def test_net(n):
n[1, 2, 'a', 'x'] = 3
n.add_layer('b', 1)
n.add_layer('y', 2)
n.add_node(3, layer=('a', 'x'))
n.add_node(4, layer=('c', 'z'))
an1 = transforms.aggregate(n, 1)
self.assertEqual(set(an1), set([1, 2, 3, 4]))
self.assertEqual(set(an1.iter_node_layers()),
set([(1, 'x'), (2, 'x'), (3, 'x'), (4, 'z')]))
an2 = transforms.aggregate(n, 2)
self.assertEqual(set(an2), set([1, 2, 3, 4]))
self.assertEqual(set(an2.iter_node_layers()),
set([(1, 'a'), (2, 'a'), (3, 'a'), (4, 'c')]))
def test_aggregate_2dim_mlayer_interlayeredges(self):
n = net.MultilayerNetwork(aspects=2, fullyInterconnected=False)
n[1, 'a', 'x'][2, 'b', 'y'] = 3
n[1, 'c', 'x'][2, 'd', 'y'] = 1
n[1, 'a', 'x'][2, 'b', 'x'] = 1
an1 = transforms.aggregate(n, 1)
self.assertEqual(set(an1.edges),
set([(1, 2, 'x', 'y', 4), (1, 2, 'x', 'x', 1)]))
an2 = transforms.aggregate(n, 2)
self.assertEqual(set(an2.edges),
set([(1, 2, 'a', 'b', 4), (1, 2, 'c', 'd', 1)]))
an3 = transforms.aggregate(n, (1, 2))
self.assertEqual(set(an3.edges), set([(1, 2, 5)]))
self.assertEqual(an3, transforms.aggregate(an1, 1))
self.assertEqual(an3, transforms.aggregate(an2, 1))
def test_aggregate_unweighted_mplex_simple(self):
an = transforms.aggregate(self.mplex_simple, 1)
self.assertEqual(an[1, 2], 3)
self.assertEqual(an[1, 3], 3)
self.assertEqual(an[1, 4], 2)
self.assertEqual(an[2, 3], 1)
self.assertEqual(an[3, 4], 1)
self.assertEqual(an[2, 4], 1)
def test_net(n):
n[1, 2, 'a'] = 1
n.add_layer('b')
n.add_node(3, layer=('a'))
n.add_node(4, layer=('c'))
an = transforms.aggregate(n, 1)
self.assertEqual(set(an), set([1, 2, 3, 4]))
self.assertEqual(an[1, 2], 1)
self.assertEqual(an.aspects, 0)
def test_aggregate_2dim_mplex(self):
n = net.MultiplexNetwork([('categorical', 1.0), ('categorical', 1.0)])
n[1, 2, 'a', 'x'] = 3
n[2, 3, 'a', 'x'] = 1
n[1, 2, 'b', 'x'] = 1
n[1, 3, 'b', 'x'] = 1
n[1, 2, 'c', 'x'] = 1
n[1, 3, 'c', 'x'] = 1
n[2, 3, 'c', 'x'] = 1
n[1, 2, 'b', 'y'] = 1
n[2, 3, 'b', 'y'] = 1
n[1, 2, 'c', 'y'] = 1
n[1, 3, 'c', 'y'] = 1
n[1, 2, 'a', 'y'] = 1
n[1, 3, 'a', 'y'] = 1
n[2, 3, 'a', 'y'] = 1
an1 = transforms.aggregate(n, 1)
self.assertEqual(an1[1, 2, 'x'], 5)
self.assertEqual(an1[1, 3, 'x'], 2)
self.assertEqual(an1[2, 3, 'x'], 2)
self.assertEqual(an1[1, 2, 'y'], 3)
self.assertEqual(an1[1, 3, 'y'], 2)
self.assertEqual(an1[2, 3, 'y'], 2)
an2 = transforms.aggregate(n, 2)
self.assertEqual(an2[1, 2, 'a'], 4)
self.assertEqual(an2[1, 3, 'a'], 1)
self.assertEqual(an2[2, 3, 'a'], 2)
self.assertEqual(an2[1, 2, 'b'], 2)
self.assertEqual(an2[1, 3, 'b'], 1)
self.assertEqual(an2[2, 3, 'b'], 1)
self.assertEqual(an2[1, 2, 'c'], 2)
self.assertEqual(an2[1, 3, 'c'], 2)
self.assertEqual(an2[2, 3, 'c'], 1)
an3 = transforms.aggregate(n, (1, 2))
self.assertEqual(an3[1, 2], 8)
self.assertEqual(an3[1, 3], 4)
self.assertEqual(an3[2, 3], 4)
self.assertEqual(an3, transforms.aggregate(an1, 1))
self.assertEqual(an3, transforms.aggregate(an2, 1))
def test_weighted_consistency_mslice(self, net):
anet = transforms.aggregate(net, 1)
onet = transforms.overlay_network(net)
wmax = max(map(lambda x: x[2], anet.edges))
owmax = max(map(lambda x: x[2], onet.edges))
b = len(net.slices[1])
self.assertAlmostEqual(cc.gcc_contraction_m(net),
cc.gcc_contraction_m_ct(net))
self.assertAlmostEqual(cc.gcc_contraction_m_ct(net),
cc.gcc_contraction_m_full(net))
#self.assertAlmostEqual(cc.gcc_contraction_m_full(net),cc.gcc_super_graph(net))
self.assertAlmostEqual(cc.gcc_contraction_o2(net),
owmax * cc.gcc_zhang(onet) / float(b))
self.assertAlmostEqual(cc.gcc_contraction_o2(net),
cc.gcc_contraction_o_full(net))
def test_symmetric_aw(self, net):
import numpy
adj, nodes1 = net.get_supra_adjacency_matrix()
a, nodes2 = net.get_supra_adjacency_matrix(includeCouplings=False)
c = adj - a
i = numpy.eye(len(a))
ch = c + i
b = len(net.slices[1])
assert (c * c == (b - 1) * i + (b - 2) * c).all()
#fn=cc.get_full_multiplex_network(net.slices[0],net.slices[1])
#f,node3=fn.get_supra_adjacency_matrix(includeCouplings=False)
#ca+ac version
t = (ch * a + a * ch) * (ch * a + a * ch) * (ch * a + a * ch)
t_simple = 4 * (b + 1) * a * a * a + 2 * (
b + 2
) * a * c * a * a * c + 4 * a * a * c * a * c + 2 * (
b + 1
) * a * c * a * c * a + 2 * a * c * a * c * a * c + 2 * c * a * c * a * a * c + 2 * c * a * a * a * c
for node in range(len(a)):
assert t[node, node] == t_simple[node, node]
#c'a+ac' version
chd = c + 0.5 * i
t = (chd * a + a * chd) * (chd * a + a * chd) * (chd * a + a * chd)
t_simple = (
2 * b - 1
) * a**3 + 2 * a**2 * c * a * c + 2 * b * a * c * a**2 * c + (
2 * b - 1
) * a * c * a * c * a + 2 * a * c * a * c * a * c + c * a**3 * c + 2 * c * a**2 * c * a * c
for node in range(len(a)):
assert t[node, node] == t_simple[node, node]
#c'a+ac' version with random alpha and beta
alpha, beta = random.random(), random.random()
chd = beta * c + 0.5 * alpha * i
t = (chd * a + a * chd) * (chd * a + a * chd) * (chd * a + a * chd)
t_simple = alpha**3 * a**3 - 2 * alpha * beta**2 * a**3 + 2 * alpha * b * beta**2 * a**3 + alpha * beta**2 * c * a**3 * c - 4 * beta**3 * a * c * a**2 * c - 4 * beta**3 * a * c * a * c * a + 2 * alpha * beta**2 * a**2 * c * a * c + 2 * b * beta**3 * a * c * a**2 * c + 2 * beta**3 * c * a**2 * c * a * c + 4 * alpha * beta**2 * a * c * a**2 * c + 2 * b * beta**3 * a * c * a * c * a + 2 * beta**3 * a * c * a * c * a * c + 3 * alpha * beta**2 * a * c * a * c * a
for node in range(len(a)):
self.assertAlmostEqual(t[node, node], t_simple[node, node])
#cac version with random alpha and beta
alpha, beta = random.random(), random.random()
ch = beta * c + alpha * i
t = (ch * a * ch) * (ch * a * ch) * (ch * a * ch)
t_simple = alpha**6 * a**3 + alpha**2 * beta**4 * a**3 - 2 * alpha**4 * beta**2 * a**3 + alpha**2 * beta**4 * b**2 * a**3 + beta**6 * c * a**3 * c - 2 * b * alpha**2 * beta**4 * a**3 + 2 * b * alpha**4 * beta**2 * a**3 + alpha**4 * beta**2 * c * a**3 * c + beta**6 * b**2 * c * a**3 * c - 2 * b * beta**6 * c * a**3 * c - 2 * alpha**2 * beta**4 * c * a**3 * c - 4 * alpha**2 * beta**4 * a * c * a**2 * c - 4 * alpha**2 * beta**4 * a**2 * c * a * c - 4 * alpha**3 * beta**3 * a * c * a**2 * c - 4 * alpha**3 * beta**3 * a**2 * c * a * c + 2 * b * alpha**2 * beta**4 * c * a**3 * c + 4 * alpha * beta**5 * a * c * a**2 * c + 4 * alpha * beta**5 * a**2 * c * a * c + 4 * alpha**4 * beta**2 * a * c * a**2 * c + 4 * alpha**4 * beta**2 * a**2 * c * a * c + 4 * beta**6 * c * a**2 * c * a * c - 8 * alpha**3 * beta**3 * a * c * a * c * a - 6 * alpha * b * beta**5 * a * c * a**2 * c - 6 * alpha * b * beta**5 * a**2 * c * a * c - 6 * b * beta**6 * c * a**2 * c * a * c - 4 * alpha * beta**5 * c * a**2 * c * a * c - 4 * alpha**2 * beta**4 * c * a**2 * c * a * c + 2 * alpha * beta**5 * b**2 * a * c * a**2 * c + 2 * alpha * beta**5 * b**2 * a**2 * c * a * c + 2 * b * alpha**3 * beta**3 * a * c * a**2 * c + 2 * b * alpha**3 * beta**3 * a**2 * c * a * c + 2 * beta**6 * b**2 * c * a**2 * c * a * c + 4 * b * alpha**2 * beta**4 * a * c * a**2 * c + 4 * b * alpha**2 * beta**4 * a**2 * c * a * c + 4 * alpha**2 * beta**4 * a * c * a * c * a + 4 * alpha**3 * beta**3 * c * a**2 * c * a * c + 4 * alpha**4 * beta**2 * a * c * a * c * a + alpha**2 * beta**4 * b**2 * a * c * a * c * a - 16 * alpha**2 * beta**4 * a * c * a * c * a * c - 4 * b * alpha**2 * beta**4 * a * c * a * c * a + 2 * b * alpha**2 * beta**4 * c * a**2 * c * a * c + 4 * alpha * b * beta**5 * c * a**2 * c * a * c + 4 * b * alpha**3 * beta**3 * a * c * a * c * a + 4 * beta**6 * c * a * c * a * c * a * c + 8 * alpha * beta**5 * a * c * a * c * a * c + 8 * alpha**3 * beta**3 * a * c * a * c * a * c + beta**6 * b**2 * c * a * c * a * c * a * c - 8 * alpha * b * beta**5 * a * c * a * c * a * c - 8 * alpha * beta**5 * c * a * c * a * c * a * c - 4 * b * beta**6 * c * a * c * a * c * a * c + 2 * alpha * beta**5 * b**2 * a * c * a * c * a * c + 4 * alpha**2 * beta**4 * c * a * c * a * c * a * c + 8 * b * alpha**2 * beta**4 * a * c * a * c * a * c + 4 * alpha * b * beta**5 * c * a * c * a * c * a * c
for node in range(len(a)):
self.assertAlmostEqual(t[node, node], t_simple[node, node])
#cac version
ch = c + i
t = (ch * a * ch) * (ch * a * ch) * (ch * a * ch)
t_simple = b**2 * (
a**3 +
(2 * a * c * a**2 * c + 2 * a**2 * c * a * c + a * c * a * c * a) +
(2 * a * c * a * c * a * c) + c * a**3 * c + c * a**2 * c * a * c +
c * a * c * a**2 * c + c * a * c * a * c * a * c)
cac_sum = 0
for node in range(len(a)):
cac_sum += t[node, node]
assert t[node, node] == t_simple[node, node]
anet = transforms.aggregate(net, 1)
w, nodes1 = anet.get_supra_adjacency_matrix()
m = ch * a * ch
saw = m * m * m
moreno_tot = 0
aw_tot = 0
w_tot = 0
for snode in range(len(w)):
moreno_sum = 0
aw_sum = 0
for layer in range(int(len(a) / len(w))):
aaa, aacac, acaac, acaca, acacac, afa, afcac, acfac, acfca, acfcac = cc.cc_cycle_vector_bf(
net, snode, layer)
moreno_sum += aaa + 2 * aacac + 2 * acaac + acaca + 2 * acacac
aw_sum += aaa + aacac + acaac + acaca + acacac
self.assertEqual(aw_sum,
saw[snode + len(w), snode + len(w)] / b / b)
self.assertEqual(aw_sum, (w * w * w)[snode, snode])
moreno_tot += moreno_sum
aw_tot += aw_sum
w_tot += (w * w * w)[snode, snode]
self.assertEqual(aw_tot, w_tot)
"""
def test_unweighted_consistency(self, net):
anet = transforms.aggregate(net, 1)
onet = transforms.overlay_network(net)
wmax = max(map(lambda x: x[2], anet.edges))
owmax = max(map(lambda x: x[2], onet.edges))
b = len(net.slices[1])
self.assertEqual(cc.cc_cycle_vector_bf(net, 1, 1),
cc.cc_cycle_vector_adj(net, 1, 1))
#----
t = 0
node = 1
for i, j in itertools.combinations(anet[node], 2):
t += anet[node][i] * anet[node][j] * anet[i][j]
d = 0
for i, j in itertools.combinations(anet[node], 2):
d += anet[node][i] * anet[node][j] * len(net.slices[1])
lt = 0
ld = 0
sums = [0 for i in range(10)]
for l in net.slices[1]:
aaa, aacac, acaac, acaca, acacac, afa, afcac, acfac, acfca, acfcac = cc.cc_cycle_vector_bf(
net, 1, l)
self.assertEqual((aaa, aacac, acaac, acaca, acacac, afa, afcac,
acfac, acfca, acfcac),
cc.cc_cycle_vector_anet(net, 1, l, anet))
sums = map(lambda x, y: x + y, sums, [
aaa, aacac, acaac, acaca, acacac, afa, afcac, acfac, acfca,
acfcac
])
lt += aaa + aacac + acaac + acaca + acacac
ld += afa + afcac + acfac + acfca + acfcac
self.assertEqual(tuple(sums),
cc.cc_cycle_vector_anet(net, 1, None, anet))
self.assertEqual(2 * t, lt)
self.assertEqual(2 * d, ld)
cc.gcc_aw_vector_adj(net)
self.assertAlmostEqual(
cc.gcc_aw(net, w1=0.3, w2=0.3, w3=0.3),
cc.gcc_aw_seplayers_adj(net, w1=0.3, w2=0.3, w3=0.3))
for supernode in net.slices[0]:
self.assertAlmostEqual(
cc.sncc_aw(net, supernode, w1=0.5, w2=0.5, w3=None),
wmax / float(b) * cc.cc_zhang(anet, supernode))
#global cc
tga = 0
tgaw = 0
tgmoreno = 0
for node in net:
for i, j in itertools.combinations(anet[node], 2):
tga += 2 * anet[node][i] * anet[node][j] * anet[i][j]
for l in net.slices[1]:
aaa, aacac, acaac, acaca, acacac, afa, afcac, acfac, acfca, acfcac = cc.cc_cycle_vector_bf(
net, node, l)
tgaw += aaa + aacac + acaac + acaca + acacac
tgmoreno += aaa + 2 * aacac + 2 * acaac + acaca + 2 * acacac
"""
