def SI_random(self):
zm = [sp.csr_matrix((self.size,self.size),dtype=np.int8) for ii in range(self.runtime+1)]
zm[0] = sp.eye(self.size,self.size,dtype=np.int8, format='csr')
C = to_scipy_sparse_matrix(fast_gnp_random_graph(self.size,self.prob),dtype=np.int8,format='csr') + sp.eye(self.size, self.size, 0, dtype=np.int8, format='csr')
for ii in range(1,self.runtime+1):
zm[ii] = C
C = (to_scipy_sparse_matrix(fast_gnp_random_graph(self.size,self.prob),dtype=np.int8,format='csr') + sp.eye(self.size, self.size, 0, dtype=np.int8, format='csr'))*C
return zm
def smoke_test_random_graph(self):
seed = 42
G=gnp_random_graph(100,0.25,seed)
G=binomial_graph(100,0.25,seed)
G=erdos_renyi_graph(100,0.25,seed)
G=fast_gnp_random_graph(100,0.25,seed)
G=gnm_random_graph(100,20,seed)
G=dense_gnm_random_graph(100,20,seed)
G=watts_strogatz_graph(10,2,0.25,seed)
assert_equal(len(G), 10)
assert_equal(G.number_of_edges(), 10)
G=connected_watts_strogatz_graph(10,2,0.1,seed)
assert_equal(len(G), 10)
assert_equal(G.number_of_edges(), 10)
G=watts_strogatz_graph(10,4,0.25,seed)
assert_equal(len(G), 10)
assert_equal(G.number_of_edges(), 20)
G=newman_watts_strogatz_graph(10,2,0.0,seed)
assert_equal(len(G), 10)
assert_equal(G.number_of_edges(), 10)
G=newman_watts_strogatz_graph(10,4,0.25,seed)
assert_equal(len(G), 10)
assert_true(G.number_of_edges() >= 20)
G=barabasi_albert_graph(100,1,seed)
G=barabasi_albert_graph(100,3,seed)
assert_equal(G.number_of_edges(),(97*3))
G = extended_barabasi_albert_graph(100, 1, 0, 0, seed)
assert_equal(G.number_of_edges(), 99)
G = extended_barabasi_albert_graph(100, 3, 0, 0, seed)
assert_equal(G.number_of_edges(), 97 * 3)
G = extended_barabasi_albert_graph(100, 1, 0, 0.5, seed)
assert_equal(G.number_of_edges(), 99)
G = extended_barabasi_albert_graph(100, 2, 0.5, 0, seed)
assert_greater(G.number_of_edges(), 100 * 3)
assert_less(G.number_of_edges(), 100 * 4)
G=extended_barabasi_albert_graph(100, 2, 0.3, 0.3, seed)
assert_greater(G.number_of_edges(), 100 * 2)
assert_less(G.number_of_edges(), 100 * 4)
G=powerlaw_cluster_graph(100,1,1.0,seed)
G=powerlaw_cluster_graph(100,3,0.0,seed)
assert_equal(G.number_of_edges(),(97*3))
G=random_regular_graph(10,20,seed)
assert_raises(NetworkXError, random_regular_graph, 3, 21)
constructor=[(10,20,0.8),(20,40,0.8)]
G=random_shell_graph(constructor,seed)
G=random_lobster(10,0.1,0.5,seed)
def _getGraph(self, values):
n = values['Nodes']
p = values['Density']
G = rnd.fast_gnp_random_graph(n, p, directed=True)
nodes = layout.circularNodes(n, 25)
return G, nodes
def SIS_random(self):
#=======================================================================
# SIR_random() berechnet ein Ausbruchsszenario nach dem SIR-Modell.
# Als Adjazenzmatrizen werden zu jedem Zeitschritt Erdos-Renyi-Graphen ausgewuerfelt.
#=======================================================================
#=======================================================================
# Berechnung der Leslie-Matrix fuer den ersten Zeitschritt
#=======================================================================
T = sp.lil_matrix((self.memory+1,self.memory+1),dtype=np.int8)
T[0,:] = 1
T = T.tocsr()
K = sp.eye(self.memory+1,self.memory+1,1,dtype=np.int8,format='csr').transpose()
M = sp.kron(K, sp.eye(self.size,self.size,dtype=np.int8, format='csr'), format='csr')
A = to_scipy_sparse_matrix(fast_gnp_random_graph(self.size,self.prob),dtype=np.int8,format='csr')
L = M + sp.kron(T,A, format='csr')
#=======================================================================
# C beinhaltet die Altersklassen des Netzwerks
# sumup ist eine Hilfsmatrix um C blockweise aufzusummieren
# Die Zugangsmatrix zm zum Zeitpunkt 0 ist die Einheitsmatrix und
# zum Zeitpunkt 1 gerade gleich der ersten Adjazenzmatrix und eins wenn
# die Infektionsperiode groesser ist als 0
#=======================================================================
C = L[:,0:self.size]
tmp = [sp.csr_matrix((self.size,self.size),dtype=np.int8) for ii in range(self.memory+1)]
sumup = sp.hstack([sp.eye(self.size,self.size,dtype=np.int8, format='csr') for ii in range(self.memory+1)]).tocsr()
zm = [sp.csr_matrix((self.size,self.size),dtype=np.int8) for ii in range(self.runtime+1)]
zm[0] = sp.eye(self.size,self.size,dtype=np.int8, format='csr')
if self.memory > 0:
zm[1] = zm[0] + C[0:self.size,:]
else:
zm[1] = C[0:self.size,:]
#=======================================================================
# Die zeitabhaengige Zugangsmatrix wird berechnet
#=======================================================================
for ii in range(2,self.runtime+1): #runtime > 1
A = to_scipy_sparse_matrix(fast_gnp_random_graph(self.size,self.prob),dtype=np.int8,format='csr')
L = M + sp.kron(T,A, format='csr')
C = L*C
C = self.clearMat(C, tmp)
zm[ii] = sumup*C
return zm
def fastGnp(n,p=0.3):
graphsToReturn = []
for i in range(100):
print RandomGraphGenerator.fast_gnp_random_graph, n, i
graphsToReturn.append([i*TIME_UNIT_IN_SECONDS, my_nx.getDictForGraph(fast_gnp_random_graph(n,p))])
return graphsToReturn
def smoke_test_random_graph(self):
seed = 42
G = gnp_random_graph(100, 0.25, seed)
G = gnp_random_graph(100, 0.25, seed, directed=True)
G = binomial_graph(100, 0.25, seed)
G = erdos_renyi_graph(100, 0.25, seed)
G = fast_gnp_random_graph(100, 0.25, seed)
G = fast_gnp_random_graph(100, 0.25, seed, directed=True)
G = gnm_random_graph(100, 20, seed)
G = gnm_random_graph(100, 20, seed, directed=True)
G = dense_gnm_random_graph(100, 20, seed)
G = watts_strogatz_graph(10, 2, 0.25, seed)
assert_equal(len(G), 10)
assert_equal(G.number_of_edges(), 10)
G = connected_watts_strogatz_graph(10, 2, 0.1, tries=10, seed=seed)
assert_equal(len(G), 10)
assert_equal(G.number_of_edges(), 10)
assert_raises(NetworkXError, connected_watts_strogatz_graph, \
10, 2, 0.1, tries=0)
G = watts_strogatz_graph(10, 4, 0.25, seed)
assert_equal(len(G), 10)
assert_equal(G.number_of_edges(), 20)
G = newman_watts_strogatz_graph(10, 2, 0.0, seed)
assert_equal(len(G), 10)
assert_equal(G.number_of_edges(), 10)
G = newman_watts_strogatz_graph(10, 4, 0.25, seed)
assert_equal(len(G), 10)
assert_true(G.number_of_edges() >= 20)
G = barabasi_albert_graph(100, 1, seed)
G = barabasi_albert_graph(100, 3, seed)
assert_equal(G.number_of_edges(), (97 * 3))
G = extended_barabasi_albert_graph(100, 1, 0, 0, seed)
assert_equal(G.number_of_edges(), 99)
G = extended_barabasi_albert_graph(100, 3, 0, 0, seed)
assert_equal(G.number_of_edges(), 97 * 3)
G = extended_barabasi_albert_graph(100, 1, 0, 0.5, seed)
assert_equal(G.number_of_edges(), 99)
G = extended_barabasi_albert_graph(100, 2, 0.5, 0, seed)
assert_greater(G.number_of_edges(), 100 * 3)
assert_less(G.number_of_edges(), 100 * 4)
G = extended_barabasi_albert_graph(100, 2, 0.3, 0.3, seed)
assert_greater(G.number_of_edges(), 100 * 2)
assert_less(G.number_of_edges(), 100 * 4)
G = powerlaw_cluster_graph(100, 1, 1.0, seed)
G = powerlaw_cluster_graph(100, 3, 0.0, seed)
assert_equal(G.number_of_edges(), (97 * 3))
G = random_regular_graph(10, 20, seed)
assert_raises(NetworkXError, random_regular_graph, 3, 21)
assert_raises(NetworkXError, random_regular_graph, 33, 21)
constructor = [(10, 20, 0.8), (20, 40, 0.8)]
G = random_shell_graph(constructor, seed)
G = random_lobster(10, 0.1, 0.5, seed)
# difficult to find seed that requires few tries
seq = random_powerlaw_tree_sequence(10, 3, seed=14, tries=1)
G = random_powerlaw_tree(10, 3, seed=14, tries=1)
def sparse_er_generator(n):
p = 2 / n
return fast_gnp_random_graph(n, p)
def test_random_graph(self):
seed = 42
G = gnp_random_graph(100, 0.25, seed)
G = gnp_random_graph(100, 0.25, seed, directed=True)
G = binomial_graph(100, 0.25, seed)
G = erdos_renyi_graph(100, 0.25, seed)
G = fast_gnp_random_graph(100, 0.25, seed)
G = fast_gnp_random_graph(100, 0.25, seed, directed=True)
G = gnm_random_graph(100, 20, seed)
G = gnm_random_graph(100, 20, seed, directed=True)
G = dense_gnm_random_graph(100, 20, seed)
G = watts_strogatz_graph(10, 2, 0.25, seed)
assert len(G) == 10
assert G.number_of_edges() == 10
G = connected_watts_strogatz_graph(10, 2, 0.1, tries=10, seed=seed)
assert len(G) == 10
assert G.number_of_edges() == 10
pytest.raises(NetworkXError, connected_watts_strogatz_graph,
10, 2, 0.1, tries=0)
G = watts_strogatz_graph(10, 4, 0.25, seed)
assert len(G) == 10
assert G.number_of_edges() == 20
G = newman_watts_strogatz_graph(10, 2, 0.0, seed)
assert len(G) == 10
assert G.number_of_edges() == 10
G = newman_watts_strogatz_graph(10, 4, 0.25, seed)
assert len(G) == 10
assert G.number_of_edges() >= 20
G = barabasi_albert_graph(100, 1, seed)
G = barabasi_albert_graph(100, 3, seed)
assert G.number_of_edges() == (97 * 3)
G = extended_barabasi_albert_graph(100, 1, 0, 0, seed)
assert G.number_of_edges() == 99
G = extended_barabasi_albert_graph(100, 3, 0, 0, seed)
assert G.number_of_edges() == 97 * 3
G = extended_barabasi_albert_graph(100, 1, 0, 0.5, seed)
assert G.number_of_edges() == 99
G = extended_barabasi_albert_graph(100, 2, 0.5, 0, seed)
assert G.number_of_edges() > 100 * 3
assert G.number_of_edges() < 100 * 4
G = extended_barabasi_albert_graph(100, 2, 0.3, 0.3, seed)
assert G.number_of_edges() > 100 * 2
assert G.number_of_edges() < 100 * 4
G = powerlaw_cluster_graph(100, 1, 1.0, seed)
G = powerlaw_cluster_graph(100, 3, 0.0, seed)
assert G.number_of_edges() == (97 * 3)
G = random_regular_graph(10, 20, seed)
pytest.raises(NetworkXError, random_regular_graph, 3, 21)
pytest.raises(NetworkXError, random_regular_graph, 33, 21)
constructor = [(10, 20, 0.8), (20, 40, 0.8)]
G = random_shell_graph(constructor, seed)
G = random_lobster(10, 0.1, 0.5, seed)
# difficult to find seed that requires few tries
seq = random_powerlaw_tree_sequence(10, 3, seed=14, tries=1)
G = random_powerlaw_tree(10, 3, seed=14, tries=1)
