Merge branch 'master' of github.com:HGX-Team/hypergraphx

Author: FraLotito

hypergraphx/core/directed_hypergraph.py

@@ -696,6 +696,28 @@ def get_sizes(self):
         """
         return [len(edge[0]) + len(edge[1]) for edge in self._edge_list.keys()]
 
+    def max_size(self):
+        """
+        Returns the maximum size of the hypergraph.
+
+        Returns
+        -------
+        int
+            Maximum size of the hypergraph.
+        """
+        return max(self.get_sizes())
+
+    def max_order(self):
+        """
+        Returns the maximum order of the hypergraph.
+
+        Returns
+        -------
+        int
+            Maximum order of the hypergraph.
+        """
+        return self.max_size() - 1
+
     def distribution_sizes(self):
         """
         Returns the distribution of sizes of the hyperedges in the hypergraph.
@@ -876,6 +898,10 @@ def is_isolated(self, node, size=None, order=None):
 
         return is_isolated(self, node, size=size, order=order)
 
+    def to_line_graph(self, distance="intersection",s:int = 1, weighted=False):
+        from hypergraphx.representations.projections import directed_line_graph
+        return directed_line_graph(self, distance, s, weighted)
+
     #Metadata
     def set_hypergraph_metadata(self, metadata):
         self._hypergraph_metadata = metadata

hypergraphx/core/hypergraph.py

@@ -978,6 +978,10 @@ def adjacency_factor(self,t:int = 0):
         from hypergraphx.linalg import adjacency_factor
         return adjacency_factor(self, t)
 
+    def to_line_graph(self, distance="intersection",s:int = 1, weighted=False):
+        from hypergraphx.representations.projections import line_graph
+        return line_graph(self, distance, s, weighted)
+
     #Metadata
     def set_hypergraph_metadata(self, metadata):
         self._hypergraph_metadata = metadata

hypergraphx/measures/s_centralities.py

@@ -36,6 +36,64 @@ def s_closeness(H: Hypergraph, s=1):
     c = nx.closeness_centrality(lg)
     return {id_to_edge[k]: v for k, v in c.items()}
 
+def s_betweenness_averaged(H: TemporalHypergraph, s=1):
+    """
+    Computes the betweenness centrality for each edge in the temporal hypergraph.
+    The function calculates the betweenness centrality during each time of the temporal hypergraph and then
+    the result is the average betweenness centrality in each time.
+    Parameters
+    ----------
+    H : TemporalHypergraph
+        The temporal hypergraph to compute the betweenness centrality for.
+    s : int, optional
+    Returns
+    -------
+    dict.
+        The betweenness centrality for each edge in the temporal hypergraph.
+        The keys are the edges and the values are the betweenness centrality.
+    """
+    subhypergraphs = H.subhypergraph()
+    T = len(subhypergraphs)
+    res = dict()
+    for hypergraph in subhypergraphs.values():
+        lg, id_to_edge = line_graph(hypergraph, s=s)
+        b = nx.betweenness_centrality(lg)
+        for k, v in b.items():
+            k = id_to_edge[k]
+            if k not in res.keys():
+                res[k] = 0
+            res[k] += v
+    return {k: v/T for k, v in res.items()}
+
+def s_closeness_averaged(H: TemporalHypergraph, s=1):
+    """
+    Computes the closeness centrality for each edge in the temporal hypergraph.
+    The function calculates the closeness centrality during each time of the temporal hypergraph and then
+    the result is the average closeness centrality in each time.
+    Parameters
+    ----------
+    H : TemporalHypergraph
+        The temporal hypergraph to compute the closeness centrality for.
+    s : int, optional
+    Returns
+    -------
+    dict.
+        The closeness centrality for each edge in the hypergraph.
+        The keys are the edges and the values are the closeness centrality.
+    """
+    subhypergraphs = H.subhypergraph()
+    T = len(subhypergraphs)
+    res = dict()
+    for hypergraph in subhypergraphs.values():
+        lg, id_to_edge = line_graph(hypergraph, s=s)
+        b = nx.closeness_centrality(lg)
+        for k, v in b.items():
+            k = id_to_edge[k]
+            if k not in res.keys():
+                res[k] = 0
+            res[k] += v
+    return {k: v/T for k, v in res.items()}
+
 def s_betweenness_nodes(H: Hypergraph|DirectedHypergraph):
     """
     Computes the betweenness centrality for each node in the hypergraph.
@@ -94,10 +152,12 @@ def s_betweenness_nodes_averaged(H: TemporalHypergraph):
         lg, id_to_edge = bipartite_projection(hypergraph)
         b = nx.betweenness_centrality(lg)
         for k, v in b.items():
-            if k not in res.keys():
-                res[k] = 0
-            res[k] += v
-    return {id_to_edge[k]: v/T for k, v in res.items() if "E" not in k}
+            if "E" not in k:
+                k = id_to_edge[k]
+                if k not in res.keys():
+                    res[k] = 0
+                res[k] += v
+    return {k: v/T for k, v in res.items() if "E" not in k}
 
 def s_closenness_nodes_averaged(H: TemporalHypergraph):
     """
