def testSerialRandom():
""" 50 Random serial test cases
"""
N = 10
p = .7
runs = 0
while runs < 50:
# a random graph
G = nx.fast_gnp_random_graph(N, p)
try:
nx.shortest_path(G, source=0, target=N - 1)
except RuntimeError:
continue
# convert to plain ndarray
nw1 = nx2nw(G)
# copy and join network
nw2 = serialCopy(nw1)
# compute effective resistance
ER1 = ResNetwork(nw1, silence_level=3).effective_resistance(
0,
len(nw1) - 1)
ER2 = ResNetwork(nw2, silence_level=3).effective_resistance(
0,
len(nw2) - 1)
# increment runs
runs += 1
# assertion
print ER1 * 2 - ER2
assert (ER1 * 2 - ER2) < 1E-6
def testParallelTrivial():
""" Trivial parallel case:
a) 0 --- 1 --- 2
/---- 3 ---\
b) 0 --- 1 --- 2
c) /---- 3 ---\
0 --- 1 --- 2
\____ 4 ___/
ER(a) = 2*ER(b) = 3*ER(c)
"""
nws = []
# construct nw1
idI, idJ = [0, 1], [1, 2]
nws.append(makeNW(idI, idJ, [.1]))
# construct nw2
idI += [0, 3]
idJ += [3, 2]
nws.append(makeNW(idI, idJ, [.1]))
# nw3
idI += [0, 4]
idJ += [4, 2]
nws.append(makeNW(idI, idJ, [.1]))
ER = []
for nw in nws:
rnw = ResNetwork(nw)
ER.append(rnw.effective_resistance(0, 2))
assert abs(ER[0]/2-ER[1]) < .1E-6
assert abs(ER[0]/3-ER[2]) < .1E-6
def testParallelTrivial():
r""" Trivial parallel case:
a) 0 --- 1 --- 2
/---- 3 ---\
b) 0 --- 1 --- 2
c) /---- 3 ---\
0 --- 1 --- 2
\____ 4 ___/
ER(a) = 2*ER(b) = 3*ER(c)
"""
nws = []
# construct nw1
idI, idJ = [0, 1], [1, 2]
nws.append(makeNW(idI, idJ, [.1]))
# construct nw2
idI += [0, 3]
idJ += [3, 2]
nws.append(makeNW(idI, idJ, [.1]))
# nw3
idI += [0, 4]
idJ += [4, 2]
nws.append(makeNW(idI, idJ, [.1]))
ER = []
for nw in nws:
rnw = ResNetwork(nw)
ER.append(rnw.effective_resistance(0, 2))
assert abs(ER[0] / 2 - ER[1]) < .1E-6
assert abs(ER[0] / 3 - ER[2]) < .1E-6
def testSerialRandom():
""" 50 Random serial test cases
"""
N = 10
p = .7
runs = 50
for run in range(0, runs):
# a random graph
G = nx.fast_gnp_random_graph(N, p)
try:
nx.shortest_path(G, source=0, target=N - 1)
except RuntimeError:
continue
except nx.NetworkXNoPath:
pass
# convert to plain ndarray
nw1 = nx2nw(G)
# copy and join network
nw2 = serialCopy(nw1)
# compute effective resistance
ER1 = ResNetwork(nw1, silence_level=3).effective_resistance(
0,
len(nw1) - 1)
ER2 = ResNetwork(nw2, silence_level=3).effective_resistance(
0,
len(nw2) - 1)
# assertion
# print(ER1*2-ER2)
assert (ER1 * 2 - ER2) < 1E-6
def testParallelLessTrivial():
""" Less Trivial Parallel Case:
|--- 1 --- 0
a) 2 |
|--- 3 ----4
|--- 1 --- 0 --- 5 --- |
b) 2 | | 7
|--- 3 ----4 --- 6 --- |
|---- 8 ----------- |
| | |
| |----------| |
| | |
|--- 1 --- 0 --- 5 --- | | |
c) 2 | | 7 | 9
|--- 3 ----4 --- 6 --- | | |
| | |
| ----------| |
| | |
|---- 10 -----------|
"""
nws = []
idI = [0, 1, 1, 2, 3]
idJ = [1, 2, 3, 3, 4]
nws.append(makeNW(idI, idJ, [1] * len(idI)))
idI.extend([0, 5, 5, 6, 6])
idJ.extend([5, 6, 7, 7, 4])
nws.append(makeNW(idI, idJ, [1] * len(idI)))
idI.extend([0, 8, 8, 9, 10])
idJ.extend([8, 9, 10, 10, 4])
nws.append(makeNW(idI, idJ, [1] * len(idI)))
ER = []
Gs = []
for nw in nws:
rnw = ResNetwork(nw)
ER.append(rnw.effective_resistance(0, 4))
# Gs.append(nx.DiGraph(nw))
# # showGraphs(Gs)
# # s = ''
# # for i,e in enumerate(ER):
# # s = s + "NW{:d} {:.3f}\t".format(i,e)
# # print("Effective resistances (0,2)\n %s" % (s))
assert abs(ER[0] / 2 - ER[1]) < .1E-6
assert abs(ER[0] / 3 - ER[2]) < .1E-6
def testParallelLessTrivial():
""" Less Trivial Parallel Case:
|--- 1 --- 0
a) 2 |
|--- 3 ----4
|--- 1 --- 0 --- 5 --- |
b) 2 | | 7
|--- 3 ----4 --- 6 --- |
|---- 8 ----------- |
| | |
| |----------| |
| | |
|--- 1 --- 0 --- 5 --- | | |
c) 2 | | 7 | 9
|--- 3 ----4 --- 6 --- | | |
| | |
| ----------| |
| | |
|---- 10 -----------|
"""
nws = []
idI = [0, 1, 1, 2, 3]
idJ = [1, 2, 3, 3, 4]
nws.append(makeNW(idI, idJ, [1]*len(idI)))
idI.extend([0, 5, 5, 6, 6])
idJ.extend([5, 6, 7, 7, 4])
nws.append(makeNW(idI, idJ, [1]*len(idI)))
idI.extend([0, 8, 8, 9, 10])
idJ.extend([8, 9, 10, 10, 4])
nws.append(makeNW(idI, idJ, [1]*len(idI)))
ER = []
Gs = []
for nw in nws:
rnw = ResNetwork(nw)
ER.append(rnw.effective_resistance(0, 4))
# Gs.append(nx.DiGraph(nw))
# # showGraphs(Gs)
# # s = ''
# # for i,e in enumerate(ER):
# # s = s + "NW{:d} {:.3f}\t".format(i,e)
# # print "Effective resistances (0,2)\n %s" % (s)
assert abs(ER[0]/2-ER[1]) < .1E-6
assert abs(ER[0]/3-ER[2]) < .1E-6
def test_get_admittance():
net = ResNetwork.SmallTestNetwork()
res = net.get_admittance()
exp = [[0., 0.5, 0., 0., 0.], [0.5, 0., 0.125, 0.5, 0.],
[0., 0.125, 0., 0.125, 0.], [0., 0.5, 0.125, 0., 0.1],
[0., 0., 0., 0.1, 0.]]
assert np.allclose(res, exp, atol=1e-04)
def test_get_R():
res = ResNetwork.SmallTestNetwork().get_R()
exp = [[2.28444444, 0.68444444, -0.56, -0.20444444, -2.20444444],
[0.68444444, 1.08444444, -0.16, 0.19555556, -1.80444444],
[-0.56, -0.16, 3.04, -0.16, -2.16],
[-0.20444444, 0.19555556, -0.16, 1.08444444, -0.91555556],
[-2.20444444, -1.80444444, -2.16, -0.91555556, 7.08444444]]
assert np.allclose(res, exp, atol=1e-04)
def test_effective_resistance_closeness_centrality():
net = ResNetwork.SmallTestNetwork()
res = net.effective_resistance_closeness_centrality(0)
exp = 0.1538
assert np.isclose(res, exp, atol=1e-04)
res = net.effective_resistance_closeness_centrality(4)
exp = 0.08
assert np.isclose(res, exp, atol=1e-04)
def test_effective_resistance():
net = ResNetwork.SmallTestNetwork()
res = net.effective_resistance(1, 1)
exp = 0.0
assert np.isclose(res, exp, atol=1e-04)
res = net.effective_resistance(1, 2)
exp = 4.4444
assert np.isclose(res, exp, atol=1e-04)
def testSerialTrivial():
"""Trivial serial test case
a) 0 --- 1 --- 2
b) 0 --- 1 --- 2 --- 3 --- 4
ER(a)/2 = ER(b)
"""
# construct nw1
idI = [0, 1]
idJ = [1, 2]
val = [1, 1]
nw1 = np.zeros((3, 3))
G1 = nx.DiGraph()
for i, j, v in zip(idI, idJ, val):
nw1[i, j] = v
nw1[j, i] = v
# construct nw2
idI = idI + [2, 3]
idJ = idJ + [3, 4]
val = val + [1, 1]
nw2 = np.zeros((5, 5))
for i, j, v in zip(idI, idJ, val):
nw2[i, j] = v
nw2[j, i] = v
# init ResNetworks
rnw1 = ResNetwork(nw1)
rnw2 = ResNetwork(nw2)
ER1 = rnw1.effective_resistance(0, 2)
ER2 = rnw2.effective_resistance(0, 4)
print "Effective resistances (0,2)"
print "NW1 %.3f\tNW2 %.3f\t 2*NW1 = %.3f" % (ER1, ER2, 2*ER1)
assert (ER1*2-ER2) < 1E-6
def test_init(capsys):
print(ResNetwork.SmallTestNetwork())
out, err = capsys.readouterr()
out_ref = "ResNetwork:\nGeoNetwork:\n" + \
"Network: undirected, 5 nodes, 5 links, link density 0.500." + \
"\nGeographical boundaries:\n" + \
" time lat lon\n" + \
" min 0.0 0.00 -180.00\n" + \
" max 9.0 90.00 180.00\n" + \
"Average resistance: 2.4\n"
assert out == out_ref
def test_admittance_laplacian():
res = ResNetwork.SmallTestNetwork().admittance_lapacian()
exp = [[
0.5,
-0.5,
0.,
0.,
0.,
], [-0.5, 1.125, -0.125, -0.5, 0.], [0., -0.125, 0.25, -0.125, 0.],
[0., -0.5, -0.125, 0.725, -0.1], [0., 0., 0., -0.1, 0.1]]
assert np.allclose(res, exp, atol=1e-04)
def testParallelRandom():
""" 50 random parallel cases
"""
N = 10
p = .7
runs = 0
while runs < 50:
G = nx.fast_gnp_random_graph(N, p)
a = 0
b = G.number_of_nodes() - 1
try:
nx.shortest_path(G, source=a, target=b)
except RuntimeError:
continue
i, j = [], []
for xx in G.edges():
i.append(xx[0])
j.append(xx[1])
# %.1f values for resistance
val = np.round(np.random.ranf(len(i)) * 100) / 10
# and test
nw1 = makeNW(i, j, val)
nw2 = parallelCopy(nw1, a, b)
ER1 = ResNetwork(nw1).effective_resistance(a, b)
ER2 = ResNetwork(nw2).effective_resistance(a, b)
# assertion
assert (ER1 / 2 - ER2) < 1E-6
# increment runs
runs += 1
def test_update_resistances():
net = ResNetwork.SmallTestNetwork()
net.update_resistances(net.adjacency)
res = net.get_admittance()
exp = [[0., 1., 0., 0., 0.], [1., 0., 1., 1., 0.], [0., 1., 0., 1., 0.],
[0., 1., 1., 0., 1.], [0., 0., 0., 1., 0.]]
assert (res == exp).all()
res = net.admittance_lapacian()
exp = [[1., -1., 0., 0., 0.], [-1., 3., -1., -1., 0.],
[0., -1., 2., -1., 0.], [0., -1., -1., 3., -1.],
[0., 0., 0., -1., 1.]]
assert (res == exp).all()
def test_edge_current_flow_betweenness():
net = ResNetwork.SmallTestNetwork()
res = net.edge_current_flow_betweenness()
exp = [[0., 0.4, 0., 0., 0.], [0.4, 0., 0.2444, 0.5333, 0.],
[0., 0.2444, 0., 0.2444, 0.], [0., 0.5333, 0.2444, 0., 0.4],
[0., 0., 0., 0.4, 0.]]
assert np.allclose(res, exp, atol=1e-04)
net.update_resistances(net.adjacency)
res = net.edge_current_flow_betweenness()
exp = [[0., 0.4, 0., 0., 0.], [0.4, 0., 0.3333, 0.4, 0.],
[0., 0.3333, 0., 0.3333, 0.], [0., 0.4, 0.3333, 0., 0.4],
[0., 0., 0., 0.4, 0.]]
assert np.allclose(res, exp, atol=1e-04)
def test_SmallComplexNetwork():
net = ResNetwork.SmallComplexNetwork()
assert net.flagComplex
adm = net.get_admittance()
res = adm.real
exp = [[0., 0.1, 0., 0., 0.], [0.1, 0., 0.0625, 0.25, 0.],
[0., 0.0625, 0., 0.0625, 0.], [0., 0.25, 0.0625, 0., 0.05],
[0., 0., 0., 0.05, 0.]]
assert np.allclose(res, exp, atol=1e-04)
res = adm.imag
exp = [[0., -0.2, 0., 0., 0.], [-0.2, 0., -0.0625, -0.25, 0.],
[0., -0.0625, 0., -0.0625, 0.], [0., -0.25, -0.0625, 0., -0.05],
[0., 0., 0., -0.05, 0.]]
assert np.allclose(res, exp, atol=1e-04)
def testSerialTrivial():
"""Trivial serial test case
a) 0 --- 1 --- 2
b) 0 --- 1 --- 2 --- 3 --- 4
ER(a)/2 = ER(b)
"""
# construct nw1
idI = [0, 1]
idJ = [1, 2]
val = [1, 1]
nw1 = np.zeros((3, 3))
G1 = nx.DiGraph()
for i, j, v in zip(idI, idJ, val):
nw1[i, j] = v
nw1[j, i] = v
# construct nw2
idI = idI + [2, 3]
idJ = idJ + [3, 4]
val = val + [1, 1]
nw2 = np.zeros((5, 5))
for i, j, v in zip(idI, idJ, val):
nw2[i, j] = v
nw2[j, i] = v
# init ResNetworks
rnw1 = ResNetwork(nw1)
rnw2 = ResNetwork(nw2)
ER1 = rnw1.effective_resistance(0, 2)
ER2 = rnw2.effective_resistance(0, 4)
print("Effective resistances (0,2)")
print("NW1 %.3f\tNW2 %.3f\t 2*NW1 = %.3f" % (ER1, ER2, 2 * ER1))
assert (ER1 * 2 - ER2) < 1E-6
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2014 SWIPO Project
#
# Authors (this file):
# Stefan Schinkel <*****@*****.**>
"""
Weave tests to check that python and weave implementations give the same
results
"""
from pyunicorn import ResNetwork
res = ResNetwork.SmallTestNetwork()
resC = ResNetwork.SmallComplexNetwork()
def testVCFB():
for i in range(5):
res.flagWeave = False
vcfbPython = res.vertex_current_flow_betweenness(i)
res.flagWeave = True
vcfbWeave = res.vertex_current_flow_betweenness(i)
assert vcfbPython == vcfbWeave
def testECFB():
res.flagWeave = False
ecfbPython = res.edge_current_flow_betweenness()
res.flagWeave = True
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2014 SWIPO Project
#
# Authors (this file):
# Stefan Schinkel <*****@*****.**>
"""
Provides simple type check for resistive networks
"""
import numpy as np
from pyunicorn import ResNetwork
res = ResNetwork.SmallTestNetwork()
def testAdmittiveDegreeType():
print("testing types")
assert isinstance(res.admittive_degree(), np.ndarray)
def test_admittive_degree():
res = ResNetwork.SmallTestNetwork().admittive_degree()
exp = [0.5, 1.125, 0.25, 0.725, 0.1]
assert np.allclose(res, exp, atol=1e-04)
def test_average_neighbors_admittive_degree():
res = ResNetwork.SmallTestNetwork().average_neighbors_admittive_degree()
exp = [2.25, 1.31111111, 7.4, 2.03448276, 7.25]
assert np.allclose(res, exp, atol=1e-04)
def test_local_admittive_clustering():
res = ResNetwork.SmallTestNetwork().local_admittive_clustering()
exp = [0., 0.00694444, 0.0625, 0.01077586, 0.]
assert np.allclose(res, exp, atol=1e-04)
def test_global_admittive_clustering():
res = ResNetwork.SmallTestNetwork().global_admittive_clustering()
exp = 0.016
assert np.isclose(res, exp, atol=1e-04)
def test_average_effective_resistance():
res = ResNetwork.SmallTestNetwork().average_effective_resistance()
exp = 7.2889
assert np.isclose(res, exp, atol=1e-04)
def test_diameter_effective_resistance():
res = ResNetwork.SmallTestNetwork().diameter_effective_resistance()
exp = 14.4444
assert np.isclose(res, exp, atol=1e-04)
def test_vertex_current_flow_betweenness():
net = ResNetwork.SmallTestNetwork()
res = net.vertex_current_flow_betweenness(1)
exp = 0.3889
assert np.isclose(res, exp, atol=1e-04)
def test_update_R():
net = ResNetwork.SmallTestNetwork()
net.update_R()
assert True
def test_SmallTestNetwork():
assert isinstance(ResNetwork.SmallTestNetwork(), ResNetwork)
def test_update_admittance():
net = ResNetwork.SmallTestNetwork()
net.update_admittance()
assert True
