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 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
