Base class for mixed graphs. More...

#include <mixedGraph.h>

Inheritance diagram for gum::MixedGraph:

Collaboration diagram for gum::MixedGraph:

Public Attributes
Signaler1< NodeId >	onNodeAdded

Signaler1< NodeId >	onNodeDeleted

Signaler2< NodeId, NodeId >	onEdgeAdded

Signaler2< NodeId, NodeId >	onEdgeDeleted

Signaler2< NodeId, NodeId >	onArcAdded

Signaler2< NodeId, NodeId >	onArcDeleted

Public Member Functions
Constructors / Destructors
	MixedGraph (Size nodes_size=HashTableConst::default_size, bool nodes_resize_policy=true, Size arcs_size=HashTableConst::default_size, bool arcs_resize_policy=true, Size edges_size=HashTableConst::default_size, bool edges_resize_policy=true)
	default constructor More...

	MixedGraph (const MixedGraph &g)
	copy constructor More...

virtual	~MixedGraph ()
	destructor More...

Operators
MixedGraph &	operator= (const MixedGraph &g)
	copy operator More...

bool	operator== (const MixedGraph &g) const
	tests whether two MixedGraphs are identical (same nodes, arcs and edges) More...

bool	operator!= (const MixedGraph &g) const
	tests whether two MixedGraphs are different More...

Accessors/Modifiers
virtual void	eraseNode (const NodeId id)
	remove a node as well as its adjacent arcs and edges from the graph More...

virtual void	clear ()
	removes all the nodes, arcs and edges from the graph More...

const std::vector< NodeId >	mixedOrientedPath (const NodeId node1, const NodeId node2) const
	returns a mixed edge/directed arc path from node1 to node2 in the arc/edge set More...

const std::vector< NodeId >	mixedUnorientedPath (const NodeId node1, const NodeId node2) const
	returns a mixed/directed path from node1 to node2 in the arc/edge set More...

virtual const std::string	toDot () const
	to friendly display mixed graph in DOT format More...

virtual const std::string	toString () const
	to friendly display the content of the MixedGraph More...

Operators
bool	operator== (const UndiGraph &g) const
	tests whether two UndiGraphs are identical (same nodes, same edges) More...

bool	operator!= (const UndiGraph &g) const
	tests whether two UndiGraphs are different More...

Operators
bool	operator== (const NodeGraphPart &p) const
	check whether two NodeGraphParts contain the same nodes More...

bool	operator!= (const NodeGraphPart &p) const
	check whether two NodeGraphParts contain different nodes More...

Operators
bool	operator== (const EdgeGraphPart &p) const
	tests whether two EdgeGraphParts contain the same edges More...

bool	operator!= (const EdgeGraphPart &p) const
	tests whether two EdgeGraphParts contain different edges More...

Accessors/Modifiers
virtual void	addEdge (const NodeId first, const NodeId second)
	insert a new edge into the undirected graph More...

bool	hasUndirectedCycle () const
	checks whether the graph contains cycles More...

virtual UndiGraph	partialUndiGraph (NodeSet nodesSet)
	returns the partial graph formed by the nodes given in parameter More...

Accessors/Modifiers
void	populateNodes (const NodeGraphPart &s)
	populateNodes clears *this and fills it with the same nodes as "s" More...

template<typename T >
void	populateNodesFromProperty (const NodeProperty< T > &h)
	populateNodesFromProperty clears *this and fills it with the keys of "h" More...

NodeId	nextNodeId () const
	returns a new node id, not yet used by any node More...

virtual NodeId	addNode ()
	insert a new node and return its id More...

std::vector< NodeId >	addNodes (Size n)
	insert n nodes More...

virtual void	addNodeWithId (const NodeId id)
	try to insert a node with the given id More...

bool	existsNode (const NodeId id) const
	returns true iff the NodeGraphPart contains the given nodeId More...

bool	exists (const NodeId id) const
	alias for existsNode More...

bool	emptyNodes () const
	indicates whether there exists nodes in the NodeGraphPart More...

bool	empty () const
	alias for emptyNodes More...

virtual void	clearNodes ()
	remove all the nodes from the NodeGraphPart More...

Size	sizeNodes () const
	returns the number of nodes in the NodeGraphPart More...

Size	size () const
	alias for sizeNodes More...

NodeId	bound () const
	returns a number n such that all node ids are strictly lower than n More...

NodeSet	asNodeSet () const
	returns a copy of the set of nodes represented by the NodeGraphPart More...

const NodeGraphPart &	nodes () const
	return *this as a NodeGraphPart More...

node_iterator_safe	beginSafe () const
	a begin iterator to parse the set of nodes contained in the NodeGraphPart More...

const node_iterator_safe &	endSafe () const noexcept
	the end iterator to parse the set of nodes contained in the NodeGraphPart More...

node_iterator	begin () const noexcept
	a begin iterator to parse the set of nodes contained in the NodeGraphPart More...

const node_iterator &	end () const noexcept
	the end iterator to parse the set of nodes contained in the NodeGraphPart More...

template<typename VAL >
NodeProperty< VAL >	nodesProperty (VAL(*f)(const NodeId &), Size size=0) const
	a method to create a HashTable with key:NodeId and value:VAL More...

template<typename VAL >
NodeProperty< VAL >	nodesProperty (const VAL &a, Size size=0) const
	a method to create a hashMap with key:NodeId and value:VAL More...

template<typename VAL >
List< VAL >	listMapNodes (VAL(*f)(const NodeId &)) const
	a method to create a list of VAL from a set of nodes (using for every nodee, say x, the VAL f(x)) More...

Accessors/Modifiers
virtual void	eraseEdge (const Edge &edge)
	removes an edge from the EdgeGraphPart More...

bool	existsEdge (const Edge &edge) const
	indicates whether a given edge exists More...

bool	existsEdge (const NodeId n1, const NodeId n2) const
	indicates whether a given edge exists More...

bool	emptyEdges () const
	indicates wether the EdgeGraphPart contains any edge More...

virtual void	clearEdges ()
	removes all the edges from the EdgeGraphPart More...

Size	sizeEdges () const
	indicates the number of edges stored within the EdgeGraphPart More...

const EdgeSet &	edges () const
	returns the set of edges stored within the EdgeGraphPart More...

const NodeSet &	neighbours (const NodeId id) const
	returns the set of edges adjacent to a given node More...

void	eraseNeighbours (const NodeId id)
	erase all the edges adjacent to a given node More...

void	unvirtualizedEraseNeighbours (const NodeId id)
	same function as eraseNeighbours but without any virtual call to an erase More...

template<typename VAL >
EdgeProperty< VAL >	edgesProperty (VAL(*f)(const Edge &), Size size=0) const
	a method to create a hashMap of VAL from a set of edges (using for every edge, say x, the VAL f(x)) More...

template<typename VAL >
EdgeProperty< VAL >	edgesProperty (const VAL &a, Size size=0) const
	a method to create a hashMap of VAL from a set of edges (using for every edge, say x, the VAL a) More...

template<typename VAL >
List< VAL >	listMapEdges (VAL(*f)(const Edge &)) const
	a method to create a list of VAL from a set of edges (using for every edge, say x, the VAL f(x)) More...

const std::vector< NodeId >	undirectedPath (const NodeId node1, const NodeId node2) const
	returns a possible path from node1 to node2 in the edge set More...

Operators
bool	operator== (const DiGraph &g) const
	tests whether two DiGraphs are identical (same nodes, same arcs) More...

bool	operator!= (const DiGraph &g) const
	tests whether two DiGraphs are different More...

Operators
bool	operator== (const ArcGraphPart &p) const
	tests whether two ArcGraphParts contain the same arcs More...

bool	operator!= (const ArcGraphPart &p) const
	tests whether two ArcGraphParts contain different arcs More...

Accessors/Modifiers
virtual void	addArc (const NodeId tail, const NodeId head)
	insert a new arc into the directed graph 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...

Accessors/Modifiers
virtual void	eraseArc (const Arc &arc)
	removes an arc from the ArcGraphPart More...

bool	existsArc (const Arc &arc) const
	indicates whether a given arc exists More...

bool	existsArc (const NodeId tail, const NodeId head) const
	indicates whether a given arc exists More...

bool	emptyArcs () const
	indicates wether the ArcGraphPart contains any arc More...

void	clearArcs ()
	removes all the arcs from the ArcGraphPart More...

Size	sizeArcs () const
	indicates the number of arcs stored within the ArcGraphPart More...

const ArcSet &	arcs () const
	returns the set of arcs stored within the ArcGraphPart More...

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

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

void	eraseParents (const NodeId id)
	erase all the parents of a given node More...

void	unvirtualizedEraseParents (const NodeId id)
	same function as eraseParents but without any virtual call to an erase More...

void	eraseChildren (const NodeId id)
	removes all the children of a given node More...

void	unvirtualizedEraseChildren (const NodeId id)
	same function as eraseChildren but without any virtual call to an erase More...

template<typename VAL >
ArcProperty< VAL >	arcsProperty (VAL(*f)(const Arc &), Size size=0) const
	a method to create a hashMap of VAL from a set of arcs (using for every arc, say x, the VAL f(x)) More...

template<typename VAL >
ArcProperty< VAL >	arcsProperty (const VAL &a, Size size=0) const
	a method to create a hashMap of VAL from a set of arcs (using for every arc, say x, the VAL a) More...

template<typename VAL >
List< VAL >	listMapArcs (VAL(*f)(const Arc &)) const
	a method to create a list of VAL from a set of arcs (using for every arc, say x, the VAL f(x)) More...

const std::vector< NodeId >	directedPath (const NodeId node1, const NodeId node2) const
	returns a directed path from node1 to node2 belonging to the set of arcs More...

const std::vector< NodeId >	directedUnorientedPath (const NodeId node1, const NodeId node2) const
	returns an unoriented (directed) path from node1 to node2 in the arc set More...

Public Types
typedef NodeGraphPartIterator	NodeIterator

typedef NodeGraphPartIterator	NodeConstIterator

typedef NodeGraphPartIteratorSafe	NodeIteratorSafe

typedef NodeGraphPartIteratorSafe	NodeConstIteratorSafe

typedef EdgeSetIterator	EdgeIterator

typedef ArcSetIterator	ArcIterator


using	node_iterator = NodeGraphPartIterator
	types for STL compliance More...

using	node_const_iterator = NodeGraphPartIterator
	types for STL compliance More...

using	node_iterator_safe = NodeGraphPartIteratorSafe
	types for STL compliance More...

using	node_const_iterator_safe = NodeGraphPartIteratorSafe
	types for STL compliance More...

Protected Member Functions
void	_eraseSetOfArcs (const ArcSet &set)
	a (virtualized) function to remove a given set of arcs More...

void	_unvirtualizedEraseSetOfArcs (const ArcSet &set)
	similar to _eraseSetOfArcs except that it is unvirtualized More...

Detailed Description

Base class for mixed graphs.

Usage example:: // creating empty graphs
MixedGraph g1,g2;
// adding nodes, arcs and edges to g1
NodeId i1=g1.addNode();
NodeId i2=g1.addNode();
NodeId i3=g1.addNode();
g1.addArc( i1,i2 );
g1.addArc( i1,i3 );
g1.addArc( i2,i3 );
g1.addEdge( i1,i2 );
g1.addEdge( i1,i3 );
g1.addEdge( i2,i3 );
//throw an InvalidNode
// g1.addArc( i1+i2+i3,i1 );
// g1.addEdge( i1+i2+i3,i1 );
// copying graphs
MixedGraph g3 = g1;
g2 = g1;
MixedGraph g4=g1;
// check if a graph has no node
if ( g1.empty() ) cerr << "graph g1 is empty" << endl;
// remove all the nodes (as well as their adjacent arcs and edges)
g1.clear();
// remove some arc
g4.eraseArc( Arc ( i1,i3 ) );
// remove some edge
g4.eraseEdge( Edge ( i1,i3 ) );
// remove node
g2.eraseNode( i2 );
// parse a graph
for ( const auto nod : g3.nodes() )
cerr << nod << endl;
for ( const auto arc : g3.arcs() )
cerr << arc << endl;
for ( const auto edg : g3.edges()) )
cerr << edg << endl;
const NodeSet& a=g3.parents( 3 );
for ( const auto iter : a)
cerr << " - "<<iter;
cerr<<endl;
const NodeSet& a=g3.neighbours( 3 );
for ( NodeSetIterator iter = a.begin( ); iter != a.end(); ++iter )
cerr << " - "<<*iter;
cerr<<endl;
// remove all the arcs that are parent of a given node
g3.eraseParents( 2 );
// remove all the edges that are adjacent to a given node
g3.eraseNeighbours( 2 );

