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)