@@ -121,7 +181,9 @@ def s_closenness_nodes_averaged(H: TemporalHypergraph):
         lg, id_to_edge = bipartite_projection(hypergraph)
         b = nx.closeness_centrality(lg)
         for k, v in b.items():
-            if k not in res.keys():
-                res[k] = 0
-            res[k] += v
-    return {id_to_edge[k]: v/T for k, v in res.items() if "E" not in k}
+            if "E" not in k:
+                k = id_to_edge[k]
+                if k not in res.keys():
+                    res[k] = 0
+                res[k] += v
+    return {k: v/T for k, v in res.items() if "E" not in k}

hypergraphx/representations/projections.py

@@ -1,6 +1,5 @@
 import networkx as nx
-
-from hypergraphx import Hypergraph
+from hypergraphx import Hypergraph, DirectedHypergraph
 from hypergraphx.measures.edge_similarity import intersection, jaccard_similarity
 
 
@@ -176,3 +175,73 @@ def _distance(a, b):
                             )
                     vis[k] = True
     return g, id_to_edge
+
+def directed_line_graph(h: DirectedHypergraph, distance="intersection", s=1, weighted=False):
+    """
+    Returns a line graph of the directed hypergraph.
+
+    Parameters
+    ----------
+    h : DirectedHypergraph
+        The directed hypergraph to be projected.
+    distance : str
+        The distance function to be used. Can be 'intersection' or 'jaccard'.
+    s : float
+        The threshold for the distance function.
+    weighted : bool
+        Whether the line graph should be weighted or not.
+
+    Returns
+    -------
+    networkx.Graph
+        The line graph of the hypergraph.
+
+    Notes
+    -----
+    Computing the line graph can be very expensive for large hypergraphs.
+
+    Example
+    -------
+    >>> import networkx as nx
+    >>> import hypergraphx as hgx
+    >>> from hypergraphx.representations.projections import line_graph
+    >>>
+    >>> h = hgx.Hypergraph()
+    >>> h.add_nodes([1, 2, 3, 4, 5])
+    >>> h.add_edges([(1, 2), (1, 2, 3), (3, 4, 5)])
+    >>> g, idx = line_graph(h)
+    >>> g.edges()
+    EdgeView([(0, 1), (1, 2)])
+    """
+
+    def _distance(a, b):
+        if distance == "intersection":
+            return intersection(a, b)
+        if distance == "jaccard":
+            return jaccard_similarity(a, b)
+
+    edges = h.get_edges()
+    edge_to_id = {}
+    id_to_edge = {}
+    cont = 0
+    for e in edges:
+        edge_to_id[e] = cont
+        id_to_edge[cont] = e
+        cont += 1
+
+    g = nx.DiGraph()
+    g.add_nodes_from([i for i in range(len(h))])
+
+    for edge1 in h.get_edges():
+        for edge2 in h.get_edges():
+            if edge1 != edge2:
+                source = set(edge1[1])
+                target = set(edge2[0])
+                w = _distance(source, target)
+                if w >= s:
+                    if weighted:
+                        g.add_edge(edge_to_id[edge1],edge_to_id[edge2], weight=w)
+                    else:
+                        g.add_edge( edge_to_id[edge1],edge_to_id[edge2] )
+
+    return g, id_to_edge