def Q_max_modularity(network: Network, cluster_mapping: Dict) -> float: """Computes the maximum theoretically possible Q-modularity for a given network and cluster mapping """ m = network.number_of_edges() qmax: float = 2*m for v in network.nodes.uids: for w in network.nodes.uids: if cluster_mapping[v] == cluster_mapping[w]: qmax -= network.degrees()[v]*network.degrees()[w]/(2*m) return qmax/(2*m)
def Q_modularity(network: Network, cluster_mapping: Dict) -> float: """Computes the Q-modularity of a network for a given cluster mapping """ A = network.adjacency_matrix() m = network.number_of_edges() q = 0.0 for v in network.nodes.uids: for w in network.nodes.uids: if cluster_mapping[v] == cluster_mapping[w]: q += A[network.nodes.index[v], network.nodes.index[w]] - \ network.degrees()[v] * network.degrees()[w]/(2*m) return q/(2*m)
def degree_sequence(network: Network, weight: Weight = None) -> np.array: """Calculates the degree sequence of a network. Parameters ---------- network : Network The :py:class:`Network` object that contains the network weights : bool If True weighted degrees will be calculated Examples -------- Generate a simple network >>> import pathpy as pp >>> net = pp.Network(directed=False) >>> net.add_edge('a', 'b', weight = 2.1) >>> net.add_edge('a', 'c', weight = 1.0) >>> s = pp.algorithms.statistics.degrees.degree_sequence(net) >>> s np.array([2., 1., 1.]) Return weighted degree sequence >>> s = pp.algorithms.statistics.degrees.degree_sequence(net,weight=True) >>> s array([3.1, 2.1, 1.0]) """ _degrees = np.zeros(network.number_of_nodes(), dtype=float) for v in network.nodes.uids: _degrees[network.nodes.index[v]] = network.degrees(weight=weight)[v] return _degrees
def degree_assortativity(network: Network, mode: str = 'total', weight: Weight = None) -> float: """Calculates the degree assortativity coefficient of a network. Parameters ---------- network : Network The network in which to calculate the Molloy-Reed fraction """ A = network.adjacency_matrix(weight=weight) m = np.sum(A) d = network.degrees(weight) if network.directed and mode == 'in': d = network.indegrees(weight) elif network.directed and mode == 'out': d = network.outdegrees(weight) elif network.directed and mode == 'total': d = network.degrees(weight) elif not network.directed: m = m / 2. idx = network.nodes.index cov: float = 0. var: float = 0. for i in network.nodes.keys(): for j in network.nodes.keys(): cov += (A[idx[i], idx[j]] - (d[i] * d[j]) / (2 * m)) * d[i] * d[j] if i != j: var -= (d[i] * d[j]) / (2 * m) * d[i] * d[j] else: var += (d[i] - (d[i] * d[j]) / (2 * m)) * d[i] * d[j] return cov / var
def degree_centrality(network: Network, mode: str = 'degree') -> dict: """Calculates the degree centrality of all nodes. Parameters ---------- network : Network The :py:class:`Network` object that contains the network mode : str Can be chose nas 'degree', 'indegree', or 'outdegree'. Determines whether to calculate undirected/total degrees, indegrees, or degrees Examples -------- Compute degree centrality in a simple network >>> import pathpy as pp >>> net = pp.Network(directed=True) >>> net.add_edge('a', 'x') >>> net.add_edge('x', 'b') >>> c = pp.algorithms.centralities.degree_centrality(net) >>> c['a'] 1 >>> c = pp.algorithms.centralities.degree_centrality(net, mode='indegree') >>> c['a'] 0 """ d: dict = dict() if mode not in set(['degree', 'indegree', 'outdegree']): LOG.error('Mode must be \'degree\', \'indegree\' or \'outdegree\'') raise KeyError for v in network.nodes.keys(): if mode == 'indegree': d[v] = network.indegrees()[v] elif mode == 'outdegree': d[v] = network.outdegrees()[v] else: d[v] = network.degrees()[v] return d
def local_clustering_coefficient(network: Network, v: str) -> float: """Calculates the local clustering coefficient of a node in a network. The local clustering coefficient of any node with an (out-)degree smaller than two is defined as zero. For all other nodes, it is defined as: cc(c) := 2*k(i)/(d_i(d_i-1)) or cc(c) := k(i)/(d_out_i(d_out_i-1)) in undirected and directed networks respectively. Parameters ---------- network : Network The network in which to calculate the local clustering coefficient node : str The node for which the local clustering coefficient shall be calculated """ lcc: float = 0. d = network.degrees() o = network.outdegrees() if network.directed and o[v] >= 2 or network.directed == False and d[ v] >= 2: k: int = 0 # compute set of closed triads closed = closed_triads(network, v) k = len(closed) if network.directed: return k / (o[v] * (o[v] - 1)) else: return 2 * k / (d[v] * (d[v] - 1)) else: return 0.