Definition at line 124 of file mixedGraph.h.

Member Typedef Documentation

◆ ArcIterator

typedef ArcSetIterator gum::ArcGraphPart::ArcIterator

inherited

Definition at line 78 of file arcGraphPart.h.

◆ EdgeIterator

typedef EdgeSetIterator gum::EdgeGraphPart::EdgeIterator

inherited

Definition at line 74 of file edgeGraphPart.h.

◆ node_const_iterator

using gum::NodeGraphPart::node_const_iterator = NodeGraphPartIterator

inherited

types for STL compliance

Definition at line 258 of file nodeGraphPart.h.

◆ node_const_iterator_safe

using gum::NodeGraphPart::node_const_iterator_safe = NodeGraphPartIteratorSafe

inherited

types for STL compliance

Definition at line 260 of file nodeGraphPart.h.

◆ node_iterator

using gum::NodeGraphPart::node_iterator = NodeGraphPartIterator

inherited

types for STL compliance

Definition at line 257 of file nodeGraphPart.h.

◆ node_iterator_safe

using gum::NodeGraphPart::node_iterator_safe = NodeGraphPartIteratorSafe

inherited

types for STL compliance

Definition at line 259 of file nodeGraphPart.h.

◆ NodeConstIterator

typedef NodeGraphPartIterator gum::NodeGraphPart::NodeConstIterator

inherited

Definition at line 267 of file nodeGraphPart.h.

◆ NodeConstIteratorSafe

typedef NodeGraphPartIteratorSafe gum::NodeGraphPart::NodeConstIteratorSafe

inherited

Definition at line 269 of file nodeGraphPart.h.

◆ NodeIterator

typedef NodeGraphPartIterator gum::NodeGraphPart::NodeIterator

inherited

Definition at line 266 of file nodeGraphPart.h.

◆ NodeIteratorSafe

typedef NodeGraphPartIteratorSafe gum::NodeGraphPart::NodeIteratorSafe

inherited

Definition at line 268 of file nodeGraphPart.h.

Constructor & Destructor Documentation

◆ MixedGraph() [1/2]

gum::MixedGraph::MixedGraph	(	Size	nodes_size = `HashTableConst::default_size`,
		bool	nodes_resize_policy = `true`,
		Size	arcs_size = `HashTableConst::default_size`,
		bool	arcs_resize_policy = `true`,
		Size	edges_size = `HashTableConst::default_size`,
		bool	edges_resize_policy = `true`
	)

explicit

default constructor

Parameters

nodes_size	the size of the hash table used to store all the nodes
nodes_resize_policy	the resizing policy of this hash table
arcs_size	the size of the hash table used to store all the arcs
arcs_resize_policy	the resizing policy of this hash table
edges_size	the size of the hash table used to store all the edges
edges_resize_policy	the resizing policy of this hash table

Definition at line 34 of file mixedGraph.cpp.

                                                    :
       // Note that we need to initialize the NodeGraphPart by ourselves
       // because
       // it is a virtual inherited class (see C++ FAQ Lite #25.12 for details)
       NodeGraphPart(nodes_size, nodes_resize_policy),
       UndiGraph(edges_size, edges_resize_policy),
       DiGraph(arcs_size, arcs_resize_policy) {
     // for debugging purposes
     GUM_CONSTRUCTOR(MixedGraph);
   }

◆ MixedGraph() [2/2]

gum::MixedGraph::MixedGraph ( const MixedGraph & g )

copy constructor

Parameters

g	the MixedGraph to copy

Definition at line 50 of file mixedGraph.cpp.

                                             :
       NodeGraphPart(g), UndiGraph(g), DiGraph(g) {
     // for debugging purposes
     GUM_CONS_CPY(MixedGraph);
   }

◆ ~MixedGraph()

gum::MixedGraph::~MixedGraph ( )

virtual

destructor

Definition at line 56 of file mixedGraph.cpp.

                           {
     // for debugging purposes
     GUM_DESTRUCTOR(MixedGraph);
   }

Member Function Documentation

◆ _eraseSetOfArcs()

INLINE void gum::ArcGraphPart::_eraseSetOfArcs ( const ArcSet & set )

protectedinherited

a (virtualized) function to remove a given set of arcs

Warning: this function uses eraseArc, which is a virtual function. Hence the behaviour of this function is that of a virtual function

Definition at line 88 of file arcGraphPart_inl.h.

References gum::ArcGraphPart::eraseArc().

                                                              {
     for (const auto arc : set)
       eraseArc(arc);
   }

Here is the call graph for this function:

◆ _unvirtualizedEraseSetOfArcs()

INLINE void gum::ArcGraphPart::_unvirtualizedEraseSetOfArcs ( const ArcSet & set )

protectedinherited

similar to _eraseSetOfArcs except that it is unvirtualized

Warning: this function uses ArcGraphPart::eraseArc, hence, as compared with _eraseSetOfArcs, it removes the arcs without calling a virtual eraseArc

Definition at line 121 of file arcGraphPart_inl.h.

References gum::ArcGraphPart::eraseArc().

                                                                           {
     for (const auto& arc : set)
       ArcGraphPart::eraseArc(arc);
   }

Here is the call graph for this function:

◆ addArc()

INLINE void gum::DiGraph::addArc	(	const NodeId	tail,
		const NodeId	head
	)

virtualinherited

insert a new arc into the directed graph

Parameters

tail	the id of the tail of the new inserted arc
head	the id of the head of the new inserted arc

Warning: if the arc already exists, nothing is done. In particular, no exception is raised.

Exceptions

InvalidNode if head or tail does not belong to the graph nodes

Reimplemented from gum::ArcGraphPart.

Reimplemented in gum::DAG.

Definition at line 32 of file diGraph_inl.h.

References gum::ArcGraphPart::addArc(), gum::NodeGraphPart::exists(), and GUM_ERROR.

