def test_global_efficiency():
base_dir = str(Path(__file__).parent/"examples")
in_mat = np.load(base_dir + '/997/997_Default_est_cov_0.1_4.npy')
G = nx.from_numpy_array(in_mat)
start_time = time.time()
global_eff = netstats.global_efficiency(G)
print("%s%s%s" % ('thresh_and_fit (Functional, proportional thresholding) --> finished: ', str(np.round(time.time() - start_time, 1)), 's'))
assert global_eff is not None
def local_efficiency(G, weight=None):
"""Return the local efficiency of each node in the graph G
Parameters
----------
G : NetworkX graph
Returns
-------
local_efficiency : dict
the keys of the dict are the nodes in the graph G and the corresponding
values are local efficiencies of each node
Notes
-----
The published definition includes a scale factor based on a completely
connected graph. In the case of an unweighted network, the scaling factor
is 1 and can be ignored. In the case of a weighted graph, calculating the
scaling factor requires somehow knowing the weights of the edges required
to make a completely connected graph. Since that knowlege may not exist,
the scaling factor is not included. If that knowlege exists, construct the
corresponding weighted graph and calculate its local_efficiency to scale
the weighted graph.
References
----------
.. [1] Latora, V., and Marchiori, M. (2001). Efficient behavior of
small-world networks. Physical Review Letters 87.
.. [2] Latora, V., and Marchiori, M. (2003). Economic small-world behavior
in weighted networks. Eur Phys J B 32, 249-263.
"""
if G.is_directed():
new_graph = nx.DiGraph
else:
new_graph = nx.Graph
efficiencies = dict()
for node in G:
temp_G = new_graph()
temp_G.add_nodes_from(G.neighbors(node))
for neighbor in G.neighbors(node):
for (n1, n2) in G.edges(neighbor):
if (n1 in temp_G) and (n2 in temp_G):
temp_G.add_edge(n1, n2)
if weight is not None:
for (n1, n2) in temp_G.edges():
temp_G[n1][n2][weight] = G[n1][n2][weight]
efficiencies[node] = global_efficiency(temp_G, weight)
return efficiencies
def local_efficiency(G):
return float(sum(global_efficiency(nx.ego_graph(G, v)) for v in G)) / len(G)