def creaRandom():
# CREAZIONE RANDOM DEL GRAFO
g = Graph()
for i in range(100):
g.insert_vertex(i)
nodi = g.vertices()
for i in range(0, len(nodi)):
while True:
peso = randint(1, 1000000000)
if g.peso_unico(peso):
if i + 1 == len(nodi):
g.insert_edge(nodi[i], nodi[0], peso)
break
else:
g.insert_edge(nodi[i], nodi[i + 1], peso)
break
for node in nodi:
i = 0
while i < 3:
peso = randint(1, 1000000000)
# NUMERO MOLTO GRANDE PER AVERE QUASI LA CERTEZZA DI NON AVERE ARCHI CON LO STESSO PESO
# LA FUNZIONE PER IL CONTROLLO è PRESENTE NELA CLASSE DEL GRAFO MA IMPIEGA MOLTO TEMPO
nodo2 = randint(0, 9999)
if nodo2 != node.element() and g.get_edge(
node, nodi[nodo2]) is None and g.peso_unico(peso):
i = i + 1
g.insert_edge(node, nodi[nodo2], peso)
return g
def grafi_connessi():
g = Graph()
g2=Graph()
dict_edge={}
n=100
g_seq=Graph_seq(n)
for i in range(n):
v0=g.insert_vertex(i)
g2.insert_vertex(i)
v0.connessioni=Array("i",n,lock=False)
v0.pesi_condivisi=Array("i",n,lock=False)
nodi=g.vertices()
for i in range(len(nodi)):
print(i)
j=i+1
for x in range(j,len(nodi)):
while True:
peso = randint( 1, 100000000 )
if g.peso_unico(peso):
e=g.insert_edge( nodi[i], nodi[x], peso )
g_seq.addEdge(i,x,peso)
dict_edge[e.element()]=e
nodi[i].pesi_condivisi[nodi[x].element()]=peso
nodi[x].pesi_condivisi[nodi[i].element()]=peso
nodi[i].connessioni[len(nodi[i].listaArchi)-1]=nodi[x].element()
nodi[x].connessioni[len(nodi[x].listaArchi)-1]=nodi[i].element()
break
lista_pesi_condivisi=[]
lista_connessioni_condivise=[]
for node in nodi:
if len(node.listaArchi)<n:
node.connessioni[len(node.listaArchi)]=-1
lista_pesi_condivisi.append(node.pesi_condivisi)
lista_connessioni_condivise.append(node.connessioni)
return g,g_seq,lista_pesi_condivisi,lista_connessioni_condivise,dict_edge
def creaRandom():
# CREAZIONE RANDOM DEL GRAFO
g = Graph()
g2=Graph()
dict_edge={}
n=100
g_seq=Graph_seq(n)
for i in range(n):
v0=g.insert_vertex(i)
g2.insert_vertex(i)
v0.connessioni=Array("i",n,lock=False)
v0.pesi_condivisi=Array("i",n,lock=False)
#print(i)
#v0.archi_condivisi=m.list([0 for x in range(n-1)])
nodi=g.vertices()
nodi2=g2.vertices()
for i in range(0,len(nodi)):
while True:
peso = randint( 1, 100000000 )
if g.peso_unico(peso):
if i+1==len(nodi):
e=g.insert_edge( nodi[i], nodi[0], peso )
g_seq.addEdge(i,0,peso)
dict_edge[e.element()]=e
nodi[i].pesi_condivisi[nodi[0].element()]=peso
nodi[0].pesi_condivisi[nodi[i].element()]=peso
nodi[i].connessioni[len(nodi[i].listaArchi)-1]=nodi[0].element()
nodi[0].connessioni[len(nodi[0].listaArchi)-1]=nodi[i].element()
g2.insert_edge( nodi2[i], nodi2[0], peso )
break
else:
e=g.insert_edge( nodi[i], nodi[i+1], peso )
dict_edge[e.element()]=e
g_seq.addEdge(i,i+1,peso)
nodi[i].pesi_condivisi[nodi[i+1].element()]=peso
nodi[i+1].pesi_condivisi[nodi[i].element()]=peso
nodi[i].connessioni[len(nodi[i].listaArchi)-1]=nodi[i+1].element()
nodi[i+1].connessioni[len(nodi[i+1].listaArchi)-1]=nodi[i].element()
g2.insert_edge( nodi2[i], nodi2[i+1], peso )
break
lista_archi_condivisi=[]
for node in nodi:
i=0
#print(node,flush=True)
print("node",node,flush=True)
while i<1:
peso = randint( 1, 100000000 )
# NUMERO MOLTO GRANDE PER AVERE QUASI LA CERTEZZA DI NON AVERE ARCHI CON LO STESSO PESO
# LA FUNZIONE PER IL CONTROLLO è PRESENTE NELA CLASSE DEL GRAFO MA IMPIEGA MOLTO TEMPO
nodo2 = randint(0, n-1)
if nodo2 != node.element() and g.get_edge(node,nodi[nodo2]) is None and g.peso_unico(peso):
e=g.insert_edge( node, nodi[nodo2], peso )
g_seq.addEdge(node.element(),nodo2,peso)
dict_edge[e.element()]=e
g2.insert_edge( nodi2[node.element()], nodi2[nodo2], peso )
node.pesi_condivisi[nodi[nodo2].element()]=peso
nodi[nodo2].pesi_condivisi[node.element()]=peso
node.connessioni[len(node.listaArchi)-1]=nodi[nodo2].element()
nodi[nodo2].connessioni[len( nodi[nodo2].listaArchi)-1]=node.element()
i=i+1
lista_pesi_condivisi=[]
lista_connessioni_condivise=[]
for node in nodi:
if len(node.listaArchi)<n:
node.connessioni[len(node.listaArchi)]=-1
lista_pesi_condivisi.append(node.pesi_condivisi)
lista_connessioni_condivise.append(node.connessioni)
return g,g_seq,lista_pesi_condivisi,lista_connessioni_condivise,dict_edge
def Boruvka_parallel_array(g,lista_pesi_condivisi,lista_connessioni,dict_edge):
grafoB = Graph()
lista_nodi = g.vertices()
for node in lista_nodi:
grafoB.insert_vertex( node.element() )
peso_albero=0
parent = Array( "i", g.vertex_count(), lock=False )
successor_next =Array( "i",g.vertex_count(), lock=False )
result=Array("i",g.vertex_count(),lock=False)
jobs_min=JoinableQueue()
processes_minimo=minimo_paralelo(parent,successor_next,lista_pesi_condivisi,lista_connessioni,jobs_min,result)
lista_nodi_boruvka=grafoB.vertices()
t66=time()
while len( lista_nodi ) > 1:
lista_divisa_interi=dividi_gruppi(lista_nodi,8)
t2=time()
add_jobs(jobs_min,lista_divisa_interi,0)
jobs_min.join()
for node in lista_nodi:
edge=dict_edge[result[node.element()]]
n1,n2=edge.endpoints_posizione()
e=grafoB.insert_edge(lista_nodi_boruvka[n1],lista_nodi_boruvka[n2]
,edge.element())
if e is not None:
peso_albero+=edge.element()
for node in lista_nodi:
i=node.element()
parent_opposto = parent[parent[i]]
if i == parent_opposto:
if i < parent[i]:
parent[i] = i
else:
parent[parent[i]] = parent[i]
while True:
bool = True
add_jobs(jobs_min,lista_divisa_interi,1)
jobs_min.join()
for x, y in zip( parent, successor_next ):
if x != y:
bool = False
break
if bool:
break
add_jobs(jobs_min,lista_divisa_interi,2)
jobs_min.join()
for node in lista_nodi:
node.root =parent[node.element()]
node.setElement( node.root )
dict_merge={}
for node in lista_nodi:
if node.root==node.posizione:
dict_merge[node.root]=[]
add_jobs(jobs_min,lista_divisa_interi,3)
jobs_min.join()
lista=[x for x in lista_nodi]
lista_nodi=[]
for node in lista:
if node.posizione!=node.root:
dict_merge[node.root].append(node.posizione)
else:
lista_nodi.append(node)
if len(lista_nodi)<=1:
break
add_jobs(jobs_min,dict_merge,4)
jobs_min.join()
for pr in processes_minimo:
pr.terminate()
return (grafoB,peso_albero)
def creaRandom():
# CREAZIONE RANDOM DEL GRAFO
g = Graph()
g_sequenziale = Graph()
g_parallel_array = Graph()
g_parallel_queue = Graph()
g_prim = Graph2()
dict_edge = {}
n = 10000
for i in range(n):
g_sequenziale.insert_vertex(i)
v1 = g_parallel_queue.insert_vertex(i)
v2 = g_parallel_array.insert_vertex(i)
v1.connessioni = Array("i", n, lock=False)
v1.pesi_condivisi = Array("i", n, lock=False)
v2.connessioni = Array("i", n, lock=False)
v2.pesi_condivisi = Array("i", n, lock=False)
g_prim.insert_vertex(i)
g.insert_vertex(i)
nodi = g.vertices()
nodi_sequenziale = g_sequenziale.vertices()
nodi_array = g_parallel_array.vertices()
nodi_queue = g_parallel_queue.vertices()
nodi_prim = g_prim.vertices()
for i in range(0, len(nodi)):
while True:
peso = randint(1, 100000000)
if g.peso_unico(peso):
if i + 1 == len(nodi):
e = g.insert_edge(nodi[i], nodi[0], peso)
dict_edge[e.element()] = e
g_prim.insert_edge(nodi_prim[i], nodi_prim[0], peso)
g_sequenziale.insert_edge(nodi_sequenziale[i],
nodi_sequenziale[0], peso)
g_parallel_array.insert_edge(nodi_array[i], nodi_array[0],
peso)
g_parallel_queue.insert_edge(nodi_queue[i], nodi_queue[0],
peso)
nodi_queue[i].pesi_condivisi[
nodi_queue[0].element()] = peso
nodi_queue[0].pesi_condivisi[
nodi_queue[i].element()] = peso
nodi_queue[i].connessioni[len(nodi_queue[i].listaArchi) -
1] = nodi_queue[0].element()
nodi_queue[0].connessioni[len(nodi_queue[0].listaArchi) -
1] = nodi_queue[i].element()
nodi_array[i].pesi_condivisi[
nodi_array[0].element()] = peso
nodi_array[0].pesi_condivisi[
nodi_array[i].element()] = peso
nodi_array[i].connessioni[len(nodi_array[i].listaArchi) -
1] = nodi_array[0].element()
nodi_array[0].connessioni[len(nodi_array[0].listaArchi) -
1] = nodi_array[i].element()
break
else:
e = g.insert_edge(nodi[i], nodi[i + 1], peso)
dict_edge[e.element()] = e
g_prim.insert_edge(nodi_prim[i], nodi_prim[i + 1], peso)
g_sequenziale.insert_edge(nodi_sequenziale[i],
nodi_sequenziale[i + 1], peso)
g_parallel_array.insert_edge(nodi_array[i],
nodi_array[i + 1], peso)
g_parallel_queue.insert_edge(nodi_queue[i],
nodi_queue[i + 1], peso)
nodi_queue[i].pesi_condivisi[nodi_queue[
i + 1].element()] = peso
nodi_queue[i + 1].pesi_condivisi[
nodi_queue[i].element()] = peso
nodi_queue[i].connessioni[len(nodi_queue[i].listaArchi) -
1] = nodi_queue[i + 1].element()
nodi_queue[i +
1].connessioni[len(nodi_queue[i + 1].listaArchi)
- 1] = nodi_queue[i].element()
nodi_array[i].pesi_condivisi[nodi_array[
i + 1].element()] = peso
nodi_array[i + 1].pesi_condivisi[
nodi_array[i].element()] = peso
nodi_array[i].connessioni[len(nodi_array[i].listaArchi) -
1] = nodi_array[i + 1].element()
nodi_array[i +
1].connessioni[len(nodi_array[i + 1].listaArchi)
- 1] = nodi_array[i].element()
break
for node in nodi:
i = 0
while i < 99:
peso = randint(1, 100000000)
# NUMERO MOLTO GRANDE PER AVERE QUASI LA CERTEZZA DI NON AVERE ARCHI CON LO STESSO PESO
# LA FUNZIONE PER IL CONTROLLO è PRESENTE NELA CLASSE DEL GRAFO MA IMPIEGA MOLTO TEMPO
nodo2 = randint(0, n - 1)
if nodo2 != node.element() and g.get_edge(
node, nodi[nodo2]) is None and g.peso_unico(peso):
e = g.insert_edge(node, nodi[nodo2], peso)
dict_edge[e.element()] = e
g_sequenziale.insert_edge(nodi_sequenziale[node.element()],
nodi_sequenziale[nodo2], peso)
g_parallel_array.insert_edge(nodi_array[node.element()],
nodi_array[nodo2], peso)
g_parallel_queue.insert_edge(nodi_queue[node.element()],
nodi_queue[nodo2], peso)
g_prim.insert_edge(nodi_prim[node.element()], nodi_prim[nodo2],
peso)
nodi_queue[node.element()].pesi_condivisi[
nodi_queue[nodo2].element()] = peso
nodi_queue[nodo2].pesi_condivisi[nodi_queue[
node.element()].element()] = peso
nodi_queue[node.element()].connessioni[
len(nodi_queue[node.element()].listaArchi) -
1] = nodi_queue[nodo2].element()
nodi_queue[nodo2].connessioni[
len(nodi_queue[nodo2].listaArchi) -
1] = nodi_queue[node.element()].element()
nodi_array[node.element()].pesi_condivisi[
nodi_array[nodo2].element()] = peso
nodi_array[nodo2].pesi_condivisi[nodi_array[
node.element()].element()] = peso
nodi_array[node.element()].connessioni[
len(nodi_array[node.element()].listaArchi) -
1] = nodi_array[nodo2].element()
nodi_array[nodo2].connessioni[
len(nodi_array[nodo2].listaArchi) -
1] = nodi_array[node.element()].element()
i = i + 1
lista_pesi_condivisi_queue = []
lista_connessioni_condivise_queue = []
lista_connessioni_condivise_array = []
lista_pesi_condivisi_array = []
for node in nodi_array:
if len(node.listaArchi) < n:
node.connessioni[len(node.listaArchi)] = -1
lista_pesi_condivisi_array.append(node.pesi_condivisi)
lista_connessioni_condivise_array.append(node.connessioni)
for node in nodi_queue:
if len(node.listaArchi) < n:
node.connessioni[len(node.listaArchi)] = -1
lista_pesi_condivisi_queue.append(node.pesi_condivisi)
lista_connessioni_condivise_queue.append(node.connessioni)
return g,g_sequenziale,g_parallel_array,g_parallel_queue,\
g_prim,lista_pesi_condivisi_array,\
lista_connessioni_condivise_array,lista_pesi_condivisi_queue,lista_connessioni_condivise_queue,dict_edge
def Boruvka_seq(g):
lista_nodi = g.vertices()
peso_albero = 0
mst = Graph()
for node in g.vertices():
mst.insert_vertex(node.element())
parent = [-1] * g.vertex_count()
tempo_ricerca = 0
tempo_pointer = 0
tempo_merge = 0
while len(lista_nodi) > 1:
tempo_ricerca_parziale = time()
for node in lista_nodi:
minedge = None
for edge in node.incident_edges():
if minedge == None or minedge.element() > edge.element():
minedge = edge
n1, n2 = edge.endpoints()
if n1 == node.element():
parent[node.element()] = n2
else:
parent[node.element()] = n1
if minedge is not None:
n1, n2 = minedge.endpoints_posizione()
e = mst.insert_edge(mst.vertices()[n1],
mst.vertices()[n2], minedge.element())
if e is not None:
peso_albero += minedge.element()
#print(e,flush=True)
tempo_ricerca += (time() - tempo_ricerca_parziale)
for node in lista_nodi:
node_parent = parent[node.element()]
parent_parent = parent[parent[node.element()]]
if node.element() == parent_parent:
if node.element() < node_parent:
parent[node.element()] = node.element()
else:
parent[node_parent] = node_parent
tempo_pointer_parziale = time()
findRoot(parent)
tempo_pointer += (time() - tempo_pointer_parziale)
for nodo in lista_nodi:
nodo.root = g.vertices()[parent[nodo.element()]]
nodo.setElement(nodo.root.element())
for edge in nodo.incident_edges():
n1, n2 = edge.endpoints()
edge.setElement(parent[n1], parent[n2])
i = 0
tempo_merge_parziale = time()
while i < len(lista_nodi):
node = lista_nodi[i]
if node.root != node:
merge(node, node.root)
lista_nodi.pop(i)
else:
i = i + 1
delete_multi_edges(lista_nodi)
tempo_merge += (time() - tempo_merge_parziale)
print(
"TEMPO RICERCA ARCHI MINIMI :{}, TEMPO POINTER JUMPING:{}, TEMPO MERGE:{}"
.format(tempo_ricerca, tempo_pointer, tempo_merge))
return (mst, peso_albero)