Referenced by gum::EssentialGraph::__buildEssentialGraph(), gum::MarkovBlanket::__buildMarkovBlanket(), gum::learning::Miic::_orientation_3off2(), gum::learning::Miic::_orientation_latents(), gum::learning::Miic::_orientation_miic(), gum::learning::Miic::_propagatesHead(), gum::prm::gspan::Pattern::addArc(), gum::DAG::addArc(), and gum::DAGCycleDetector::addArc().

                                                                   {
     if (!exists(head)) { GUM_ERROR(InvalidNode, "head node"); }
 
     if (!exists(tail)) { GUM_ERROR(InvalidNode, "tail node"); }
 
     ArcGraphPart::addArc(tail, head);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addEdge()

INLINE void gum::UndiGraph::addEdge	(	const NodeId	first,
		const NodeId	second
	)

virtualinherited

insert a new edge into the undirected graph

The order in which the extremal nodes are specified is not important.

Parameters

first	the id of one extremal node of the new inserted edge
second	the id of the other extremal node of the new inserted edge

Warning: if the edge already exists, nothing is done. In particular, no exception is raised.

Exceptions

InvalidNode if first and/or second do not belong to the graph nodes

Reimplemented from gum::EdgeGraphPart.

Reimplemented in gum::CliqueGraph.

Definition at line 32 of file undiGraph_inl.h.

References gum::EdgeGraphPart::addEdge(), gum::NodeGraphPart::exists(), and GUM_ERROR.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__addEdgesInReducedGraph(), gum::EssentialGraph::__buildEssentialGraph(), gum::prm::gspan::StrictSearch< GUM_SCALAR >::__buildPatternGraph(), gum::prm::StructuredInference< GUM_SCALAR >::__buildPatternGraph(), gum::SpanningForestPrim::__computeInAComponent(), gum::prm::gspan::DFSTree< GUM_SCALAR >::__initialiaze_root(), gum::DAGmodel::__moralGraph(), gum::learning::genericBNLearner::__prepare_miic_3off2(), gum::prm::GSpan< GUM_SCALAR >::__sortPatterns(), gum::StaticTriangulation::__triangulate(), gum::InfluenceDiagram< GUM_SCALAR >::_moralGraph(), gum::prm::StructuredInference< GUM_SCALAR >::CData::CData(), gum::prm::gspan::DFSTree< GUM_SCALAR >::growPattern(), gum::prm::gspan::EdgeGrowth< GUM_SCALAR >::insert(), gum::prm::gspan::InterfaceGraph< GUM_SCALAR >::InterfaceGraph(), gum::DAG::moralGraph(), gum::UndiGraph::partialUndiGraph(), and gum::StaticTriangulation::triangulatedGraph().

                                                                         {
     if (!exists(first)) { GUM_ERROR(InvalidNode, "first node"); }
 
     if (!exists(second)) { GUM_ERROR(InvalidNode, "second node"); }
 
     EdgeGraphPart::addEdge(second, first);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addNode()

INLINE NodeId gum::NodeGraphPart::addNode ( )

virtualinherited

insert a new node and return its id

Returns: the id chosen by the internal idFactory

Reimplemented in gum::CliqueGraph.

Definition at line 250 of file nodeGraphPart_inl.h.

References GUM_EMIT1.

Referenced by gum::prm::gspan::DFSTree< GUM_SCALAR >::__addChild(), gum::prm::StructuredInference< GUM_SCALAR >::__addEdgesInReducedGraph(), gum::prm::o3prm::O3InterfaceFactory< GUM_SCALAR >::__addInterface2Dag(), gum::prm::ClassDependencyGraph< GUM_SCALAR >::__addNode(), gum::prm::o3prm::O3TypeFactory< GUM_SCALAR >::__addTypes2Dag(), gum::prm::gspan::StrictSearch< GUM_SCALAR >::__buildPatternGraph(), gum::prm::StructuredInference< GUM_SCALAR >::__buildPatternGraph(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::__checkAndAddNodesToDag(), gum::prm::LayerGenerator< GUM_SCALAR >::__generateClassDag(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateClassDag(), gum::prm::gspan::DFSTree< GUM_SCALAR >::__initialiaze_root(), gum::IncrementalGraphLearner< AttributeSelection, isScalar >::_insertNode(), gum::prm::gspan::DFSTree< GUM_SCALAR >::addRoot(), gum::prm::gspan::DFSTree< GUM_SCALAR >::growPattern(), gum::IncrementalGraphLearner< AttributeSelection, isScalar >::IncrementalGraphLearner(), gum::prm::gspan::EdgeGrowth< GUM_SCALAR >::insert(), and gum::LeafAggregator::update().

                                        {
     NodeId newNode;
 
     // fill the first hole if holes exist
     if (__holes && (!__holes->empty())) {
       newNode = *(__holes->begin());
       __eraseHole(newNode);
     } else {
       newNode = __boundVal;
       ++__boundVal;
       __updateEndIteratorSafe();
     }
 
     GUM_EMIT1(onNodeAdded, newNode);
 
     return newNode;
   }

Here is the caller graph for this function:

◆ addNodes()

INLINE std::vector< NodeId > gum::NodeGraphPart::addNodes ( Size n )

inherited

insert n nodes

Parameters

n	the number of nodes to add

Returns: the vector of chosen ids

Definition at line 268 of file nodeGraphPart_inl.h.

                                                            {
     std::vector< NodeId > v;
     v.reserve(N);
     for (Idx i = 0; i < N; i++)
       v.push_back(this->addNode());
     return v;
   }

◆ addNodeWithId()

void gum::NodeGraphPart::addNodeWithId ( const NodeId id )

virtualinherited

try to insert a node with the given id

Warning: This method should be carefully used. Please prefer populateNodes or populateNodesFromProperty when possible

Exceptions

DuplicateElement exception if the id already exists

Definition at line 129 of file nodeGraphPart.cpp.

References gum::NodeGraphPart::__boundVal, gum::NodeGraphPart::__eraseHole(), gum::NodeGraphPart::__holes, gum::NodeGraphPart::__holes_resize_policy, gum::NodeGraphPart::__holes_size, gum::NodeGraphPart::__inHoles(), gum::NodeGraphPart::__updateEndIteratorSafe(), GUM_EMIT1, GUM_ERROR, gum::Set< Key, Alloc >::insert(), and gum::NodeGraphPart::onNodeAdded.

Referenced by gum::EssentialGraph::__buildEssentialGraph(), gum::MarkovBlanket::__buildMarkovBlanket(), gum::SpanningForestPrim::__computeInAComponent(), gum::learning::genericBNLearner::__learnDAG(), gum::learning::genericBNLearner::__prepare_miic_3off2(), gum::prm::GSpan< GUM_SCALAR >::__sortPatterns(), gum::InfluenceDiagram< GUM_SCALAR >::_addNode(), gum::InfluenceDiagram< GUM_SCALAR >::_moralGraph(), gum::prm::gspan::Pattern::addNodeWithLabel(), gum::prm::StructuredInference< GUM_SCALAR >::CData::CData(), gum::InfluenceDiagram< GUM_SCALAR >::getDecisionGraph(), gum::BayesNetFragment< GUM_SCALAR >::installNode(), gum::prm::gspan::InterfaceGraph< GUM_SCALAR >::InterfaceGraph(), gum::learning::Miic::learnStructure(), gum::UndiGraph::partialUndiGraph(), and gum::learning::StructuralConstraintDAG::StructuralConstraintDAG().

                                                    {
     if (id >= __boundVal) {
       if (id > __boundVal) {   // we have to add holes
         if (!__holes) __holes = new NodeSet(__holes_size, __holes_resize_policy);
 
         for (NodeId i = __boundVal; i < id; ++i)
           __holes->insert(i);
       }
 
       __boundVal = id + 1;
 
       __updateEndIteratorSafe();
     } else {
       if (__inHoles(id)) {   // we fill a hole
         __eraseHole(id);
       } else {
         GUM_ERROR(DuplicateElement, "Id " << id << " is already used");
       }
     }
 
     GUM_EMIT1(onNodeAdded, id);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ arcs()

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

inherited

returns the set of arcs stored within the ArcGraphPart

Definition at line 36 of file arcGraphPart_inl.h.

References gum::ArcGraphPart::__arcs.

Referenced by gum::MarkovBlanket::arcs(), gum::EssentialGraph::arcs(), gum::DAGmodel::arcs(), gum::prm::gspan::Pattern::arcs(), gum::learning::DAG2BNLearner< ALLOC >::createBN(), gum::DAG::moralGraph(), and gum::DiGraph::toDot().

36 { return __arcs; }

gum::ArcGraphPart::__arcs

Set< Arc > __arcs

the set of all the arcs contained within the ArcGraphPart

Definition: arcGraphPart.h:266

Here is the caller graph for this function:

◆ arcsProperty() [1/2]

template<typename VAL >

ArcProperty< VAL > gum::ArcGraphPart::arcsProperty	(	VAL(*)(const Arc &)	f,
		Size	size = `0`
	)		const

inherited

a method to create a hashMap of VAL from a set of arcs (using for every arc, say x, the VAL f(x))

Parameters

f	a function assigning a VAL to any arc
size	an optional parameter enabling to fine-tune the returned Property. Roughly speaking, it is a good practice to have a size equal to half the number of arcs. If you do not specify this parameter, the method will assign it for you.

◆ arcsProperty() [2/2]

template<typename VAL >

ArcProperty< VAL > gum::ArcGraphPart::arcsProperty	(	const VAL &	a,
		Size	size = `0`
	)		const

inherited

a method to create a hashMap of VAL from a set of arcs (using for every arc, say x, the VAL a)

Parameters

a	the default value assigned to each arc in the returned Property
size	an optional parameter enabling to fine-tune the returned Property. Roughly speaking, it is a good practice to have a size equal to half the number of arcs. If you do not specify this parameter, the method will assign it for you.

◆ asNodeSet()

INLINE NodeSet gum::NodeGraphPart::asNodeSet ( ) const

inherited

returns a copy of the set of nodes represented by the NodeGraphPart

Warning: this function is o(n) where n is the number of nodes. In space and in time. Usually, when you need to parse the nodes of a NodeGraphPart, prefer using
for(const auto n : nodes())
rather than
for(const auto n : asNodeSet())
as this is faster and consumes much less memory.

Definition at line 358 of file nodeGraphPart_inl.h.

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

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

                                                 {
     NodeSet son(sizeNodes());
 
     if (!empty()) {
       for (NodeId n = 0; n < __boundVal; ++n) {
         if (!__inHoles(n)) son.insert(n);
       }
     }
 
     return son;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ begin()

INLINE NodeGraphPartIterator gum::NodeGraphPart::begin ( ) const

noexceptinherited

a begin iterator to parse the set of nodes contained in the NodeGraphPart

Definition at line 330 of file nodeGraphPart_inl.h.

References gum::NodeGraphPartIterator::_validate().

Referenced by gum::prm::gspan::DFSTree< GUM_SCALAR >::parent().

                                                                    {
     NodeGraphPartIterator it(*this);
     it._validate();   // stop the iterator at the first not-in-holes
     return it;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ beginSafe()

INLINE NodeGraphPartIteratorSafe gum::NodeGraphPart::beginSafe ( ) const

inherited

a begin iterator to parse the set of nodes contained in the NodeGraphPart

Definition at line 316 of file nodeGraphPart_inl.h.

References gum::NodeGraphPartIterator::_validate().

                                                                   {
     NodeGraphPartIteratorSafe it(*this);
     it._validate();   // stop the iterator at the first not-in-holes
     return it;
   }

Here is the call graph for this function:

◆ bound()

INLINE NodeId gum::NodeGraphPart::bound ( ) const

inherited

returns a number n such that all node ids are strictly lower than n

Definition at line 305 of file nodeGraphPart_inl.h.

Referenced by gum::NodeGraphPart::__clearNodes(), gum::StaticTriangulation::__computeEliminationTree(), gum::NodeGraphPartIterator::_setPos(), and gum::NodeGraphPartIterator::_validate().

305 { return __boundVal; }

gum::NodeGraphPart::__boundVal

NodeId __boundVal

the id below which NodeIds may belong to the NodeGraphPart

Definition: nodeGraphPart.h:511

Here is the caller graph for this function:

◆ children()

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

inherited

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

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

Parameters

id	the node which is the tail of the arcs returned

Definition at line 59 of file arcGraphPart_inl.h.

References gum::ArcGraphPart::__checkChildren(), and gum::ArcGraphPart::__children.

Referenced by gum::MCBayesNetGenerator< GUM_SCALAR, ICPTGenerator, ICPTDisturber >::__AR(), gum::EssentialGraph::__buildEssentialGraph(), gum::MCBayesNetGenerator< GUM_SCALAR, ICPTGenerator, ICPTDisturber >::__connect(), gum::MCBayesNetGenerator< GUM_SCALAR, ICPTGenerator, ICPTDisturber >::__directedPath(), gum::prm::gspan::Pattern::__expandCodeIsMinimal(), gum::DAG::__hasDirectedPath(), gum::prm::gspan::Pattern::__not_rec(), gum::prm::gspan::Pattern::__rec(), gum::InfluenceDiagram< GUM_SCALAR >::_getChildrenDecision(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::_initialize(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::_makeInferenceNodeToNeighbours(), gum::ArcGraphPart::ArcGraphPart(), gum::MarkovBlanket::children(), gum::EssentialGraph::children(), gum::DAGmodel::children(), gum::ArcGraphPart::directedUnorientedPath(), gum::InfluenceDiagram< GUM_SCALAR >::erase(), gum::ArcGraphPart::eraseChildren(), gum::InfluenceDiagram< GUM_SCALAR >::existsPathBetween(), gum::prm::gspan::Pattern::isMinimal(), mixedUnorientedPath(), gum::BayesBall::relevantPotentials(), gum::dSeparation::relevantPotentials(), gum::prm::gspan::Pattern::remove(), gum::BayesBall::requisiteNodes(), gum::dSeparation::requisiteNodes(), gum::MarkovBlanket::toDot(), gum::EssentialGraph::toDot(), gum::InfluenceDiagram< GUM_SCALAR >::toDot(), toDot(), and gum::ArcGraphPart::unvirtualizedEraseChildren().

                                                                     {
     __checkChildren(id);
     return *(__children[id]);
   }

Here is the call graph for this function:

◆ clear()

INLINE void gum::MixedGraph::clear ( )

virtual

removes all the nodes, arcs and edges from the graph

Reimplemented from gum::DiGraph.

Definition at line 46 of file mixedGraph_inl.h.

References gum::ArcGraphPart::clearArcs(), gum::EdgeGraphPart::clearEdges(), and gum::NodeGraphPart::clearNodes().

Referenced by gum::EssentialGraph::__buildEssentialGraph().

                                 {
     EdgeGraphPart::clearEdges();
     ArcGraphPart::clearArcs();
     NodeGraphPart::clearNodes();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clearArcs()

void gum::ArcGraphPart::clearArcs ( )

inherited

removes all the arcs from the ArcGraphPart

Definition at line 76 of file arcGraphPart.cpp.

References gum::ArcGraphPart::__arcs, gum::ArcGraphPart::__children, gum::ArcGraphPart::__parents, gum::Set< Key, Alloc >::clear(), GUM_EMIT2, and gum::ArcGraphPart::onArcDeleted.

Referenced by gum::DiGraph::clear(), clear(), gum::ArcGraphPart::operator=(), operator=(), and gum::ArcGraphPart::~ArcGraphPart().

                                {
     for (const auto& elt : __parents)
       delete elt.second;
 
     __parents.clear();
 
     for (const auto& elt : __children)
       delete elt.second;
 
     __children.clear();
 
     // we need this copy only if at least one onArcDeleted listener exists
     if (onArcDeleted.hasListener()) {
       ArcSet tmp = __arcs;
       __arcs.clear();
 
       for (const auto& arc : tmp)
         GUM_EMIT2(onArcDeleted, arc.tail(), arc.head());
     } else {
       __arcs.clear();
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clearEdges()

void gum::EdgeGraphPart::clearEdges ( )

virtualinherited

removes all the edges from the EdgeGraphPart

Reimplemented in gum::CliqueGraph.

Definition at line 64 of file edgeGraphPart.cpp.

References gum::EdgeGraphPart::__edges, gum::EdgeGraphPart::__neighbours, gum::Set< Key, Alloc >::clear(), GUM_EMIT2, and gum::EdgeGraphPart::onEdgeDeleted.

Referenced by gum::UndiGraph::clear(), clear(), gum::EdgeGraphPart::operator=(), operator=(), and gum::EdgeGraphPart::~EdgeGraphPart().

                                  {
     for (const auto& elt : __neighbours)
       delete elt.second;
 
     __neighbours.clear();
 
     if (onEdgeDeleted.hasListener()) {
       EdgeSet tmp = __edges;
       __edges.clear();
 
       for (const auto& edge : tmp)
         GUM_EMIT2(onEdgeDeleted, edge.first(), edge.second());
     } else {
       __edges.clear();
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clearNodes()

INLINE void gum::NodeGraphPart::clearNodes ( )

virtualinherited

remove all the nodes from the NodeGraphPart

Definition at line 307 of file nodeGraphPart_inl.h.

Referenced by gum::DiGraph::clear(), gum::UndiGraph::clear(), clear(), and operator=().

307 { __clearNodes(); }

gum::NodeGraphPart::__clearNodes

void __clearNodes()

code for clearing nodes (called twice)

Definition: nodeGraphPart.cpp:152

Here is the caller graph for this function:

◆ directedPath()

const std::vector< NodeId > gum::ArcGraphPart::directedPath	(	const NodeId	node1,
		const NodeId	node2
	)		const

inherited

returns a directed path from node1 to node2 belonging to the set of arcs

Parameters

node1	the id from which the path begins
node2	the id to which the path ends

Exceptions

NotFound exception is raised if no path can be found between the two nodes

Definition at line 152 of file arcGraphPart.cpp.

References gum::List< Val, Alloc >::empty(), gum::HashTable< Key, Val, Alloc >::exists(), gum::List< Val, Alloc >::front(), GUM_ERROR, gum::HashTable< Key, Val, Alloc >::insert(), gum::ArcGraphPart::parents(), gum::List< Val, Alloc >::popFront(), and gum::List< Val, Alloc >::pushBack().

Referenced by gum::learning::Miic::_orientation_latents().

                                                                                 {
     // not recursive version => use a FIFO for simulating the recursion
     List< NodeId > nodeFIFO;
     nodeFIFO.pushBack(n2);
 
     // mark[node] = successor if visited, else mark[node] does not exist
     NodeProperty< NodeId > mark;
     mark.insert(n2, n2);
 
     NodeId current;
 
     while (!nodeFIFO.empty()) {
       current = nodeFIFO.front();
       nodeFIFO.popFront();
 
       // check the parents
 
       for (const auto new_one : parents(current)) {
         if (mark.exists(new_one))   // if this node is already marked, do not
           continue;                 // check it again
 
         mark.insert(new_one, current);
 
         if (new_one == n1) {
           std::vector< NodeId > v;
 
           for (current = n1; current != n2; current = mark[current])
             v.push_back(current);
 
           v.push_back(n2);
 
           return v;
         }
 
         nodeFIFO.pushBack(new_one);
       }
     }
 
     GUM_ERROR(NotFound, "no path found");
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ directedUnorientedPath()

const std::vector< NodeId > gum::ArcGraphPart::directedUnorientedPath	(	const NodeId	node1,
		const NodeId	node2
	)		const

inherited

returns an unoriented (directed) path from node1 to node2 in the arc set

Parameters

node1	the id from which the path begins
node2	the id to which the path ends

Exceptions

NotFound exception is raised if no path can be found between the two nodes

Definition at line 195 of file arcGraphPart.cpp.

References gum::ArcGraphPart::children(), gum::List< Val, Alloc >::empty(), gum::HashTable< Key, Val, Alloc >::exists(), gum::List< Val, Alloc >::front(), GUM_ERROR, gum::HashTable< Key, Val, Alloc >::insert(), gum::ArcGraphPart::parents(), gum::List< Val, Alloc >::popFront(), and gum::List< Val, Alloc >::pushBack().

                                                                                 {
     // not recursive version => use a FIFO for simulating the recursion
     List< NodeId > nodeFIFO;
     nodeFIFO.pushBack(n2);
 
     // mark[node] = successor if visited, else mark[node] does not exist
     NodeProperty< NodeId > mark;
     mark.insert(n2, n2);
 
     NodeId current;
 
     while (!nodeFIFO.empty()) {
       current = nodeFIFO.front();
       nodeFIFO.popFront();
 
       // check the parents
       for (const auto new_one : parents(current)) {
         if (mark.exists(new_one))   // the node has already been visited
           continue;
 
         mark.insert(new_one, current);
 
         if (new_one == n1) {
           std::vector< NodeId > v;
 
           for (current = n1; current != n2; current = mark[current])
             v.push_back(current);
 
           v.push_back(n2);
 
           return v;
         }
 
         nodeFIFO.pushBack(new_one);
       }
 
       // check the children
       for (const auto new_one : children(current)) {
         if (mark.exists(new_one))   // the node has already been visited
           continue;
 
         mark.insert(new_one, current);
 
         if (new_one == n1) {
           std::vector< NodeId > v;
 
           for (current = n1; current != n2; current = mark[current])
             v.push_back(current);
 
           v.push_back(n2);
 
           return v;
         }
 
         nodeFIFO.pushBack(new_one);
       }
     }
 
     GUM_ERROR(NotFound, "no path found");
   }

Here is the call graph for this function:

◆ edges()

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

inherited

returns the set of edges stored within the EdgeGraphPart

Definition at line 36 of file edgeGraphPart_inl.h.

References gum::EdgeGraphPart::__edges.

Referenced by gum::StaticTriangulation::__computeMaxPrimeJunctionTree(), gum::learning::Miic::_initiation(), gum::BarrenNodesFinder::barrenNodes(), gum::EssentialGraph::edges(), and gum::SpanningForestPrim::edgesInSpanningForest().

36 { return __edges; }

gum::EdgeGraphPart::__edges

EdgeSet __edges

the set of all the edges contained within the EdgeGraphPart

Definition: edgeGraphPart.h:223

Here is the caller graph for this function:

◆ edgesProperty() [1/2]

template<typename VAL >

EdgeProperty< VAL > gum::EdgeGraphPart::edgesProperty	(	VAL(*)(const Edge &)	f,
		Size	size = `0`
	)		const

inherited

a method to create a hashMap of VAL from a set of edges (using for every edge, say x, the VAL f(x))

Parameters

f	a function assigning a VAL to any edge
size	an optional parameter enabling to fine-tune the returned Property. Roughly speaking, it is a good practice to have a size equal to half the number of edges. If you do not specify this parameter, the method will assign it for you.

Referenced by gum::DefaultJunctionTreeStrategy::__computeJunctionTree().

Here is the caller graph for this function:

◆ edgesProperty() [2/2]

template<typename VAL >

EdgeProperty< VAL > gum::EdgeGraphPart::edgesProperty	(	const VAL &	a,
		Size	size = `0`
	)		const

inherited

a method to create a hashMap of VAL from a set of edges (using for every edge, say x, the VAL a)

Parameters

a	the default value assigned to each edge in the returned Property
size	an optional parameter enabling to fine-tune the returned Property. Roughly speaking, it is a good practice to have a size equal to half the number of edges. If you do not specify this parameter, the method will assign it for you.

◆ empty()

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

inherited

alias for emptyNodes

Definition at line 303 of file nodeGraphPart_inl.h.

Referenced by gum::prm::gspan::Pattern::remove().

303 { return emptyNodes(); }

gum::NodeGraphPart::emptyNodes

bool emptyNodes() const

indicates whether there exists nodes in the NodeGraphPart

Definition: nodeGraphPart_inl.h:301

Here is the caller graph for this function:

◆ emptyArcs()

INLINE bool gum::ArcGraphPart::emptyArcs ( ) const

inherited

indicates wether the ArcGraphPart contains any arc

Definition at line 32 of file arcGraphPart_inl.h.

References gum::ArcGraphPart::__arcs, and gum::Set< Key, Alloc >::empty().

32 { return __arcs.empty(); }

gum::Set::empty

bool empty() const noexcept

Indicates whether the set is the empty set.

Definition: set_tpl.h:704

gum::ArcGraphPart::__arcs

Set< Arc > __arcs

the set of all the arcs contained within the ArcGraphPart

Definition: arcGraphPart.h:266

Here is the call graph for this function:

◆ emptyEdges()

INLINE bool gum::EdgeGraphPart::emptyEdges ( ) const

inherited

indicates wether the EdgeGraphPart contains any edge

Definition at line 32 of file edgeGraphPart_inl.h.

References gum::EdgeGraphPart::__edges, and gum::Set< Key, Alloc >::empty().

32 { return __edges.empty(); }

gum::Set::empty

bool empty() const noexcept

Indicates whether the set is the empty set.

Definition: set_tpl.h:704

gum::EdgeGraphPart::__edges

EdgeSet __edges

the set of all the edges contained within the EdgeGraphPart

Definition: edgeGraphPart.h:223

Here is the call graph for this function:

◆ emptyNodes()

INLINE bool gum::NodeGraphPart::emptyNodes ( ) const

inherited

indicates whether there exists nodes in the NodeGraphPart

Definition at line 301 of file nodeGraphPart_inl.h.

301 { return (sizeNodes() == 0); }

gum::NodeGraphPart::sizeNodes

Size sizeNodes() const

returns the number of nodes in the NodeGraphPart

Definition: nodeGraphPart_inl.h:277

◆ end()

INLINE const NodeGraphPartIterator & gum::NodeGraphPart::end ( ) const

noexceptinherited

the end iterator to parse the set of nodes contained in the NodeGraphPart

Definition at line 336 of file nodeGraphPart_inl.h.

                                                                         {
     return __endIteratorSafe;
   }

◆ endSafe()

INLINE const NodeGraphPartIteratorSafe & gum::NodeGraphPart::endSafe ( ) const

noexceptinherited

the end iterator to parse the set of nodes contained in the NodeGraphPart

Definition at line 326 of file nodeGraphPart_inl.h.

                                                                                 {
     return __endIteratorSafe;
   }

◆ eraseArc()

INLINE void gum::ArcGraphPart::eraseArc ( const Arc & arc )

virtualinherited

removes an arc from the ArcGraphPart

Parameters

arc	the arc to be removed

Warning: if the arc does not exist, nothing is done. In particular, no exception is thrown. However, the signal onArcDeleted is fired only if a node is effectively removed.

Definition at line 76 of file arcGraphPart_inl.h.

References gum::ArcGraphPart::__arcs, gum::ArcGraphPart::__children, gum::ArcGraphPart::__parents, gum::Set< Key, Alloc >::erase(), gum::ArcGraphPart::existsArc(), GUM_EMIT2, gum::Arc::head(), gum::ArcGraphPart::onArcDeleted, and gum::Arc::tail().

Referenced by gum::EssentialGraph::__buildEssentialGraph(), gum::prm::LayerGenerator< GUM_SCALAR >::__generateClassDag(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateClassDag(), gum::learning::genericBNLearner::__learnDAG(), gum::ArcGraphPart::_eraseSetOfArcs(), gum::learning::Miic::_orientation_3off2(), gum::learning::Miic::_orientation_latents(), gum::learning::Miic::_orientation_miic(), gum::BayesNetFragment< GUM_SCALAR >::_uninstallArc(), gum::ArcGraphPart::_unvirtualizedEraseSetOfArcs(), gum::DAGCycleDetector::eraseArc(), gum::InfluenceDiagram< GUM_SCALAR >::eraseArc(), gum::ArcGraphPart::eraseChildren(), gum::ArcGraphPart::eraseParents(), gum::learning::GreedyHillClimbing::learnStructure(), gum::learning::LocalSearchWithTabuList::learnStructure(), gum::prm::gspan::Pattern::pop_back(), gum::BayesNet< double >::reverseArc(), gum::ArcGraphPart::unvirtualizedEraseChildren(), and gum::ArcGraphPart::unvirtualizedEraseParents().

                                                    {
     // ASSUMING tail and head exists in __parents anf __children
     // (if not, it is an error)
     if (existsArc(arc)) {
       NodeId tail = arc.tail(), head = arc.head();
       __parents[head]->erase(tail);
       __children[tail]->erase(head);
       __arcs.erase(arc);
       GUM_EMIT2(onArcDeleted, tail, head);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eraseChildren()

INLINE void gum::ArcGraphPart::eraseChildren ( const NodeId id )

inherited

removes all the children of a given node

Parameters

id	the node all the children of which will be removed

Warning: although this method is not virtual, it calls method eraseArc( const Arc& arc ) and, as such, has a "virtual" behaviour. If you do not wish it to have this "virtual" behaviour, call instead method unvirtualizedEraseChildren; if no arc is a parent of id, nothing is done. In particular, no exception is thrown.

Definition at line 107 of file arcGraphPart_inl.h.

References gum::ArcGraphPart::__children, gum::Set< Key, Alloc >::beginSafe(), gum::ArcGraphPart::children(), gum::Set< Key, Alloc >::endSafe(), and gum::ArcGraphPart::eraseArc().

                                                          {
     if (__children.exists(id)) {
       NodeSet& children = *(__children[id]);
 
       for (auto iter = children.beginSafe();   // safe iterator needed here
            iter != children.endSafe();
            ++iter) {
         // warning: use this erase so that you actually use the vritualized
         // arc removal function
         eraseArc(Arc(id, *iter));
       }
     }
   }

Here is the call graph for this function:

◆ eraseEdge()

INLINE void gum::EdgeGraphPart::eraseEdge ( const Edge & edge )

virtualinherited

removes an edge from the EdgeGraphPart

Parameters

edge	the edge to be removed

Warning: if the edge does not exist, nothing is done. In particular, no exception is thrown. However, the signal onEdgeDeleted is fired only if a node is effectively removed.

Reimplemented in gum::CliqueGraph.

Definition at line 62 of file edgeGraphPart_inl.h.

References gum::EdgeGraphPart::__edges, gum::EdgeGraphPart::__neighbours, gum::Set< Key, Alloc >::erase(), gum::EdgeGraphPart::existsEdge(), gum::Edge::first(), GUM_EMIT2, gum::EdgeGraphPart::onEdgeDeleted, and gum::Edge::second().

Referenced by gum::learning::Miic::_initiation(), gum::learning::Miic::_iteration(), gum::learning::Miic::_orientation_3off2(), gum::learning::Miic::_orientation_latents(), gum::learning::Miic::_orientation_miic(), gum::learning::Miic::_propagatesHead(), gum::EdgeGraphPart::eraseNeighbours(), and gum::EdgeGraphPart::unvirtualizedEraseNeighbours().

                                                        {
     if (existsEdge(edge)) {
       // ASSUMING first and second exists in __neighbours (if not, it is an
       // error)
       NodeId id1 = edge.first(), id2 = edge.second();
 
       __neighbours[id1]->erase(id2);
       __neighbours[id2]->erase(id1);
       __edges.erase(edge);
       GUM_EMIT2(onEdgeDeleted, id1, id2);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eraseNeighbours()

INLINE void gum::EdgeGraphPart::eraseNeighbours ( const NodeId id )

inherited

erase all the edges adjacent to a given node

Parameters

id	the node the adjacent edges of which will be removed

Warning: if no edge is adjacent to id, nothing is done. In particular, no exception is thrown.; although this method is not virtual, it calls method eraseEdge( const Edge& edge ) and, as such, has a "virtual" behaviour

Definition at line 80 of file edgeGraphPart_inl.h.

References gum::EdgeGraphPart::__neighbours, gum::EdgeGraphPart::eraseEdge(), and gum::EdgeGraphPart::neighbours().

                                                             {
     if (__neighbours.exists(id)) {
       const NodeSet& set = neighbours(id);
 
       for (auto iter = set.beginSafe(); iter != set.endSafe();
            ++iter) {   // safe iterator needed here
         // warning: use this erase so that you actually use the virtualized
         // edge removal function
         eraseEdge(Edge(*iter, id));
       }
     }
   }

Here is the call graph for this function:

◆ eraseNode()

INLINE void gum::MixedGraph::eraseNode ( const NodeId id )

virtual

remove a node as well as its adjacent arcs and edges from the graph

Parameters

id	the id of the node to be removed

Warning: if the node does not exist, nothing is done. In particular, no exception is raised.

Reimplemented from gum::DiGraph.

Definition at line 52 of file mixedGraph_inl.h.

References gum::NodeGraphPart::eraseNode(), gum::ArcGraphPart::unvirtualizedEraseChildren(), gum::EdgeGraphPart::unvirtualizedEraseNeighbours(), and gum::ArcGraphPart::unvirtualizedEraseParents().

                                                    {
     EdgeGraphPart::unvirtualizedEraseNeighbours(id);
     ArcGraphPart::unvirtualizedEraseParents(id);
     ArcGraphPart::unvirtualizedEraseChildren(id);
     NodeGraphPart::eraseNode(id);
   }

Here is the call graph for this function:

◆ eraseParents()

INLINE void gum::ArcGraphPart::eraseParents ( const NodeId id )

inherited

erase all the parents of a given node

Parameters

id	the node all the parents of which will be removed

Warning: although this method is not virtual, it calls method eraseArc( const Arc& arc ) and, as such, has a "virtual" behaviour. If you do not wish it to have this "virtual" behaviour, call instead method unvirtualizedEraseParents; if no arc is a parent of id, nothing is done. In particular, no exception is thrown.

Definition at line 93 of file arcGraphPart_inl.h.

References gum::ArcGraphPart::__parents, gum::Set< Key, Alloc >::beginSafe(), gum::Set< Key, Alloc >::endSafe(), gum::ArcGraphPart::eraseArc(), and gum::ArcGraphPart::parents().

                                                         {
     if (__parents.exists(id)) {
       NodeSet& parents = *(__parents[id]);
 
       for (auto iter = parents.beginSafe();   // safe iterator needed here
            iter != parents.endSafe();
            ++iter) {
         // warning: use this erase so that you actually use the virtualized
         // arc removal function
         eraseArc(Arc(*iter, id));
       }
     }
   }

Here is the call graph for this function:

◆ exists()

INLINE bool gum::NodeGraphPart::exists ( const NodeId id ) const

inherited

alias for existsNode

Definition at line 289 of file nodeGraphPart_inl.h.

Referenced by gum::MarkovBlanket::__buildMarkovBlanket(), gum::prm::ClassBayesNet< GUM_SCALAR >::__get(), gum::DAG::__hasDirectedPath(), gum::learning::genericBNLearner::__learnDAG(), gum::prm::StructuredInference< GUM_SCALAR >::__removeNode(), gum::NodeGraphPartIterator::_setPos(), gum::prm::gspan::Pattern::addArc(), gum::DiGraph::addArc(), gum::UndiGraph::addEdge(), and gum::prm::gspan::Pattern::exists().

                                                            {
     return existsNode(node);
   }

Here is the caller graph for this function:

◆ existsArc() [1/2]

INLINE bool gum::ArcGraphPart::existsArc ( const Arc & arc ) const

inherited

indicates whether a given arc exists

Parameters

arc	the arc we test whether or not it belongs to the ArcGraphPart

Definition at line 38 of file arcGraphPart_inl.h.

References gum::ArcGraphPart::__arcs, and gum::Set< Key, Alloc >::contains().

Referenced by gum::MCBayesNetGenerator< GUM_SCALAR, ICPTGenerator, ICPTDisturber >::__AorR(), gum::MCBayesNetGenerator< GUM_SCALAR, ICPTGenerator, ICPTDisturber >::__AR(), gum::MarkovBlanket::__buildMarkovBlanket(), gum::MCBayesNetGenerator< GUM_SCALAR, ICPTGenerator, ICPTDisturber >::__connect(), gum::MCBayesNetGenerator< GUM_SCALAR, ICPTGenerator, ICPTDisturber >::__directedPath(), gum::learning::Miic::__existsDirectedPath(), gum::prm::LayerGenerator< GUM_SCALAR >::__generateClassDag(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateClassDag(), gum::MCBayesNetGenerator< GUM_SCALAR, ICPTGenerator, ICPTDisturber >::__jump_multi(), gum::MCBayesNetGenerator< GUM_SCALAR, ICPTGenerator, ICPTDisturber >::__jump_poly(), gum::prm::gspan::Pattern::__not_rec(), gum::prm::gspan::Pattern::__rec(), gum::learning::Miic::_orientation_3off2(), gum::learning::Miic::_orientation_latents(), gum::learning::Miic::_orientation_miic(), gum::learning::Miic::_updateProbaTriples(), gum::DAGCycleDetector::addArc(), gum::ArcGraphPart::eraseArc(), gum::DAGCycleDetector::eraseArc(), gum::InfluenceDiagram< GUM_SCALAR >::eraseArc(), and gum::prm::gspan::Pattern::exists().

                                                           {
     return __arcs.contains(arc);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ existsArc() [2/2]

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

inherited

indicates whether a given arc exists

Parameters

tail	the tail of the arc we test the existence in the ArcGraphPart
head	the head of the arc we test the existence in the ArcGraphPart

Definition at line 42 of file arcGraphPart_inl.h.

References gum::ArcGraphPart::__parents.

                                                                                 {
     return __parents.exists(head) && __parents[head]->exists(tail);
   }

◆ existsEdge() [1/2]

INLINE bool gum::EdgeGraphPart::existsEdge ( const Edge & edge ) const

inherited

indicates whether a given edge exists

Parameters

edge	the edge we test whether or not it belongs to the EdgeGraphPart

Definition at line 38 of file edgeGraphPart_inl.h.

References gum::EdgeGraphPart::__edges, and gum::Set< Key, Alloc >::contains().

Referenced by gum::StaticTriangulation::__computeMaxPrimeMergings(), gum::prm::GSpan< GUM_SCALAR >::__sortPatterns(), gum::EssentialGraph::__strongly_protected(), gum::StaticTriangulation::__triangulate(), gum::learning::Miic::_orientation_3off2(), gum::learning::Miic::_orientation_miic(), gum::EdgeGraphPart::eraseEdge(), gum::StaticTriangulation::fillIns(), and gum::prm::gspan::InterfaceGraph< GUM_SCALAR >::InterfaceGraph().

                                                               {
     return __edges.contains(edge);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ existsEdge() [2/2]

INLINE bool gum::EdgeGraphPart::existsEdge	(	const NodeId	n1,
		const NodeId	n2
	)		const

inherited

indicates whether a given edge exists

Parameters

n1	the id of one extremity of the edge we test the existence in the EdgeGraphPart
n2	the id of the other extremity of the edge we test the existence in the EdgeGraphPart

Definition at line 42 of file edgeGraphPart_inl.h.

References gum::EdgeGraphPart::__neighbours.

                                                                    {
     return __neighbours.exists(first) && __neighbours[first]->exists(second);
   }

◆ existsNode()

INLINE bool gum::NodeGraphPart::existsNode ( const NodeId id ) const

inherited

returns true iff the NodeGraphPart contains the given nodeId

Definition at line 283 of file nodeGraphPart_inl.h.

Referenced by gum::MarkovBlanket::__buildMarkovBlanket(), gum::SpanningForestPrim::__compute(), gum::SpanningForestPrim::__computeInAComponent(), gum::SpanningForestPrim::__exploreNode(), gum::OrderedEliminationSequenceStrategy::__isOrderNeeded(), gum::PartialOrderedEliminationSequenceStrategy::_isPartialOrderNeeded(), gum::OrderedEliminationSequenceStrategy::eliminationUpdate(), gum::DefaultPartialOrderedEliminationSequenceStrategy::eliminationUpdate(), gum::InfluenceDiagram< GUM_SCALAR >::getDecisionGraph(), gum::BayesNetFragment< GUM_SCALAR >::isInstalledNode(), gum::UndiGraph::partialUndiGraph(), gum::OrderedEliminationSequenceStrategy::setOrder(), and gum::PartialOrderedEliminationSequenceStrategy::setPartialOrder().

                                                                {
     if (node >= __boundVal) return false;
 
     return (!__inHoles(node));
   }

Here is the caller graph for this function:

◆ hasUndirectedCycle()

bool gum::UndiGraph::hasUndirectedCycle ( ) const

inherited

checks whether the graph contains cycles

Definition at line 52 of file undiGraph.cpp.

References gum::List< Val, Alloc >::empty(), gum::List< Val, Alloc >::front(), gum::List< Val, Alloc >::insert(), gum::EdgeGraphPart::neighbours(), gum::NodeGraphPart::nodes(), gum::NodeGraphPart::nodesProperty(), and gum::List< Val, Alloc >::popFront().

                                            {
     List< std::pair< NodeId, NodeId > > open_nodes;
     NodeProperty< bool >                examined_nodes = nodesProperty(false);
     std::pair< NodeId, NodeId >         thePair;
     NodeId                              current, from_current;
 
     for (const auto node : nodes()) {
       // check if the node has already been examined (if this is not the case,
       // this means that we are on a new connected component)
       if (!examined_nodes[node]) {
         // indicates that we are examining a new node
         examined_nodes[node] = true;
 
         // check recursively all the nodes of node's connected component
         thePair.first = node;
         thePair.second = node;
         open_nodes.insert(thePair);
 
         while (!open_nodes.empty()) {
           // get a node to propagate
           thePair = open_nodes.front();
           open_nodes.popFront();
 
           current = thePair.first;
           from_current = thePair.second;
 
           // check the neighbours
           for (const auto new_node : neighbours(current))
 
             // avoid to check the node we are coming from
             if (new_node != from_current) {
               if (examined_nodes[new_node])
                 return true;
               else {
                 examined_nodes[new_node] = true;
                 thePair.first = new_node;
                 thePair.second = current;
                 open_nodes.insert(thePair);
               }
             }
         }
       }
     }
 
     return false;
   }

Here is the call graph for this function:

◆ listMapArcs()

template<typename VAL >

List< VAL > gum::ArcGraphPart::listMapArcs ( VAL(*)(const Arc &) f ) const

inherited

a method to create a list of VAL from a set of arcs (using for every arc, say x, the VAL f(x))

Parameters

f	a function assigning a VAL to any arc

◆ listMapEdges()

template<typename VAL >

List< VAL > gum::EdgeGraphPart::listMapEdges ( VAL(*)(const Edge &) f ) const

inherited

a method to create a list of VAL from a set of edges (using for every edge, say x, the VAL f(x))

Parameters

f	a function assigning a VAL to any edge

◆ listMapNodes()

template<typename VAL >

List< VAL > gum::NodeGraphPart::listMapNodes ( VAL(*)(const NodeId &) f ) const

inherited

a method to create a list of VAL from a set of nodes (using for every nodee, say x, the VAL f(x))

Parameters

f	a function assigning a VAL to any node

◆ mixedOrientedPath()

const std::vector< NodeId > gum::MixedGraph::mixedOrientedPath	(	const NodeId	node1,
		const NodeId	node2
	)		const

returns a mixed edge/directed arc path from node1 to node2 in the arc/edge set

This function returns, if any, a path from node1 to node2, using edges and/or arcs (following the direction of th arcs)

Parameters

node1	the id from which the path begins
node2	the id to which the path ends

Exceptions

NotFound exception is raised if no path can be found between the two nodes

Definition at line 71 of file mixedGraph.cpp.

References gum::List< Val, Alloc >::empty(), gum::HashTable< Key, Val, Alloc >::exists(), gum::List< Val, Alloc >::front(), GUM_ERROR, gum::HashTable< Key, Val, Alloc >::insert(), gum::EdgeGraphPart::neighbours(), gum::ArcGraphPart::parents(), gum::List< Val, Alloc >::popFront(), and gum::List< Val, Alloc >::pushBack().

                                                                          {
     // not recursive version => use a FIFO for simulating the recursion
     List< NodeId > nodeFIFO;
     nodeFIFO.pushBack(n2);
 
     // mark[node] = successor if visited, else mark[node] does not exist
     NodeProperty< NodeId > mark;
     mark.insert(n2, n2);
 
     NodeId current;
 
     while (!nodeFIFO.empty()) {
       current = nodeFIFO.front();
       nodeFIFO.popFront();
 
       // check the neighbours
       for (const auto new_one : neighbours(current)) {
         if (mark.exists(new_one))   // if the node has already been visited
           continue;                 // do not check it again
 
         mark.insert(new_one, current);
 
         if (new_one == n1) {
           std::vector< NodeId > v;
 
           for (current = n1; current != n2; current = mark[current])
             v.push_back(current);
 
           v.push_back(n2);
 
           return v;
         }
 
         nodeFIFO.pushBack(new_one);
       }
 
       // check the parents
       for (const auto new_one : parents(current)) {
         if (mark.exists(new_one))   // if this node is already marked, do not
           continue;                 // check it again
 
         mark.insert(new_one, current);
 
         if (new_one == n1) {
           std::vector< NodeId > v;
 
           for (current = n1; current != n2; current = mark[current])
             v.push_back(current);
 
           v.push_back(n2);
 
           return v;
         }
 
         nodeFIFO.pushBack(new_one);
       }
     }
 
     GUM_ERROR(NotFound, "no path found");
   }

Here is the call graph for this function:

◆ mixedUnorientedPath()

const std::vector< NodeId > gum::MixedGraph::mixedUnorientedPath	(	const NodeId	node1,
		const NodeId	node2
	)		const

returns a mixed/directed path from node1 to node2 in the arc/edge set

This function returns, if any, a path from node1 to node2, using edges and/or arcs (not necessarily following the direction of th arcs)

Parameters

node1	the id from which the path begins
node2	the id to which the path ends

Exceptions

NotFound exception is raised if no path can be found between the two nodes

Definition at line 133 of file mixedGraph.cpp.

References gum::ArcGraphPart::children(), gum::List< Val, Alloc >::empty(), gum::HashTable< Key, Val, Alloc >::exists(), gum::List< Val, Alloc >::front(), GUM_ERROR, gum::HashTable< Key, Val, Alloc >::insert(), gum::EdgeGraphPart::neighbours(), gum::ArcGraphPart::parents(), gum::List< Val, Alloc >::popFront(), and gum::List< Val, Alloc >::pushBack().

                                                                            {
     // not recursive version => use a FIFO for simulating the recursion
     List< NodeId > nodeFIFO;
     nodeFIFO.pushBack(n2);
 
     // mark[node] = successor if visited, else mark[node] does not exist
     NodeProperty< NodeId > mark;
     mark.insert(n2, n2);
 
     NodeId current;
 
     while (!nodeFIFO.empty()) {
       current = nodeFIFO.front();
       nodeFIFO.popFront();
 
       // check the neighbours
       for (const auto new_one : neighbours(current)) {
         if (mark.exists(new_one))   // if the node has already been visited
           continue;                 // do not check it again
 
         mark.insert(new_one, current);
 
         if (new_one == n1) {
           std::vector< NodeId > v;
 
           for (current = n1; current != n2; current = mark[current])
             v.push_back(current);
 
           v.push_back(n2);
 
           return v;
         }
 
         nodeFIFO.pushBack(new_one);
       }
 
       // check the parents
       for (const auto new_one : parents(current)) {
         if (mark.exists(new_one))   // the node has already been visited
           continue;
 
         mark.insert(new_one, current);
 
         if (new_one == n1) {
           std::vector< NodeId > v;
 
           for (current = n1; current != n2; current = mark[current])
             v.push_back(current);
 
           v.push_back(n2);
 
           return v;
         }
 
         nodeFIFO.pushBack(new_one);
       }
 
       // check the children
       for (const auto new_one : children(current)) {
         if (mark.exists(new_one))   // the node has already been visited
           continue;
 
         mark.insert(new_one, current);
 
         if (new_one == n1) {
           std::vector< NodeId > v;
 
           for (current = n1; current != n2; current = mark[current])
             v.push_back(current);
 
           v.push_back(n2);
           return v;
         }
 
         nodeFIFO.pushBack(new_one);
       }
     }
 
     GUM_ERROR(NotFound, "no path found");
   }

Here is the call graph for this function:

◆ neighbours()

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

inherited

returns the set of edges adjacent to a given node

Note that the set of edges returned may be empty if no edge within the EdgeGraphPart is adjacent the given node.

Parameters

id	the node to which the edges are adjacent

Definition at line 75 of file edgeGraphPart_inl.h.

References gum::EdgeGraphPart::__checkNeighbours(), and gum::EdgeGraphPart::__neighbours.

Referenced by gum::DefaultJunctionTreeStrategy::__computeJunctionTree(), gum::StaticTriangulation::__computeMaxPrimeMergings(), gum::BinaryJoinTreeConverterDefault::__convertClique(), gum::BinaryJoinTreeConverterDefault::__convertConnectedComponent(), gum::SpanningForestPrim::__exploreNode(), gum::prm::gspan::DFSTree< GUM_SCALAR >::__initialiaze_root(), gum::BinaryJoinTreeConverterDefault::__markConnectedComponent(), gum::prm::StructuredInference< GUM_SCALAR >::__removeBarrenNodes(), gum::prm::GSpan< GUM_SCALAR >::__sortPatterns(), gum::EssentialGraph::__strongly_protected(), gum::StaticTriangulation::__triangulate(), gum::learning::Miic::_propagatesHead(), gum::EdgeGraphPart::eraseNeighbours(), gum::prm::gspan::DFSTree< GUM_SCALAR >::growPattern(), gum::UndiGraph::hasUndirectedCycle(), gum::learning::Miic::learnStructure(), mixedOrientedPath(), mixedUnorientedPath(), gum::EssentialGraph::neighbours(), gum::prm::gspan::DFSTree< GUM_SCALAR >::NeighborDegreeSort::operator()(), gum::UndiGraph::partialUndiGraph(), gum::EssentialGraph::toDot(), gum::UndiGraph::toDot(), toDot(), gum::EdgeGraphPart::undirectedPath(), and gum::EdgeGraphPart::unvirtualizedEraseNeighbours().

                                                                        {
     __checkNeighbours(id);
     return *(__neighbours[id]);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ nextNodeId()

INLINE NodeId gum::NodeGraphPart::nextNodeId ( ) const

inherited

returns a new node id, not yet used by any node

Warning: a code like
id=nextNodeId();addNode(id);
is basically not thread safe !!

Returns: a node id not yet used by any node within the NodeGraphPart

Definition at line 223 of file nodeGraphPart_inl.h.

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

                                                 {
     NodeId next = 0;
 
     // return the first hole if holes exist
     if (__holes && (!__holes->empty()))
       next = *(__holes->begin());
     else   // in other case
       next = __boundVal;
 
     return next;
   }

Here is the caller graph for this function:

◆ nodes()

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

inherited

return *this as a NodeGraphPart

Definition at line 370 of file nodeGraphPart_inl.h.

Referenced by gum::MarkovBlanket::__buildMarkovBlanket(), gum::SpanningForestPrim::__compute(), gum::StaticTriangulation::__computeMaxPrimeJunctionTree(), gum::prm::LayerGenerator< GUM_SCALAR >::__generateClassDag(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateClassDag(), gum::prm::GSpan< GUM_SCALAR >::__sortPatterns(), gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__threadUpdate(), gum::InfluenceDiagram< GUM_SCALAR >::_moralGraph(), gum::InfluenceDiagram< GUM_SCALAR >::_removeTables(), gum::prm::StructuredInference< GUM_SCALAR >::CData::CData(), gum::StaticTriangulation::fillIns(), gum::InfluenceDiagram< GUM_SCALAR >::getDecisionGraph(), gum::prm::gspan::DFSTree< GUM_SCALAR >::growPattern(), gum::UndiGraph::hasUndirectedCycle(), gum::DAG::moralGraph(), gum::MarkovBlanket::nodes(), gum::EssentialGraph::nodes(), gum::prm::gspan::Pattern::nodes(), gum::MarkovBlanket::toDot(), gum::EssentialGraph::toDot(), gum::InfluenceDiagram< GUM_SCALAR >::toDot(), gum::UndiGraph::toDot(), gum::DiGraph::toDot(), and toDot().

                                                          {
     return *(static_cast< const NodeGraphPart* >(this));
   }

Here is the caller graph for this function:

◆ nodesProperty() [1/2]

template<typename VAL >

NodeProperty< VAL > gum::NodeGraphPart::nodesProperty	(	VAL(*)(const NodeId &)	f,
		Size	size = `0`
	)		const

inherited

a method to create a HashTable with key:NodeId and value:VAL

VAL are computed from the nodes using for all node x, VAL f(x). This method is a wrapper of the same method in HashTable.

See also: HashTable::map.

Parameters

f	a function assigning a VAL to any node
size	an optional parameter enabling to fine-tune the returned Property. Roughly speaking, it is a good practice to have a size equal to half the number of nodes. If you do not specify this parameter, the method will assign it for you.

Referenced by gum::InfluenceDiagram< GUM_SCALAR >::_getChildrenDecision(), gum::BarrenNodesFinder::barrenNodes(), gum::BinaryJoinTreeConverterDefault::convert(), gum::InfluenceDiagram< GUM_SCALAR >::existsPathBetween(), and gum::UndiGraph::hasUndirectedCycle().

Here is the caller graph for this function:

◆ nodesProperty() [2/2]

template<typename VAL >

NodeProperty< VAL > gum::NodeGraphPart::nodesProperty	(	const VAL &	a,
		Size	size = `0`
	)		const

inherited

a method to create a hashMap with key:NodeId and value:VAL

for all nodes, the value stored is a. This method is a wrapper of the same method in HashTable.

See also: HashTable::map.

Parameters

a	the default value assigned to each edge in the returned Property
size	an optional parameter enabling to fine-tune the returned Property. Roughly speaking, it is a good practice to have a size equal to half the number of nodes. If you do not specify this parameter, the method will assign it for you.

◆ operator!=() [1/6]

INLINE bool gum::EdgeGraphPart::operator!= ( const EdgeGraphPart & p ) const

inherited

tests whether two EdgeGraphParts contain different edges

Parameters

p	the EdgeGraphPart that we compare with this

Definition at line 108 of file edgeGraphPart_inl.h.

References gum::EdgeGraphPart::__edges.

                                                                     {
     return __edges != p.__edges;
   }

◆ operator!=() [2/6]

INLINE bool gum::ArcGraphPart::operator!= ( const ArcGraphPart & p ) const

inherited

tests whether two ArcGraphParts contain different arcs

Parameters

p	the ArcGraphPart that we compare with this

Definition at line 154 of file arcGraphPart_inl.h.

References gum::ArcGraphPart::__arcs.

                                                                   {
     return __arcs != p.__arcs;
   }

◆ operator!=() [3/6]

INLINE bool gum::UndiGraph::operator!= ( const UndiGraph & g ) const

inherited

tests whether two UndiGraphs are different

Parameters

g	the UndiGraph with which "this" is compared

Definition at line 67 of file undiGraph_inl.h.

References gum::UndiGraph::operator==().

                                                             {
     return !operator==(p);
   }

Here is the call graph for this function:

◆ operator!=() [4/6]

INLINE bool gum::DiGraph::operator!= ( const DiGraph & g ) const

inherited

tests whether two DiGraphs are different

Parameters

g	the DiGraph with which "this" is compared

Definition at line 80 of file diGraph_inl.h.

References gum::DiGraph::operator==().

                                                         {
     return !operator==(p);
   }

Here is the call graph for this function:

◆ operator!=() [5/6]

INLINE bool gum::MixedGraph::operator!= ( const MixedGraph & g ) const

tests whether two MixedGraphs are different

Parameters

g	the MixedGraph with which "this" is compared

Definition at line 64 of file mixedGraph_inl.h.

References operator==().

                                                               {
     return !operator==(p);
   }

Here is the call graph for this function:

◆ operator!=() [6/6]

INLINE bool gum::NodeGraphPart::operator!= ( const NodeGraphPart & p ) const

inherited

check whether two NodeGraphParts contain different nodes

Parameters

p	the NodeGraphPart to be compared with "this"

Definition at line 354 of file nodeGraphPart_inl.h.

References gum::NodeGraphPartIterator::operator==().

                                                                     {
     return !operator==(p);
   }

Here is the call graph for this function:

◆ operator=()

INLINE MixedGraph & gum::MixedGraph::operator= ( const MixedGraph & g )

copy operator

Parameters

g	the MixedGraph to copy

Definition at line 29 of file mixedGraph_inl.h.

References gum::ArcGraphPart::clearArcs(), gum::EdgeGraphPart::clearEdges(), gum::NodeGraphPart::clearNodes(), gum::EdgeGraphPart::operator=(), gum::ArcGraphPart::operator=(), and gum::NodeGraphPart::operator=().

                                                               {
     // avoid self assigment
     if (this != &g) {
       // remove the old graph properly
       EdgeGraphPart::clearEdges();
       ArcGraphPart::clearArcs();
       NodeGraphPart::clearNodes();
 
       // fill the new graph
       NodeGraphPart::operator=(g);
       EdgeGraphPart::operator=(g);
       ArcGraphPart:: operator=(g);
     }
 
     return *this;
   }

Here is the call graph for this function:

◆ operator==() [1/6]

INLINE bool gum::EdgeGraphPart::operator== ( const EdgeGraphPart & p ) const

inherited

tests whether two EdgeGraphParts contain the same edges

Parameters

p	the EdgeGraphPart that we compare with this

Definition at line 104 of file edgeGraphPart_inl.h.

References gum::EdgeGraphPart::__edges.

Referenced by gum::UndiGraph::operator==(), and operator==().

                                                                     {
     return __edges == p.__edges;
   }

Here is the caller graph for this function:

◆ operator==() [2/6]

INLINE bool gum::ArcGraphPart::operator== ( const ArcGraphPart & p ) const

inherited

tests whether two ArcGraphParts contain the same arcs

Parameters

p	the ArcGraphPart that we compare with this

Definition at line 150 of file arcGraphPart_inl.h.

References gum::ArcGraphPart::__arcs.

Referenced by gum::DiGraph::operator==(), and operator==().

                                                                   {
     return __arcs == p.__arcs;
   }

Here is the caller graph for this function:

◆ operator==() [3/6]

INLINE bool gum::UndiGraph::operator== ( const UndiGraph & g ) const

inherited

tests whether two UndiGraphs are identical (same nodes, same edges)

Parameters

g	the UndiGraph with which "this" is compared

Definition at line 63 of file undiGraph_inl.h.

References gum::EdgeGraphPart::operator==(), and gum::NodeGraphPart::operator==().

Referenced by gum::UndiGraph::operator!=().

                                                             {
     return EdgeGraphPart::operator==(p) && NodeGraphPart::operator==(p);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator==() [4/6]

INLINE bool gum::DiGraph::operator== ( const DiGraph & g ) const

inherited

tests whether two DiGraphs are identical (same nodes, same arcs)

Parameters

g	the DiGraph with which "this" is compared

Definition at line 76 of file diGraph_inl.h.

References gum::ArcGraphPart::operator==(), and gum::NodeGraphPart::operator==().

Referenced by gum::DiGraph::operator!=().

                                                         {
     return ArcGraphPart::operator==(p) && NodeGraphPart::operator==(p);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator==() [5/6]

INLINE bool gum::MixedGraph::operator== ( const MixedGraph & g ) const

tests whether two MixedGraphs are identical (same nodes, arcs and edges)

Parameters

g	the MixedGraph with which "this" is compared

Definition at line 59 of file mixedGraph_inl.h.

References gum::EdgeGraphPart::operator==(), gum::ArcGraphPart::operator==(), and gum::NodeGraphPart::operator==().

Referenced by operator!=().

                                                               {
     return ArcGraphPart::operator==(p) && EdgeGraphPart::operator==(p)
            && NodeGraphPart::                            operator==(p);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator==() [6/6]

INLINE bool gum::NodeGraphPart::operator== ( const NodeGraphPart & p ) const

inherited

check whether two NodeGraphParts contain the same nodes

Parameters

p	the NodeGraphPart to be compared with "this"

Definition at line 340 of file nodeGraphPart_inl.h.

References gum::NodeGraphPart::__boundVal, and gum::NodeGraphPart::__holes.

Referenced by gum::UndiGraph::operator==(), gum::DiGraph::operator==(), and operator==().

                                                                     {
     if (__boundVal != p.__boundVal) return false;
 
     if (__holes)
       if (p.__holes)
         return (*__holes == *p.__holes);
       else
         return false;
     else if (p.__holes)
       return false;
 
     return true;
   }

Here is the caller graph for this function:

◆ parents()

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

inherited

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

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

Parameters

id	the node toward which the arcs returned are pointing

Definition at line 54 of file arcGraphPart_inl.h.

References gum::ArcGraphPart::__checkParents(), and gum::ArcGraphPart::__parents.

                                                                    {
     __checkParents(id);
     return *(__parents[id]);
   }

Here is the call graph for this function:

◆ partialUndiGraph()

UndiGraph gum::UndiGraph::partialUndiGraph ( NodeSet nodesSet )

virtualinherited

returns the partial graph formed by the nodes given in parameter

Definition at line 136 of file undiGraph.cpp.

References gum::UndiGraph::addEdge(), gum::NodeGraphPart::addNodeWithId(), gum::NodeGraphPart::existsNode(), and gum::EdgeGraphPart::neighbours().

                                                         {
     UndiGraph partialGraph;
 
     for (const auto node : nodesSet) {
       partialGraph.addNodeWithId(node);
 
       for (const auto nei : neighbours(node))
         if (nodesSet.contains(nei) && partialGraph.existsNode(nei))
           partialGraph.addEdge(node, nei);
     }
 
     return partialGraph;
   }

Here is the call graph for this function:

◆ populateNodes()

void gum::NodeGraphPart::populateNodes ( const NodeGraphPart & s )

inherited

populateNodes clears *this and fills it with the same nodes as "s"

populateNodes should basically be the preferred way to insert nodes with IDs not selected by the internal idFactory.

Parameters

s	the NodeGraphPart to be copied

Definition at line 61 of file nodeGraphPart.cpp.

References gum::NodeGraphPart::__boundVal, gum::NodeGraphPart::__holes, gum::NodeGraphPart::__holes_resize_policy, gum::NodeGraphPart::__holes_size, gum::NodeGraphPart::__updateEndIteratorSafe(), and gum::NodeGraphPart::clear().

Referenced by gum::DAGmodel::__moralGraph(), and gum::DAG::moralGraph().

                                                           {
     clear();   // "virtual" flush of the nodes set
     __holes_size = s.__holes_size;
     __holes_resize_policy = s.__holes_resize_policy;
 
     if (s.__holes) __holes = new NodeSet(*s.__holes);
 
     __boundVal = s.__boundVal;
 
     __updateEndIteratorSafe();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ populateNodesFromProperty()

template<typename T >

void gum::NodeGraphPart::populateNodesFromProperty ( const NodeProperty< T > & h )

inherited

populateNodesFromProperty clears *this and fills it with the keys of "h"

populateNodes should basically be the preferred way to insert nodes with IDs not selected by the internal idFactory.

◆ size()

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

inherited

alias for sizeNodes

Definition at line 281 of file nodeGraphPart_inl.h.

Referenced by gum::StaticTriangulation::__computeMaxPrimeJunctionTree(), gum::StaticTriangulation::__computeRecursiveThinning(), gum::OrderedEliminationSequenceStrategy::__isOrderNeeded(), gum::DiGraph::__topologicalOrder(), gum::StaticTriangulation::__triangulate(), gum::PartialOrderedEliminationSequenceStrategy::_isPartialOrderNeeded(), gum::BarrenNodesFinder::barrenNodes(), gum::prm::gspan::DFSTree< GUM_SCALAR >::growPattern(), gum::learning::GreedyHillClimbing::learnStructure(), gum::learning::LocalSearchWithTabuList::learnStructure(), gum::BayesBall::relevantPotentials(), gum::dSeparation::relevantPotentials(), gum::BayesBall::requisiteNodes(), gum::dSeparation::requisiteNodes(), gum::StaticTriangulation::setGraph(), gum::MarkovBlanket::size(), gum::EssentialGraph::size(), gum::DAGmodel::size(), gum::prm::gspan::Pattern::size(), gum::StaticTriangulation::StaticTriangulation(), and gum::UndiGraph::toDot().

281 { return sizeNodes(); }

gum::NodeGraphPart::sizeNodes

Size sizeNodes() const

returns the number of nodes in the NodeGraphPart

Definition: nodeGraphPart_inl.h:277

Here is the caller graph for this function:

◆ sizeArcs()

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

inherited

indicates the number of arcs stored within the ArcGraphPart

Definition at line 34 of file arcGraphPart_inl.h.

References gum::ArcGraphPart::__arcs, and gum::Set< Key, Alloc >::size().

Referenced by gum::MarkovBlanket::sizeArcs(), gum::EssentialGraph::sizeArcs(), gum::DAGmodel::sizeArcs(), gum::prm::gspan::Pattern::sizeArcs(), and gum::InfluenceDiagram< GUM_SCALAR >::toString().

34 { return __arcs.size(); }

gum::Set::size

Size size() const noexcept

Returns the number of elements in the set.

Definition: set_tpl.h:698

gum::ArcGraphPart::__arcs

Set< Arc > __arcs

the set of all the arcs contained within the ArcGraphPart

Definition: arcGraphPart.h:266

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sizeEdges()

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

inherited

indicates the number of edges stored within the EdgeGraphPart

Definition at line 34 of file edgeGraphPart_inl.h.

References gum::EdgeGraphPart::__edges, and gum::Set< Key, Alloc >::size().

Referenced by gum::EssentialGraph::sizeEdges().

34 { return __edges.size(); }

gum::Set::size

Size size() const noexcept

Returns the number of elements in the set.

Definition: set_tpl.h:698

gum::EdgeGraphPart::__edges

EdgeSet __edges

the set of all the edges contained within the EdgeGraphPart

Definition: edgeGraphPart.h:223

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sizeNodes()

INLINE Size gum::NodeGraphPart::sizeNodes ( ) const

inherited

returns the number of nodes in the NodeGraphPart

Definition at line 277 of file nodeGraphPart_inl.h.

Referenced by gum::BinaryJoinTreeConverterDefault::__markConnectedComponent(), gum::BarrenNodesFinder::barrenNodes(), gum::BinaryJoinTreeConverterDefault::convert(), gum::EliminationSequenceStrategy::setGraph(), gum::MarkovBlanket::sizeNodes(), and gum::EssentialGraph::sizeNodes().

                                              {
     return (__holes) ? (__boundVal - __holes->size()) : __boundVal;
   }

Here is the caller graph for this function:

◆ toDot()

const std::string gum::MixedGraph::toDot ( ) const

virtual

to friendly display mixed graph in DOT format

Reimplemented from gum::DiGraph.

Definition at line 214 of file mixedGraph.cpp.

References gum::ArcGraphPart::children(), gum::List< Val, Alloc >::exists(), gum::List< Val, Alloc >::insert(), gum::EdgeGraphPart::neighbours(), and gum::NodeGraphPart::nodes().

                                           {
     std::stringstream output;
     std::stringstream nodeStream;
     std::stringstream edgeStream;
     List< NodeId >    treatedNodes;
     output << "digraph \""
            << "no_name\" {" << std::endl;
     nodeStream << "node [shape = ellipse];" << std::endl;
     std::string tab = "  ";
 
     for (const auto node : nodes()) {
       nodeStream << tab << node << ";";
 
       for (const auto nei : neighbours(node))
         if (!treatedNodes.exists(nei))
           edgeStream << tab << node << " -> " << nei << " [dir=none];"
                      << std::endl;
 
       for (const auto chi : children(node))
         edgeStream << tab << node << " -> " << chi << ";" << std::endl;
 
       treatedNodes.insert(node);
     }
 
     output << nodeStream.str() << std::endl
            << edgeStream.str() << std::endl
            << "}" << std::endl;
 
     return output.str();
   }

Here is the call graph for this function:

◆ topologicalOrder()

const Sequence< NodeId > & gum::DiGraph::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.

Exceptions

InvalidDirectedCycle Raised if this DiGraph contains cycles.

Definition at line 88 of file diGraph.cpp.

References gum::DiGraph::__mutableTopologicalOrder, gum::DiGraph::__topologicalOrder(), and gum::SequenceImplementation< Key, Alloc, Gen >::clear().

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::__setO3ClassCreationOrder(), gum::prm::o3prm::O3InterfaceFactory< GUM_SCALAR >::__setO3InterfaceCreationOrder(), gum::prm::o3prm::O3TypeFactory< GUM_SCALAR >::__setO3TypeCreationOrder(), gum::learning::Miic::learnStructure(), and gum::DAGmodel::topologicalOrder().

                                                                       {
     if (clear
         || (__mutableTopologicalOrder
             == nullptr)) {   // we have to call _topologicalOrder
       if (__mutableTopologicalOrder == nullptr) {
         __mutableTopologicalOrder = new Sequence< NodeId >();
       } else {
         // clear is True
         __mutableTopologicalOrder->clear();
       }
 
       __topologicalOrder();
     }
 
     return *__mutableTopologicalOrder;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ toString()

const std::string gum::MixedGraph::toString ( ) const

virtual

to friendly display the content of the MixedGraph

Reimplemented from gum::DiGraph.

Definition at line 61 of file mixedGraph.cpp.

References gum::EdgeGraphPart::toString(), gum::ArcGraphPart::toString(), and gum::NodeGraphPart::toString().

Referenced by gum::operator<<().

                                              {
     std::string s = NodeGraphPart::toString();
     s += " , ";
     s += ArcGraphPart::toString();
     s += " , ";
     s += EdgeGraphPart::toString();
     return s;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ undirectedPath()

const std::vector< NodeId > gum::EdgeGraphPart::undirectedPath	(	const NodeId	node1,
		const NodeId	node2
	)		const

inherited

returns a possible path from node1 to node2 in the edge set

Parameters

node1	the id from which the path begins
node2	the id to which the path ends

Exceptions

NotFound exception is raised if no path can be found between the two nodes

Definition at line 124 of file edgeGraphPart.cpp.

References gum::List< Val, Alloc >::empty(), gum::HashTable< Key, Val, Alloc >::exists(), gum::List< Val, Alloc >::front(), GUM_ERROR, gum::HashTable< Key, Val, Alloc >::insert(), gum::EdgeGraphPart::neighbours(), gum::List< Val, Alloc >::popFront(), and gum::List< Val, Alloc >::pushBack().

                                                                          {
     // not recursive version => use a FIFO for simulating the recursion
     List< NodeId > nodeFIFO;
     nodeFIFO.pushBack(n2);
 
     // mark[node] = predecessor if visited, else mark[node] does not exist
     NodeProperty< NodeId > mark;
     mark.insert(n2, n2);
 
     NodeId current;
 
     while (!nodeFIFO.empty()) {
       current = nodeFIFO.front();
       nodeFIFO.popFront();
 
       // check the neighbour
       for (const auto new_one : neighbours(current)) {
         if (mark.exists(new_one))   // if this node is already marked, stop
           continue;
 
         mark.insert(new_one, current);
 
         if (new_one == n1) {
           std::vector< NodeId > v;
 
           for (current = n1; current != n2; current = mark[current])
             v.push_back(current);
 
           v.push_back(n2);
 
           return v;
         }
 
         nodeFIFO.pushBack(new_one);
       }
     }
 
     GUM_ERROR(NotFound, "no path found");
   }

Here is the call graph for this function:

◆ unvirtualizedEraseChildren()

INLINE void gum::ArcGraphPart::unvirtualizedEraseChildren ( const NodeId id )

inherited

same function as eraseChildren but without any virtual call to an erase

Parameters

id	the node whose outgoing arcs will be removed

Definition at line 138 of file arcGraphPart_inl.h.

References gum::ArcGraphPart::__children, gum::Set< Key, Alloc >::beginSafe(), gum::ArcGraphPart::children(), gum::Set< Key, Alloc >::endSafe(), and gum::ArcGraphPart::eraseArc().

Referenced by gum::DiGraph::eraseNode(), and eraseNode().

                                                                       {
     if (__children.exists(id)) {
       NodeSet& children = *(__children[id]);
 
       for (auto iter = children.beginSafe();   // safe iterator needed here
            iter != children.endSafe();
            ++iter) {
         ArcGraphPart::eraseArc(Arc(id, *iter));
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unvirtualizedEraseNeighbours()

INLINE void gum::EdgeGraphPart::unvirtualizedEraseNeighbours ( const NodeId id )

inherited

same function as eraseNeighbours but without any virtual call to an erase

Parameters

id	the node whose ingoing arcs will be removed

Definition at line 93 of file edgeGraphPart_inl.h.

References gum::EdgeGraphPart::__neighbours, gum::EdgeGraphPart::eraseEdge(), and gum::EdgeGraphPart::neighbours().

Referenced by gum::UndiGraph::eraseNode(), and eraseNode().

                                                                          {
     if (__neighbours.exists(id)) {
       const NodeSet& set = neighbours(id);
 
       for (auto iter = set.beginSafe(); iter != set.endSafe();
            ++iter) {   // safe iterator needed here
         EdgeGraphPart::eraseEdge(Edge(*iter, id));
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unvirtualizedEraseParents()

INLINE void gum::ArcGraphPart::unvirtualizedEraseParents ( const NodeId id )

inherited

same function as eraseParents but without any virtual call to an erase

Parameters

id	the node whose ingoing arcs will be removed

Definition at line 126 of file arcGraphPart_inl.h.

References gum::ArcGraphPart::__parents, gum::Set< Key, Alloc >::beginSafe(), gum::Set< Key, Alloc >::endSafe(), gum::ArcGraphPart::eraseArc(), and gum::ArcGraphPart::parents().

Referenced by gum::DiGraph::eraseNode(), and eraseNode().

                                                                      {
     if (__parents.exists(id)) {
       NodeSet& parents = *(__parents[id]);
 
       for (auto iter = parents.beginSafe();   // safe iterator needed here
            iter != parents.endSafe();
            ++iter) {
         ArcGraphPart::eraseArc(Arc(*iter, id));
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ onArcAdded

Signaler2< NodeId, NodeId > gum::ArcGraphPart::onArcAdded

inherited

Definition at line 80 of file arcGraphPart.h.

Referenced by gum::ArcGraphPart::addArc(), gum::ArcGraphPart::ArcGraphPart(), and gum::ArcGraphPart::operator=().

◆ onArcDeleted

Signaler2< NodeId, NodeId > gum::ArcGraphPart::onArcDeleted

inherited

Definition at line 81 of file arcGraphPart.h.

Referenced by gum::ArcGraphPart::clearArcs(), and gum::ArcGraphPart::eraseArc().

◆ onEdgeAdded

Signaler2< NodeId, NodeId > gum::EdgeGraphPart::onEdgeAdded

inherited

Definition at line 76 of file edgeGraphPart.h.

Referenced by gum::EdgeGraphPart::addEdge(), gum::EdgeGraphPart::EdgeGraphPart(), and gum::EdgeGraphPart::operator=().

◆ onEdgeDeleted

Signaler2< NodeId, NodeId > gum::EdgeGraphPart::onEdgeDeleted

inherited

Definition at line 77 of file edgeGraphPart.h.

Referenced by gum::EdgeGraphPart::clearEdges(), and gum::EdgeGraphPart::eraseEdge().

◆ onNodeAdded

Signaler1< NodeId > gum::NodeGraphPart::onNodeAdded

inherited

Definition at line 271 of file nodeGraphPart.h.

Referenced by gum::NodeGraphPart::addNodeWithId().

◆ onNodeDeleted

Signaler1< NodeId > gum::NodeGraphPart::onNodeDeleted

inherited

Definition at line 272 of file nodeGraphPart.h.

Referenced by gum::NodeGraphPart::__clearNodes().

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

agrum/graphs/mixedGraph.h
agrum/graphs/mixedGraph.cpp
agrum/graphs/mixedGraph_inl.h

Public Attributes

Public Member Functions

Public Types

Protected Member Functions

Detailed Description

Member Typedef Documentation

◆ ArcIterator

◆ EdgeIterator

◆ node_const_iterator

◆ node_const_iterator_safe

◆ node_iterator

◆ node_iterator_safe

◆ NodeConstIterator

◆ NodeConstIteratorSafe

◆ NodeIterator

◆ NodeIteratorSafe

Constructor & Destructor Documentation

◆ MixedGraph() [1/2]

◆ MixedGraph() [2/2]

◆ ~MixedGraph()

Member Function Documentation

◆ _eraseSetOfArcs()

◆ _unvirtualizedEraseSetOfArcs()

◆ addArc()

◆ addEdge()

◆ addNode()

◆ addNodes()

◆ addNodeWithId()

◆ arcs()

◆ arcsProperty() [1/2]

◆ arcsProperty() [2/2]

◆ asNodeSet()

◆ begin()

◆ beginSafe()

◆ bound()

◆ children()

◆ clear()

◆ clearArcs()

◆ clearEdges()

◆ clearNodes()

◆ directedPath()

◆ directedUnorientedPath()

◆ edges()

◆ edgesProperty() [1/2]

◆ edgesProperty() [2/2]

◆ empty()

◆ emptyArcs()

◆ emptyEdges()

◆ emptyNodes()

◆ end()

◆ endSafe()

◆ eraseArc()

◆ eraseChildren()

◆ eraseEdge()

◆ eraseNeighbours()

◆ eraseNode()

◆ eraseParents()

◆ exists()

◆ existsArc() [1/2]

◆ existsArc() [2/2]

◆ existsEdge() [1/2]

◆ existsEdge() [2/2]

◆ existsNode()

◆ hasUndirectedCycle()

◆ listMapArcs()

◆ listMapEdges()

◆ listMapNodes()

◆ mixedOrientedPath()

◆ mixedUnorientedPath()

◆ neighbours()

◆ nextNodeId()

◆ nodes()

◆ nodesProperty() [1/2]

◆ nodesProperty() [2/2]

◆ operator!=() [1/6]

◆ operator!=() [2/6]

◆ operator!=() [3/6]

◆ operator!=() [4/6]

◆ operator!=() [5/6]

◆ operator!=() [6/6]