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 """