def redundant_ties_model():
clique_size = [
3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20
]
# clique sizes
clique_edges = np.asarray(clique_size)
clique_edges = np.divide(np.multiply(clique_edges, clique_edges + 1), 2)
ep = 0.1
clique_num = np.zeros(len(clique_size))
# number of cliques of given size
for i in range(len(clique_size)):
clique_num[i] = int(2.5321 * (40.0 / (clique_size[i])**3))
clique_num = map(int, clique_num)
# comment this next line to generate a small sample graph easy to visualize
#clique_num = [0,7,3,1,0,0,0,0]
##########################################################
def r_num(size):
''' # number of representetives given clique size
maxrep = size-1; p = (size**2)/100.0;
#a = np.random.binomial(3, size/10.0) + 1
print p
if size == 3:
a = np.random.binomial(1, p) + 1
elif size >3 and size <6:
a = np.random.binomial(2, p) + 1
elif p>=1:
a = np.random.binomial(3, 0.95) + 1
else:
a = np.random.binomial(3, p) + 1
'''
if size == 3:
a = 1
elif size > 3 and size < 6:
a = np.random.randint(1, 2)
elif size > 5 and size < 11:
a = np.random.randint(2, 3)
else:
a = np.random.randint(3, 4)
return a
###########################################################
# almost cliques are generated
Gclique, r, r_cliquewise, clique_sizes, rep_numbers_cliquewise, reps_ordered_cliquewise, clique_start = almost_clique(
clique_size, clique_num, r_num)
print(len(rep_numbers_cliquewise)), 'cliques formed'
clique_list = []
for i in range(len(clique_size)):
dum = np.linspace(clique_size[i], clique_size[i], clique_num[i])
clique_list = np.hstack((clique_list, dum))
cn = len(clique_list)
########################### Spanning Tree with Power Law #####################
'''
global T
T=nx.random_powerlaw_tree(cn, tries=1000000)
plt.figure(2)
nx.draw(T, pos=nx.circular_layout(T))
'''
####### MST of Randomly Weighted Undirected Complete Graph on n nodes ########
GT = {}
for u in range(len(rep_numbers_cliquewise)):
GT[u] = {}
for u in range(len(rep_numbers_cliquewise)):
for v in range(u):
r = random()
GT[u][v] = r
GT[v][u] = r
T2 = mst(GT)
#print "T=", T2
mst_weight = sum([GT[u][v] for u, v in T2])
T2G = nx.Graph()
for u in range(len(rep_numbers_cliquewise)):
for v in range(len(rep_numbers_cliquewise)):
if (u, v) in T2:
#print "(u,v)=", u, v
T2G.add_edge(u, v)
plt.figure(1)
nx.draw(T2G, pos=nx.circular_layout(T2G))
#############################################################################
CBnodes1 = []
CBnodes2 = []
updated_CB = []
updated_CB_edges = []
for u in range(0, cn):
for v in T2G[u]:
CBnodes1 = []
CBupdated1 = []
CBnodes2 = []
updated_CB_edges = []
CB_u = []
if v >= u:
CB = nx.complete_bipartite_graph(rep_numbers_cliquewise[u],
rep_numbers_cliquewise[v])
print 'CB', CB.edges()
for i in range(rep_numbers_cliquewise[u]):
CBnodes1.append(CB.nodes()[i])
CBnodes1 = np.array(CBnodes1)
for i in range(rep_numbers_cliquewise[u]):
CBupdated1 = r_cliquewise[u]
#print "CBnodes1", CBnodes1
#print "CBupdated1", CBupdated1
for i in range(rep_numbers_cliquewise[v]):
CBnodes2.append(CB.nodes()[i])
CBnodes2 = np.array(CBnodes2)
for i in range(rep_numbers_cliquewise[v]):
CBupdated2 = r_cliquewise[v]
#print "CBnodes2", CBnodes2
#print "CBupdated2", CBupdated2
updated_CB = np.union1d(CBupdated1, CBupdated2)
print "updated_CB", updated_CB
for i in range(rep_numbers_cliquewise[u]):
for j in range(rep_numbers_cliquewise[v]):
updated_CB_edges.append([
updated_CB[i],
updated_CB[rep_numbers_cliquewise[u] + j]
])
print "updated_CB_edges", updated_CB_edges
edges = randint(1, len(CB.edges()))
print "edges", edges
e = 0
e_index = np.random.choice(len(CB.edges()),
edges,
replace=False)
print "e_index", e_index
'''
for i in range(rep_numbers_cliquewise[u]):
for j in range(rep_numbers_cliquewise[v]):
if e<edges:
n1= reps_ordered_cliquewise[u][0:i]
n2= reps_ordered_cliquewise[v][0:j]
Gclique.add_edge(clique_start[u]+reps_ordered_cliquewise[u][i], clique_start[v]+reps_ordered_cliquewise[v][j])
e=e+1
'''
print len(updated_CB_edges)
for i in range(len(e_index)):
if e < edges:
print updated_CB_edges[e_index[i]]
CB_u.append(updated_CB_edges[e_index[i]])
Gclique.add_edges_from(CB_u)
e = e + 1
#degthis,a1,a2 = draw_degdist(Gclique,2,'b',0)
'''
figcolor = 'purple'
plt.figure(3)
plt.scatter((a1),(a2),c=figcolor,marker='o',s=400,alpha=0.5)
plt.plot((a1),(a2),linewidth=2,c=figcolor)
plt.xlabel('node degree',fontsize=30)
plt.ylabel('number of nodes',fontsize=30)
plt.axis([0, 4, -0.1, 7])
'''
colors = []
c = 0
for i in range(len(clique_list)):
colors.extend(np.linspace(c, c, clique_list[i]))
c = c + 1
#pos=nx.spring_layout(Gclique,iterations=200)
posx = []
posy = []
for i in range(len(clique_list)):
centerx = np.cos(2 * np.pi * i / len(clique_list))
centery = np.sin(2 * np.pi * i / len(clique_list))
x1 = []
y1 = []
for j in range(int(clique_list[i])):
x1.append(centerx + 0.2 * np.cos(2 * np.pi * j / clique_list[i]))
y1.append(centery + 0.2 * np.sin(2 * np.pi * j / clique_list[i]))
posx.extend(x1)
posy.extend(y1)
#posx.extend(centerx+np.random.rand(clique_list[i])*0.3)
#posy.extend(centery+np.random.rand(clique_list[i])*0.3)
pos = np.transpose(np.vstack((posx, posy)))
plt.figure(2)
nx.draw(Gclique,
pos,
node_color=colors,
node_size=800,
cmap=plt.cm.Purples)
plt.show()
print 'diameter of redundant ties network is', nx.diameter(Gclique)
print 'avg clustering coeff is', nx.average_clustering(Gclique)
print 'avg shortest path length', nx.average_shortest_path_length(Gclique)
return Gclique
def Bridging_ties_model(N_init, sampleN):
clique_size = [3,4,5,6,7,8,9,10,11,12,13,14,15]; # clique sizes
total1=0.0
clique_num = np.zeros(len(clique_size)) # number of cliques of given size
########################## Algorithm 1 Final Version ######################
xk = np.arange(13)
pk = (1.0/27, 1.0/64, 1.0/125, 1.0/216, 1.0/343, 1.0/512, 1.0/729, 1.0/1000 , 1.0/1331, 1.0/1728, 1.0/2197, 1.0/2744, 1.0/3375)
#pk = (1.0/9, 1.0/16, 1.0/25, 1.0/36, 1.0/49, 1.0/64, 1.0/81, 1.0/100 , 1.0/121, 1.0/144, 1.0/169, 1.0/196, 1.0/225) # alpha= 2
pk=np.multiply(13.3372634, pk)
#pk=np.multiply(3.02627, pk)
#print pk
custm = st.rv_discrete(name='custm', values=(xk, pk))
R = custm.rvs(size=N_init)
R_sorted=sorted(R)
counter=collections.Counter(R_sorted)
keys=np.add(counter.keys(), 3)
AClist= np.divide(counter.values(), keys)
n_remaining= N_init-sum(np.multiply(AClist, keys))
(q,r)=divmod(n_remaining,3)
if n_remaining==5:
AClist[2]=AClist[2]+1
elif r==0:
AClist[0]=AClist[0]+n_remaining/3
else:
if len(AClist)==1:
AClist=np.append(AClist, 0)
if (n_remaining % 3 == 2):
AClist[0]=AClist[0]+n_remaining/3 - 2
AClist[1]=AClist[1]+2
if (n_remaining % 3 == 1):
AClist[0]=AClist[0]+n_remaining/3 - 1
AClist[1]=AClist[1]+1
for i in range(len(AClist)):
clique_num[i] = int(AClist[i])
clique_num = map(int,clique_num)
#print clique_num
'''
plt.figure(1)
plt.scatter(counter.keys(),counter.values(),c='r',marker='o',s=100,alpha=0.5)
plt.plot(counter.keys(),counter.values(),linewidth=2,c='r')
plt.xlabel('almost clique size',fontsize=10)
plt.ylabel('number of almost cliques',fontsize=10)
plt.figure(2)
fig, ax = plt.subplots(1, 1)
ax.plot(xk, custm.pmf(xk), 'ro', ms=12, mec='r')
ax.vlines(xk, 0, custm.pmf(xk), colors='r', lw=4)
plt.show()
'''
###########################################################
def l_num(size): # number of selected nodes given clique size
return 1
###########################################################
# almost cliques are generated
Gclique,l,l_cliqeuwise,clique_sizes,rep_numbers_cliquewise,clique_ordered_cliquewise, clique_start = almost_clique(clique_size,clique_num, l_num)
#print(len(rep_numbers_cliquewise)), 'cliques formed'
####### MST of Randomly Weighted Undirected Complete Graph on n nodes ########
GT = {}
for u in range(len(rep_numbers_cliquewise)):
GT[u] = {}
for u in range(len(rep_numbers_cliquewise)):
for v in range(u):
r = random()
GT[u][v] = r
GT[v][u] = r
T2 = mst(GT)
mst_weight = sum([GT[u][v] for u,v in T2])
T2G= nx.Graph()
for u in range(len(rep_numbers_cliquewise)):
for v in range(len(rep_numbers_cliquewise)):
if (u,v) in T2:
T2G.add_edge(u,v, weight=1)
#print T2G.edges()
plt.figure(1)
nx.draw(T2G, pos=nx.spring_layout(T2G,k=0.1,iterations=200),node_size=500,cmap=plt.cm.Reds)
#############################################################################
for u in range(len(l)):
for v in range(len(l)):
if u in T2G[v]:
Gclique.add_edge(l[u],l[v])
#print sorted(nx.degree(Gclique).values())
degreeList=sorted(nx.degree(Gclique).values())
counter=collections.Counter(degreeList)
plt.figure(2)
plt.scatter(counter.keys(),counter.values(),c='r',marker='o',s=100,alpha=0.5)
plt.plot(counter.keys(),counter.values(),linewidth=2,c='r')
plt.xlabel('node degree',fontsize=10)
plt.ylabel('number of nodes',fontsize=10)
plt.axis([0, 10, 0, 35])
clique_list = []
for i in range(len(clique_size)):
dum = np.linspace(clique_size[i],clique_size[i], clique_num[i])
clique_list = np.hstack((clique_list,dum ))
colors = []; c = 0
for i in range(len(clique_list)):
colors.extend(np.linspace(c,c,clique_list[i]))
c = c + 1
posx = []; posy = [];
for i in range(len(clique_list)):
centerx = np.cos(2*np.pi*i/len(clique_list))
centery = np.sin(2*np.pi*i/len(clique_list))
x1 = []; y1 = [];
for j in range(int(clique_list[i])):
x1.append(centerx + 0.2*np.cos(2*np.pi*j/clique_list[i]))
y1.append(centery + 0.2*np.sin(2*np.pi*j/clique_list[i]))
posx.extend(x1); posy.extend(y1);
pos = np.transpose(np.vstack((posx,posy)))
plt.figure(3)
nx.draw(Gclique, pos, node_color=colors,node_size=500,cmap=plt.cm.Reds)
plt.show()
A1= nx.to_numpy_matrix(Gclique)
A = np.array(A1)
A=np.trunc(A)
#print "number of nodes: ", math.sqrt(np.size(A))
np.savetxt('AdjMatrices/BT/BT'+str(N_init)+'_'+str(sampleN)+'.txt', A, fmt='%10.f', delimiter='\t')
'''
with open('StructuralProperties/ClusteringCoeff/BT/BT'+str(N_init)+'.txt', "a") as text_file:
text_file.write(str(nx.average_clustering(Gclique)) + "\n")
with open('StructuralProperties/AveShortestPath/BT/BT'+str(N_init)+'.txt', "a") as text_file:
text_file.write(str(nx.average_shortest_path_length(Gclique)) + "\n")
with open('StructuralProperties/Density/BT/BT'+str(N_init)+'.txt', "a") as text_file:
text_file.write(str(nx.density(Gclique)) + "\n")
xdata,ydata = np.log10(counter.keys()),np.log10(counter.values())
polycoef = np.polyfit(xdata, ydata, 1)
yfit = 10**( polycoef[0]*xdata+polycoef[1] )
with open('StructuralProperties/DegreeDist/BT/BT'+str(N_init)+'.txt', "a") as text_file:
text_file.write(str(polycoef[0]) + "\n")
#print polycoef[0]
plt.subplot(211)
plt.plot(xdata,ydata,'.k',xdata,yfit,'-r')
plt.subplot(212)
plt.loglog(xdata,ydata,'.k',xdata,yfit,'-r')
plt.show()
'''
return Gclique
def comembership_model2(N_init, sampleN):
clique_size = [3,4,5,6,7,8,9,10,11,12,13,14,15]; # clique sizes
total1=0.0
clique_num = np.zeros(len(clique_size)) # number of cliques of given size
########################## Algorithm 1 Final Final ######################
xk = np.arange(13)
pk = (1.0/27, 1.0/64, 1.0/125, 1.0/216, 1.0/343, 1.0/512, 1.0/729, 1.0/1000 , 1.0/1331, 1.0/1728, 1.0/2197, 1.0/2744, 1.0/3375)
#pk = (1.0/9, 1.0/16, 1.0/25, 1.0/36, 1.0/49, 1.0/64, 1.0/81, 1.0/100 , 1.0/121, 1.0/144, 1.0/169, 1.0/196, 1.0/225)
pk=np.multiply(13.3372634, pk)
#pk=np.multiply(3.02627, pk)
custm = st.rv_discrete(name='custm', values=(xk, pk))
R = custm.rvs(size=N_init)
degreeList=sorted(R)
counter=collections.Counter(degreeList)
keys=np.add(counter.keys(), 3)
AClist= np.divide(counter.values(), keys)
n_remaining= N_init-sum(np.multiply(AClist, keys))
(q,r)=divmod(n_remaining,3)
if n_remaining==5:
AClist[2]=AClist[2]+1
elif r==0:
AClist[0]=AClist[0]+n_remaining/3
else:
if len(AClist)==1:
AClist=np.append(AClist, 0)
if (n_remaining % 3 == 2):
AClist[0]=AClist[0]+n_remaining/3 - 2
AClist[1]=AClist[1]+2
if (n_remaining % 3 == 1):
AClist[0]=AClist[0]+n_remaining/3 - 1
AClist[1]=AClist[1]+1
#print "nodes", sum(np.multiply(pList,clique_size))
for i in range(len(AClist)):
clique_num[i] = int(AClist[i])
clique_num = map(int,clique_num)
print clique_num
'''
plt.figure(1)
plt.scatter(counter.keys(),counter.values(),c='r',marker='o',s=100,alpha=0.5)
plt.plot(counter.keys(),counter.values(),linewidth=2,c='r')
plt.xlabel('almost clique size',fontsize=10)
plt.ylabel('number of almost cliques',fontsize=10)
plt.figure(2)
fig, ax = plt.subplots(1, 1)
ax.plot(xk, custm.pmf(xk), 'ro', ms=12, mec='r')
ax.vlines(xk, 0, custm.pmf(xk), colors='r', lw=4)
plt.show()
'''
##########################################################
def r_num(size):
return 1
###########################################################
# almost cliques are generated
Gclique,r,r_cliquewise,clique_sizes,rep_numbers_cliquewise, reps_ordered_cliquewise, clique_start = almost_clique(clique_size,clique_num,r_num)
#print(len(rep_numbers_cliquewise)), 'cliques formed'
clique_list = []
for i in range(len(clique_size)):
dum = np.linspace(clique_size[i],clique_size[i], clique_num[i])
clique_list = np.hstack((clique_list,dum ))
cn = len(clique_list)
####### MST of Randomly Weighted Undirected Complete Graph on n nodes ########
GT = {}
for u in range(len(rep_numbers_cliquewise)):
GT[u] = {}
for u in range(len(rep_numbers_cliquewise)):
for v in range(u):
rand = random()
GT[u][v] = rand
GT[v][u] = rand
T2 = mst(GT)
#print "T=", T2
mst_weight = sum([GT[u][v] for u,v in T2])
T2G= nx.Graph()
for u in range(len(rep_numbers_cliquewise)):
for v in range(len(rep_numbers_cliquewise)):
if (u,v) in T2:
T2G.add_edge(u,v)
#############################################################################
CBnodes1=[]
CBnodes2=[]
updated_CB=[]
#print "r ", r
updated_CB_edges=[]
for u in range(0, cn):
for v in T2G[u]:
CBnodes1=[]
CBupdated1=[]
CBnodes2=[]
updated_CB_edges=[]
CB_u=[]
if v>=u:
n1=len(reps_ordered_cliquewise[u])
n2=len(reps_ordered_cliquewise[v])
density = int(np.ceil(0.05*n1*n2))
for i in range(min(density, n2-1, n1-1)):
n= reps_ordered_cliquewise[u][0:i]
for z in range(int(np.ceil(0.9*len(reps_ordered_cliquewise[u])))):
Gclique.add_edge(clique_start[u]+reps_ordered_cliquewise[u][z], clique_start[v]+reps_ordered_cliquewise[v][i+1])
r=np.append(r, clique_start[u]+reps_ordered_cliquewise[u][z])
r=np.append(r, clique_start[v]+reps_ordered_cliquewise[v][i+1])
r=sorted(set(r))
degreeList=sorted(nx.degree(Gclique).values())
counter=collections.Counter(degreeList)
plt.figure(1)
plt.scatter(counter.keys(),counter.values(),c='r',marker='o',s=100,alpha=0.5)
plt.plot(counter.keys(),counter.values(),linewidth=2,c='r')
plt.xlabel('node degree',fontsize=10)
plt.ylabel('number of nodes',fontsize=10)
plt.axis([0, 10, 0, 35])
colors = []; c = 0;
for i in range(len(clique_list)):
colors.extend(np.linspace(c,c,clique_list[i]))
c = c + 1
#pos=nx.spring_layout(Gclique,iterations=200)
posx = []; posy = [];
for i in range(len(clique_list)):
centerx = np.cos(2*np.pi*i/len(clique_list))
centery = np.sin(2*np.pi*i/len(clique_list))
x1 = []; y1 = [];
for j in range(int(clique_list[i])):
x1.append(centerx + 0.08*np.cos(2*np.pi*j/clique_list[i]))
y1.append(centery + 0.1*np.sin(2*np.pi*j/clique_list[i]))
posx.extend(x1); posy.extend(y1)
#posx.extend(centerx+np.random.rand(clique_list[i])*0.3)
#posy.extend(centery+np.random.rand(clique_list[i])*0.3)
pos = np.transpose(np.vstack((posx,posy)))
plt.figure(2)
nx.draw(Gclique,pos,node_color=colors,node_size=100,cmap=plt.cm.Greens)
plt.show()
'''
A1= nx.to_numpy_matrix(Gclique)
A = np.array(A1)
A=np.trunc(A)
np.savetxt('AdjMatrices/C/C'+str(N_init)+'_'+str(sampleN)+'.txt', A, fmt='%10.f', delimiter='\t')
with open('StructuralProperties/ClusteringCoeff/C/C'+str(N_init)+'.txt', "a") as text_file:
text_file.write(str(nx.average_clustering(Gclique)) + "\n")
with open('StructuralProperties/AveShortestPath/C/C'+str(N_init)+'.txt', "a") as text_file:
text_file.write(str(nx.average_shortest_path_length(Gclique)) + "\n")
with open('StructuralProperties/Density/C/C'+str(N_init)+'.txt', "a") as text_file:
text_file.write(str(nx.density(Gclique)) + "\n")
xdata,ydata = np.log10(counter.keys()),np.log10(counter.values())
polycoef = np.polyfit(xdata, ydata, 1)
yfit = 10**( polycoef[0]*xdata+polycoef[1] )
with open('StructuralProperties/DegreeDist/C/C'+str(N_init)+'.txt', "a") as text_file:
text_file.write(str(polycoef[0]) + "\n")
print polycoef[0]
plt.subplot(211)
plt.plot(xdata,ydata,'.k',xdata,yfit,'-r')
plt.subplot(212)
plt.loglog(xdata,ydata,'.k',xdata,yfit,'-r')
plt.show()
'''
#print "number of nodes: ", math.sqrt(np.size(A))
return Gclique
def Liaison_model2(N_init, sampleN):
clique_size = [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
# clique sizes
clique_edges = np.asarray(clique_size)
clique_edges = np.divide(np.multiply(clique_edges, clique_edges + 1), 2)
ep = 0.1
total1 = 0
clique_num = np.zeros(len(clique_size)) # number of cliques of given size
for w in range(100):
for i in range(len(clique_size)):
clique_num[i] = clique_num[i] + (2.5321 * (float(N_init - total1) /
(clique_size[i])**3))
clique_num = map(int, clique_num)
total1 = sum(np.multiply(clique_size, clique_num))
print total1
# comment this next line to generate a small sample graph easy to visualize
#clique_num = [0,7,3,1,0,0,0,0]
#6/(np.pi)^2
###########################################################
def l_num(size): # number of leaders given clique size
return 1
###########################################################
# almost cliques are generated
Gclique, l, l_cliqeuwise, clique_sizes, rep_numbers_cliquewise, clique_ordered_cliquewise, clique_start = almost_clique(
clique_size, clique_num, l_num)
print(len(rep_numbers_cliquewise)), 'cliques formed'
degdist(Gclique)
################### Spanning Tree with Power Law #####################
'''
global T
T=nx.random_powerlaw_tree(len(rep_numbers_cliquewise), tries=1000000)
plt.figure(2)
nx.draw(T, pos=nx.circular_layout(T))
'''
####### MST of Randomly Weighted Undirected Complete Graph on n nodes ########
GT = {}
for u in range(len(rep_numbers_cliquewise)):
GT[u] = {}
for u in range(len(rep_numbers_cliquewise)):
for v in range(u):
r = random()
GT[u][v] = r
GT[v][u] = r
T2 = mst(GT)
#print "T=", T2
mst_weight = sum([GT[u][v] for u, v in T2])
T2G = nx.Graph()
for u in range(len(rep_numbers_cliquewise)):
for v in range(len(rep_numbers_cliquewise)):
if (u, v) in T2:
print "(u,v)=", u, v
T2G.add_edge(u, v, weight=1)
plt.figure(3)
nx.draw(T2G, pos=nx.circular_layout(T2G))
#############################################################################
L = nx.empty_graph(len(rep_numbers_cliquewise) - 1)
n1 = len(Gclique.nodes())
def mapping(x):
return x + len(Gclique.nodes())
L = nx.relabel_nodes(L, mapping)
for u in range(len(l)):
for v in range(len(l)):
if u in T2G[v]:
#Gclique.add_edge(l[u],l[v])
Gclique.add_nodes_from(L.nodes())
#print "Gclique.nodes()",Gclique.nodes()
########################### Creating Liaison Graph ##########################
print l
l = np.array(l).tolist()
print "l = ", l
for u in range(len(T2G.edges())):
Gclique.add_edge(l[T2G.edges()[u][0]], n1 + u)
Gclique.add_edge(l[T2G.edges()[u][1]], n1 + u)
Liaisons_num = np.random.randint(1, len(T2G.edges()))
print "Liaisons_num =", Liaisons_num
iterate = len(L.nodes()) - Liaisons_num
for i in range(iterate):
j = np.random.choice(L.nodes(), 2, replace=False)
print j
print "j[0] = ", j[0], "j[1] = ", j[1]
print Gclique.neighbors(j[0]), Gclique.neighbors(j[1])
#print "Gclique.degree(j[0])", Gclique.degree(j[0]), "Gclique.degree(j[1])", Gclique.degree(j[1])
for n in Gclique.neighbors(j[1]):
Gclique.add_edge(j[0], n)
Gclique.add_edge(j[0], n)
L.remove_node(j[1])
Gclique.remove_node(j[1])
print "L.nodes() = ", L.nodes()
print "Gclique.degree(L.nodes())", Gclique.degree(L.nodes())
print "Gclique.degree(L.nodes())", sorted(Gclique.degree(L.nodes()))
L = nx.convert_node_labels_to_integers(L, first_label=n1)
Gclique = nx.convert_node_labels_to_integers(Gclique, first_label=0)
#print L.nodes()
#print Gclique.nodes()
#############################################################################
degthis, a1, a2 = draw_degdist(Gclique, 1, 'b', 0)
figcolor = 'r'
plt.figure(2)
plt.scatter((a1), (a2), c=figcolor, marker='o', s=400, alpha=0.5)
plt.plot((a1), (a2), linewidth=2, c=figcolor)
plt.xlabel('node degree', fontsize=30)
plt.ylabel('number of nodes', fontsize=30)
plt.axis([0, 20, -11, 350])
clique_list = []
for i in range(len(clique_size)):
dum = np.linspace(clique_size[i], clique_size[i], clique_num[i])
clique_list = np.hstack((clique_list, dum))
colors = []
c = 0
for i in range(len(clique_list)):
colors.extend(np.linspace(c, c, clique_list[i]))
c = c + 1
#pos=nx.spring_layout(Gclique,iterations=200)
print "clique_list= ", clique_list
posx = []
posy = []
for i in range(len(clique_list)):
centerx = np.cos(2 * np.pi * i / len(clique_list))
centery = np.sin(2 * np.pi * i / len(clique_list))
x1 = []
y1 = []
for j in range(int(clique_list[i])):
x1.append(centerx + 0.2 * np.cos(2 * np.pi * j / clique_list[i]))
y1.append(centery + 0.2 * np.sin(2 * np.pi * j / clique_list[i]))
posx.extend(x1)
posy.extend(y1)
x1 = []
y1 = []
print "len(L.nodes())=", len(L.nodes())
for j in range(len(L.nodes())):
x1.append(0.5 * np.cos(2 * np.pi * j / len(L.nodes())))
y1.append(0.5 * np.sin(2 * np.pi * j / len(L.nodes())))
posx.extend(x1)
posy.extend(y1)
pos = np.transpose(np.vstack((posx, posy)))
plt.figure(4)
#nx.draw(Gclique,pos,node_color=colors,node_size=800,cmap=plt.cm.Reds)
nx.draw(Gclique, pos, node_size=800, cmap=plt.cm.Reds)
#nx.draw(Gclique,pos=nx.spring_layout(Gclique), node_size=800,cmap=plt.cm.Reds)
plt.show()
#print 'diameter of Bridging Ties network is', nx.diameter(Gclique)
print 'avg clustering coeff is', nx.average_clustering(Gclique)
print 'avg shortest path length', nx.average_shortest_path_length(Gclique)
A1 = nx.to_numpy_matrix(Gclique)
A = np.array(A1)
A = np.trunc(A)
#print A
'''
np.savetxt('AdjMatrices/L/L'+str(N_init)+'_'+str(sampleN)+'.txt', A, fmt='%10.f', delimiter='\t')
with open('StructuralProperties/ClusteringCoeff/L/L'+str(N_init)+'.txt', "a") as text_file:
text_file.write(str(nx.average_clustering(Gclique)) + "\n")
with open('StructuralProperties/AveShortestPath/L/L'+str(N_init)+'.txt', "a") as text_file:
text_file.write(str(nx.average_shortest_path_length(Gclique)) + "\n")
#data = np.loadtxt("ComparativeAnalysis/new/SpectralGap/sg_l_ave.txt")
#xdata,ydata = data[:,0],data[:,1]
#xdata,ydata = zip(*sorted(zip(xdata,ydata))) # sorts the two lists after the xdata
#xd,yd = np.log10(xdata),np.log10(ydata)
#polycoef = polyfit(xd, yd, 1)
#print polycoef
#yfit = 10**( polycoef[0]*xd+polycoef[1] )
xdata,ydata = np.log10(a1),np.log10(a2)
polycoef = polyfit(xdata, ydata, 1)
yfit = 10**( polycoef[0]*xdata+polycoef[1] )
with open('StructuralProperties/DegreeDist/L/L'+str(n)+'.txt', "a") as text_file:
text_file.write(str(polycoef[0]) + "\n")
#plt.subplot(211)
#plt.plot(xdata,ydata,'.k',xdata,yfit,'-r')
#plt.subplot(212)
#plt.loglog(xdata,ydata,'.k',xdata,yfit,'-r')
#plt.show()
'''
print math.sqrt(np.size(A))
return Gclique
def comembership_model():
clique_size = [3,4,5,6,7,8,9,10] # clique sizes
clique_edges=np.asarray(clique_size)
clique_edges = np.divide(np.multiply(clique_edges,clique_edges+1),2)
ep = 0.1
clique_num = np.zeros(len(clique_size)) # number of cliques of given size
for i in range(len(clique_size)):
clique_num[i] = int(2.5321*(70.0/(clique_size[i])**3))
clique_num = map(int,clique_num)
# comment this next line to generate a small sample graph easy to visualize
#clique_num = [0,7,3,1,0,0,0,0]
##########################################################
def c_num(size): # number of comembers given clique size
if size == 3:
a =1
elif size >3 and size <6:
a = np.random.randint(2, 3)
elif size >5 and size <11:
a = np.random.randint(3, 4)
else:
a = 4
return a
###########################################################
# almost cliques are generated
Gclique,r,r_cliquewise,clique_sizes,rep_numbers_cliquewise, reps_ordered_cliquewise, clique_start = almost_clique(clique_size,clique_num,c_num)
print(len(rep_numbers_cliquewise)), 'cliques formed'
####### MST of Randomly Weighted Undirected Complete Graph on n nodes ########
GT = {}
for u in range(len(rep_numbers_cliquewise)):
GT[u] = {}
for u in range(len(rep_numbers_cliquewise)):
for v in range(u):
rand = random()
GT[u][v] = rand
GT[v][u] = rand
T2 = mst(GT)
mst_weight = sum([GT[u][v] for u,v in T2])
T2G= nx.Graph()
for u in range(len(rep_numbers_cliquewise)):
for v in range(len(rep_numbers_cliquewise)):
if (u,v) in T2:
print "(u,v)=", u, v
T2G.add_edge(u,v)
plt.figure(2)
nx.draw(T2G, pos=nx.circular_layout(T2G))
#############################################################################
cn=len(rep_numbers_cliquewise)
owner = np.linspace(len(Gclique)+1,len(Gclique)+1,len(Gclique))
done = np.zeros((cn,cn))
roots=[]
print "r",r
print "len(r)", len(r)
#roots_no=randint(1,len(CB.edges()))
roots=np.random.choice(5, 3, replace=False)
print "roots", roots
for i in range(cn):
neb = T2G.neighbors(i)
print 'Neighbors of ', i, '=', neb
for j in range(len(neb)):
if done[i,neb[j]] == 0 and done[neb[j],i] == 0:
done[i,neb[j]] = 1; done[neb[j],i] = 0
a1= rep_numbers_cliquewise[i]
a2= rep_numbers_cliquewise[T2G.neighbors(i)[j]]
#print 'a1= ', a1
#print 'a2= ', a2
a = min(a1,a2)
print 'a= ', a
nl1 = reps_ordered_cliquewise[i][0:a]; nl2 = reps_ordered_cliquewise[neb[j]][0:a]
print 'nl1 = ', nl1
print 'nl2 = ', nl2
for k in range(len(nl1)):
Gclique.add_edge(clique_start[i]+nl1[k],clique_start[neb[j]]+nl2[k])
owner[clique_start[i]+nl1[k]] = clique_start[neb[j]]+nl2[k]
print "clique_start[i]+nl1[k]", clique_start[i]+nl1[k]
print "clique_start[neb[j]]+nl2[k]", clique_start[neb[j]]+nl2[k]
print "owner = ", owner
c = 0
clique_mem = np.zeros(len(clique_sizes))
for i in range(len(clique_sizes)):
for k in range(int(clique_sizes[i])):
if owner[c] == len(Gclique)+1:
print "c", c
clique_mem[i] = clique_mem[i] + 1
c=c+1
print "clique_mem = ", clique_mem
print "n = ", sum(clique_mem)
for j in range(len(Gclique)):
if owner[j] != len(Gclique)+1:
for k in range(len(Gclique.neighbors(j))):
Gclique.add_edge(Gclique.neighbors(j)[k],owner[j])
keep = np.where(owner==len(Gclique)+1); keep = list(keep);
print "keep", keep
Gclique = Gclique.subgraph(keep[0])
print "owner = ", owner
degthis,a1,a2 = draw_degdist(Gclique,1,'b',0)
figcolor = 'g'
plt.figure(3)
plt.scatter((a1),(a2),c=figcolor,marker='o',s=400,alpha=0.5)
plt.plot((a1),(a2),linewidth=2,c=figcolor)
plt.xlabel('node degree',fontsize=30)
plt.ylabel('number of nodes',fontsize=30)
plt.axis([-19, 200, -19, 350])
colors = []; c = 0;
for i in range(len(clique_mem)):
colors.extend(np.linspace(c,c,clique_mem[i]))
c = c + 1
clique_list1 = [];
for i in range(len(clique_size)):
dum = np.linspace(clique_size[i],clique_size[i], clique_num[i])
clique_list1 = np.hstack((clique_list1,dum ))
#pos=nx.spring_layout(Gclique,iterations=200)
posx = []; posy = [];
for i in range(len(clique_list1)):
centerx = np.cos(2*np.pi*i/len(clique_list1))
centery = np.sin(2*np.pi*i/len(clique_list1))
x1 = []; y1 = [];
for j in range(int(clique_list1[i])):
x1.append(centerx + 0.2*np.cos(2*np.pi*j/clique_list1[i]))
y1.append(centery + 0.2*np.sin(2*np.pi*j/clique_list1[i]))
posx.extend(x1); posy.extend(y1);
pos = np.transpose(np.vstack((posx,posy)))
plt.figure(4)
nx.draw(Gclique,pos,node_color = colors,node_size=800,cmap=plt.cm.Greens)
plt.show()
print 'diameter of comembership network is', nx.diameter(Gclique)
print 'avg clustering coeff is', nx.average_clustering(Gclique)
print 'avg shortest path length', nx.average_shortest_path_length(Gclique)
return Gclique