Mercurial > repos > shellac > sam_consensus_v3
comparison env/lib/python3.9/site-packages/networkx/generators/tests/test_joint_degree_seq.py @ 0:4f3585e2f14b draft default tip
"planemo upload commit 60cee0fc7c0cda8592644e1aad72851dec82c959"
author | shellac |
---|---|
date | Mon, 22 Mar 2021 18:12:50 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:4f3585e2f14b |
---|---|
1 import time | |
2 from networkx.algorithms.assortativity import degree_mixing_dict | |
3 from networkx.generators import powerlaw_cluster_graph, gnm_random_graph | |
4 from networkx.generators.joint_degree_seq import ( | |
5 is_valid_joint_degree, | |
6 joint_degree_graph, | |
7 directed_joint_degree_graph, | |
8 is_valid_directed_joint_degree, | |
9 ) | |
10 | |
11 | |
12 def test_is_valid_joint_degree(): | |
13 """ Tests for conditions that invalidate a joint degree dict """ | |
14 | |
15 # valid joint degree that satisfies all five conditions | |
16 joint_degrees = { | |
17 1: {4: 1}, | |
18 2: {2: 2, 3: 2, 4: 2}, | |
19 3: {2: 2, 4: 1}, | |
20 4: {1: 1, 2: 2, 3: 1}, | |
21 } | |
22 assert is_valid_joint_degree(joint_degrees) | |
23 | |
24 # test condition 1 | |
25 # joint_degrees_1[1][4] not integer | |
26 joint_degrees_1 = { | |
27 1: {4: 1.5}, | |
28 2: {2: 2, 3: 2, 4: 2}, | |
29 3: {2: 2, 4: 1}, | |
30 4: {1: 1.5, 2: 2, 3: 1}, | |
31 } | |
32 assert not is_valid_joint_degree(joint_degrees_1) | |
33 | |
34 # test condition 2 | |
35 # degree_count[2] = sum(joint_degrees_2[2][j)/2, is not an int | |
36 # degree_count[4] = sum(joint_degrees_2[4][j)/4, is not an int | |
37 joint_degrees_2 = { | |
38 1: {4: 1}, | |
39 2: {2: 2, 3: 2, 4: 3}, | |
40 3: {2: 2, 4: 1}, | |
41 4: {1: 1, 2: 3, 3: 1}, | |
42 } | |
43 assert not is_valid_joint_degree(joint_degrees_2) | |
44 | |
45 # test conditions 3 and 4 | |
46 # joint_degrees_3[1][4]>degree_count[1]*degree_count[4] | |
47 joint_degrees_3 = { | |
48 1: {4: 2}, | |
49 2: {2: 2, 3: 2, 4: 2}, | |
50 3: {2: 2, 4: 1}, | |
51 4: {1: 2, 2: 2, 3: 1}, | |
52 } | |
53 assert not is_valid_joint_degree(joint_degrees_3) | |
54 | |
55 # test condition 5 | |
56 # joint_degrees_5[1][1] not even | |
57 joint_degrees_5 = {1: {1: 9}} | |
58 assert not is_valid_joint_degree(joint_degrees_5) | |
59 | |
60 | |
61 def test_joint_degree_graph(ntimes=10): | |
62 for _ in range(ntimes): | |
63 seed = int(time.time()) | |
64 | |
65 n, m, p = 20, 10, 1 | |
66 # generate random graph with model powerlaw_cluster and calculate | |
67 # its joint degree | |
68 g = powerlaw_cluster_graph(n, m, p, seed=seed) | |
69 joint_degrees_g = degree_mixing_dict(g, normalized=False) | |
70 | |
71 # generate simple undirected graph with given joint degree | |
72 # joint_degrees_g | |
73 G = joint_degree_graph(joint_degrees_g) | |
74 joint_degrees_G = degree_mixing_dict(G, normalized=False) | |
75 | |
76 # assert that the given joint degree is equal to the generated | |
77 # graph's joint degree | |
78 assert joint_degrees_g == joint_degrees_G | |
79 | |
80 | |
81 def test_is_valid_directed_joint_degree(): | |
82 | |
83 in_degrees = [0, 1, 1, 2] | |
84 out_degrees = [1, 1, 1, 1] | |
85 nkk = {1: {1: 2, 2: 2}} | |
86 assert is_valid_directed_joint_degree(in_degrees, out_degrees, nkk) | |
87 | |
88 # not realizable, values are not integers. | |
89 nkk = {1: {1: 1.5, 2: 2.5}} | |
90 assert not is_valid_directed_joint_degree(in_degrees, out_degrees, nkk) | |
91 | |
92 # not realizable, number of edges between 1-2 are insufficient. | |
93 nkk = {1: {1: 2, 2: 1}} | |
94 assert not is_valid_directed_joint_degree(in_degrees, out_degrees, nkk) | |
95 | |
96 # not realizable, in/out degree sequences have different number of nodes. | |
97 out_degrees = [1, 1, 1] | |
98 nkk = {1: {1: 2, 2: 2}} | |
99 assert not is_valid_directed_joint_degree(in_degrees, out_degrees, nkk) | |
100 | |
101 # not realizable, degree seqeunces have fewer than required nodes. | |
102 in_degrees = [0, 1, 2] | |
103 assert not is_valid_directed_joint_degree(in_degrees, out_degrees, nkk) | |
104 | |
105 | |
106 def test_directed_joint_degree_graph(n=15, m=100, ntimes=1000): | |
107 for _ in range(ntimes): | |
108 | |
109 # generate gnm random graph and calculate its joint degree. | |
110 g = gnm_random_graph(n, m, None, directed=True) | |
111 | |
112 # in-degree seqeunce of g as a list of integers. | |
113 in_degrees = list(dict(g.in_degree()).values()) | |
114 # out-degree sequence of g as a list of integers. | |
115 out_degrees = list(dict(g.out_degree()).values()) | |
116 nkk = degree_mixing_dict(g) | |
117 | |
118 # generate simple directed graph with given degree sequence and joint | |
119 # degree matrix. | |
120 G = directed_joint_degree_graph(in_degrees, out_degrees, nkk) | |
121 | |
122 # assert degree sequence correctness. | |
123 assert in_degrees == list(dict(G.in_degree()).values()) | |
124 assert out_degrees == list(dict(G.out_degree()).values()) | |
125 # assert joint degree matrix correctness. | |
126 assert nkk == degree_mixing_dict(G) |