def generateAddNoneMeasure(Sample, Node):
"""
:param Sample: il numero di campioni o di ripetizioni per la creazione del grafo
:param Node: il numero massimo di nodi per creare lo span del grafo per l'asse X
:return: plot tra valore misurato e calcolato
"""
# creazione dei campioni
dictTime = {}
for j in range(1, Sample):
Graph = GraphAdjacencyList()
for N in range(0, Node):
inizio = time.clock()
Graph.addNode(N)
fine = time.clock() - inizio
if N not in dictTime.keys():
dictTime[N] = []
dictTime[N].append(fine)
X = []
Y = []
for key in sorted(dictTime.keys()):
X.append(key)
M = np.mean(np.array(dictTime[key]))
Y.append(M)
X = np.array(X)
Y = np.array(Y)
Yt = np.ones(len(Y))
Yt = Yt * np.mean(Y)
plt.figure('Tempo aggiungi vertice')
plt.grid(True)
plt.title('Tempo aggiungi vertice')
plt.ylabel('tempo in s')
plt.xlabel('numero di vertici')
plt.xlim([np.min(X), np.max(X)])
plt.ylim([0, np.max(Y) * 1.2])
plt.plot(X, Y, 'r-', label='Tempo misurato con {0} campioni'.format(Sample))
plt.plot(X, Yt, 'b-', label='Tempo medio')
plt.legend(loc='upper left')
plot = plt
return plot
def generateGraph():
"""
:return: un oggetto di tipo GraphAdjacencyList con le seguenti caratteristiche:
Il numero di nodi è scelto casualmente da un range di 5-50, le conessioni tra i vertici
sono scelti casualmente.
"""
# instanziamo oGraph come oggetto di tipo GraphAdjacencyList
oGraph = GraphAdjacencyList()
# si stabilisce il numero dei vertici
Ntot = random.randrange(5, 51)
# aggiungiamo i vertici al grafo tempo stimato O(Ntot)
nodes = []
for i in range(0, Ntot):
node = oGraph.addNode(i)
nodes.append(node)
# creiamo una lista A di ID casuali dei nodi del grafo
Sample = random.randrange(1, len(nodes))
IdNodesA = random.sample(range(0, Ntot), Sample)
# creiamo una lista B di ID casuali dei nodi del grafo
Sample = random.randrange(1, len(nodes))
IdNodesB = random.sample(range(0, Ntot), Sample)
# creazione degli archi
for IdA in IdNodesA:
node_src = oGraph.getNode(IdA)
for IdB in IdNodesB:
node_dst = oGraph.getNode(IdB)
if random.randrange(
0, 2) == 1 and node_src != node_dst and oGraph.isAdj(
node_src.id,
node_dst.id) == False and oGraph.isAdj(
node_dst.id, node_src.id) == False:
oGraph.insertEdge(node_src.id, node_dst.id, 1)
oGraph.insertEdge(node_dst.id, node_src.id, 1)
return oGraph
def generateNodesMean(Sample,Node):
# calcolo dei campioni
dictTime = {}
for j in range(1, Sample):
Graph = GraphAdjacencyList()
nodes = []
for i in range(Node):
node = Graph.addNode(i)
nodes.append(node)
for node_src in nodes:
for node_dst in nodes:
if node_src != node_dst:
N = Graph.numNodes()
if N not in dictTime.keys():
dictTime[N] = []
Graph.insertEdge(node_src.id, node_dst.id, 1)
Graph.insertEdge(node_dst.id, node_src.id, 1)
inizio = time.clock()
Nodes_Mean(Graph)
fine = time.clock() - inizio
dictTime[N].append(fine)
X = []
Y = []
for key in sorted(dictTime.keys()):
X.append(key)
M = np.mean(np.array(dictTime[key]))
Y.append(M)
X = np.array(X)
Y = np.array(Y)
Yt = np.power(X, 4)
R = Yt / Y
C = np.mean(R)
plt.figure('Tempo calcolo dei nodi medi dei percorsi')
plt.grid(True)
plt.title('Tempo calcolo dei nodi medi dei percorsi')
plt.ylabel('andamento temporale')
plt.xlabel('numero di vertici')
plt.xlim([np.min(X), np.max(X)])
plt.ylim([0, np.max(Yt) * 1.2])
plt.plot(X, C*Y, 'r-', label='T(n) misurato con {0} campioni'.format(Sample))
plt.plot(X, Yt, 'b-', label='T(n)=N^3')
plt.legend(loc='upper left')
plot = plt
return plot
def generateDegMeasure(Sample, Node):
# creazione dei campioni
dictTime = {}
for j in range(1, Sample):
graph = GraphAdjacencyList()
nodes = []
for i in range(Node):
node = graph.addNode(i)
nodes.append(node)
for node_src in nodes:
for node_dst in nodes:
if node_src != node_dst:
graph.insertEdge(node_src.id, node_dst.id, 1)
inizio = time.clock()
D = graph.deg(node_src.id)
fine = time.clock() - inizio
if D > 0:
if D not in dictTime.keys():
dictTime[D] = []
dictTime[D].append(fine)
X = []
Y = []
for key in sorted(dictTime.keys()):
X.append(key)
M = np.mean(np.array(dictTime[key]))
Y.append(M)
X = np.array(X)
Y = np.array(Y)
Yt = X
R = Yt / Y
C = np.max(R)
plt.figure('Tempo calcolo del grado')
plt.grid(True)
plt.title('Tempo calcolo del grado')
plt.ylabel('andamento temporale')
plt.xlabel('numero di grado del nodo X')
plt.xlim([np.min(X), np.max(X)])
plt.ylim([0, np.max(Yt) * 1.2])
plt.plot(X, C*Y, 'r-', label='T(n) misurato con {0} campioni'.format(Sample))
plt.plot(X, Yt, 'b-', label='T(n)=sigma(X)')
plt.legend(loc='upper left')
plot = plt
return plot
def generateInsertEdgeMeasure(Sample, Node):
# creazione dei campioni
dictTime = {}
for j in range(1, Sample):
Graph = GraphAdjacencyList()
nodes = []
for i in range(Node):
node = Graph.addNode(i)
nodes.append(node)
for node_src in nodes:
for node_dst in nodes:
if node_src != node_dst:
M = Graph.numEdges()
if M not in dictTime.keys():
dictTime[M] = []
inizio = time.clock()
Graph.insertEdge(node_src.id, node_dst.id, 1)
fine = time.clock() - inizio
dictTime[M].append(fine)
X = []
Y = []
for key in sorted(dictTime.keys()):
X.append(key)
M = np.mean(np.array(dictTime[key]))
Y.append(M)
X = np.array(X)
Y = np.array(Y)
Yt = np.ones(len(Y))
Yt = Yt * np.mean(Y)
plt.figure('Tempo aggiungi arco')
plt.grid(True)
plt.title('Tempo aggiungi arco')
plt.ylabel('tempo in s')
plt.xlabel('numero di archi')
plt.xlim([np.min(X), np.max(X)])
plt.ylim([0, np.max(Y) * 1.2])
plt.plot(X, Y, 'r-', label='T(n) misurato con {0} campioni'.format(Sample))
plt.plot(X, Yt, 'b-', label='T(n)=cost')
plt.legend(loc='upper left')
plot = plt
return plot
def getGraphFix3():
"""
:return: un grafo non orientato con una struttura predifinita con la seguente lista di adiacenza:
0:[1, 3]
1:[0, 2]
2:[1]
3:[0, 4, 5]
4:[3]
5:[3, 6]
6:[5]
7:[]
Il risultato corrisponde a un grafo non orientato con 7 vertici dei quali 2 non sono collegati e con 18 archi
"""
oGraph = GraphAdjacencyList()
#creazione degli nodi da 0 a 7
nodes = []
for i in range(0, 8):
node = oGraph.addNode(i)
nodes.append(node)
# creazione degli arci che partono dal nal nodo 0
oGraph.insertEdge(0, 1, 1)
oGraph.insertEdge(0, 3, 1)
# creazione degli arci che partono dal nal nodo 1
oGraph.insertEdge(1, 0, 1)
oGraph.insertEdge(1, 2, 1)
# creazione degli arci che partono dal nal nodo 2
oGraph.insertEdge(2, 1, 1)
# creazione degli arci che partono dal nal nodo 3
oGraph.insertEdge(4, 3, 1)
# creazione degli arci che partono dal nal nodo 4
oGraph.insertEdge(3, 0, 1)
oGraph.insertEdge(3, 4, 1)
oGraph.insertEdge(3, 5, 1)
# creazione degli arci che partono dal nal nodo 5
oGraph.insertEdge(5, 3, 1)
oGraph.insertEdge(5, 6, 1)
# creazione degli arci che partono dal nal nodo 6
oGraph.insertEdge(6, 5, 1)
# creazione degli arci che partono dal nal nodo 7
# vuoto
return oGraph