def create_graph(self, num_nodes, probability_edges, directed):
print("Generate. Nodes[" + str(num_nodes) + "] Edges[" +
str(probability_edges) + "] Direc[" + str(directed) + "]")
graph = Graph.creategraph(num_nodes,
probability_edges,
directed=directed)
return self.export(graph)
def create_graph_and_decrease_random_weight(self, num_nodes, probability_edges, directed):
graph = Graph.creategraph(num_nodes, probability_edges, directed=directed)
dist = Floyd_Warshall(graph)
graph.decrease_random_weight()
return {
"graph": self.export(graph),
"dist": self.export_matrix(dist)
}
def create_graph_and_insert_worst_edge(self, num_nodes, probability_edges=0.5, directed):
graph = Graph.creategraph(num_nodes, probability_edges, directed=directed)
dist = Floyd_Warshall(graph)
graph.insert_random_edge()
return {
"graph": self.export(graph),
"dist": self.export_matrix(dist)
}
def create_graph_and_incremental_edge(self, num_nodes, probability_edges,
directed):
graph = Graph.creategraph(num_nodes,
probability_edges,
directed=directed)
dist = Floyd_Warshall(graph)
graph.dynamic_incremental_random_edge()
return {"graph": self.export(graph), "dist": self.export_matrix(dist)}
import os
import sys
myPath = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, myPath + '/../')
from graph.Graph import Graph
from algorithms.floyd_warshall import *
from algorithms.eg import *
from algorithms.quinca import *
from algorithms.rr import *
from algorithms.forest import *
graph = Graph.creategraph(30, .8)
result_before_dist = np.array(Floyd_Warshall(graph))
graph.insert_random_edge()
result_after_dist = np.array(Floyd_Warshall(graph))
def test_rr():
dist_rr = Bfs_Truncated_With_Sources(graph, result_before_dist)
np.testing.assert_array_equal(dist_rr, result_after_dist)
def test_eg():
dist_eg = Even_Gazit(graph, result_before_dist)
np.testing.assert_array_equal(dist_eg, result_after_dist)
import os import sys import numpy as np myPath = os.path.dirname(os.path.abspath(__file__)) sys.path.insert(0, myPath + '/../') from graph.Graph import Graph from algorithms.floyd_warshall import * from algorithms.quinca import * graph = Graph.creategraph(10, .8) result_before_dist = np.array(Floyd_Warshall(graph)) graph.insert_worst_edge() dist_rr = Quinca(graph, result_before_dist) print(dist_rr)
def run(type_incremental,
num_nodes,
probability_edges,
num_try=30,
attempt=10,
saveFileExec=True,
labExec=True,
printer=True):
## Define params
labExec = bool(labExec)
saveFileExec = bool(saveFileExec)
num_nodes = int(num_nodes)
num_try = int(num_try)
attempt = int(attempt)
probability_edges = float(probability_edges)
results = []
dirGraphs = get_folder("synthetics", type_incremental, num_nodes,
probability_edges)
dirResults = get_folder("results", type_incremental, num_nodes,
probability_edges)
if printer:
print("=============================================")
print("Num nodes: ", num_nodes)
print("Probability Edge: ", probability_edges)
print("Graph count: ", num_try)
print("Try algorithms: ", num_try)
print("Exporting graphs: ", saveFileExec)
print("Exec algorithms: ", labExec)
print("\n")
### Define lab for exec
for i in range(num_try):
print(
"Loading graph [" + str(num_nodes) + ", " +
str(probability_edges) + "]", i, " of ", num_try)
graph = Graph.creategraph(num_nodes, probability_edges)
t = time()
dist_before = Dijkstra_apsp(graph)
#dist_before = Dijkstpython3 lab.py decrease_edge 1000 0.5ra_apsp(graph) if probability_edges < 0.1 else Floyd_Warshall(graph)
time_seconds = (time() - t) * 1000
print(time_seconds)
if type_incremental == "decrease_worst_edge":
graph.decrease_worst_weight()
elif type_incremental == "insert_worst_edge":
graph.insert_worst_edge()
elif type_incremental == "decrease_edge":
graph.decrease_random_weight()
else:
graph.insert_random_edge(weights=[1])
calculate = Algorithm(graph.export_values())
calculate.attempt = attempt
### Save graph
if saveFileExec:
graph_values = {
"graph": graph.export_values(),
"dist": export_matrix(dist_before)
}
filename = dirGraphs + "g_" + str(i) + ".json"
with open(filename, 'w') as outfile:
json.dump(graph_values, outfile)
### Exec lab and save on results[]
if labExec:
for algorithm_name in calculate.list()['incremental']:
times = calculate.run_algorithm(algorithm_name, dist_before)
for timee in times:
results.append({
"algorithm": algorithm_name,
"time": timee,
"nodes": len(calculate.graph.nodes),
"edges": len(calculate.graph.source),
"density": probability_edges,
"type": type_incremental
})
### Set Data Frame
df = pd.DataFrame(results)
filename = dirResults + "result.csv"
if labExec:
if printer:
print("To export: ", filename)
df.to_csv(filename, index=False, header=True)
print("END")
return {"dataframe": df, "filename": filename}
import os
import sys
import numpy as np
myPath = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, myPath + '/../')
from graph.Graph import Graph
from algorithms_prev.dijkstra_prev import *
from algorithms_prev.floyd_warshall_prev import *
graph = Graph.creategraph(9, .8)
def test_predecesors():
dist, pred = Dijkstra_apsp_PREV(graph)
np.testing.assert_equal(True, Graph.testDistPred(dist, pred))
dist, pred = Floyd_Warshall_PREV(graph)
np.testing.assert_equal(True, Graph.testDistPred(dist, pred))
#np.testing.assert_array_equal(pred_dijkstra, pred_fw)
from graph.Graph import Graph
from algorithms.dijkstra import *
from algorithms.floyd_warshall import *
print("<--------Test Create------->\n")
graph = Graph.creategraph(4, .2)
graph.print_r()
#dist = Dijkstra_apsp(graph)
#print(dist)
dist = Floyd_Warshall(graph)
print(dist)
probability_edges = 0.1
type_incremental = "insert_edge"
filename = "graph.json"
if len(sys.argv) < 3:
print("Faltan argumentos")
exit()
if len(sys.argv) >= 3:
num_nodes = int(sys.argv[1])
probability_edges = float(sys.argv[2])
pp = int(float(sys.argv[2]) * 100)
print("Creating graph...")
graph = Graph.creategraph(num_nodes, probability_edges)
print("Graph created")
print("Running calculate dist...")
t = time()
#dist = Floyd_Warshall(graph)
dist = Dijkstra_apsp(graph)
time_seconds = time() - t
print("Dist [] Done")
graph_values = {
"graph": graph.export_values(),
"dist": export_matrix(dist),
'time_fw': time_seconds
}
filename = "synthetics/graph_" + str(num_nodes) + "_" + str(sys.argv[2]) + ".json"
from graph.Graph import Graph
import numpy as np
import matplotlib.pyplot as plt
import os
import pandas as pd
import operator
import random
os.system('clear')
graph = Graph.creategraph(20, 1.0, directed=False)
cities = graph.vertex
class City:
def __init__(self, id):
self.id = id
def distance(self, id):
return graph.get_weight(self.id, id)
class Fitness:
def __init__(self, route):
self.route = route
self.distance = 0
self.fitness = 0.0
def route_distance(self):
if self.distance == 0:
path_distance = 0
for i in range(0, len(self.route)):
import os
import sys
import numpy as np
myPath = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, myPath + '/../')
from graph.Graph import Graph
from algorithms_prev.dijkstra_prev import *
from algorithms_prev.forest_pred import *
from algorithms_prev.abm_pred import *
#Grafos Aleatorios
graph = Graph.creategraph(6, .8)
graph.print_r()
dist, prev = Dijkstra_apsp_PREV(graph)
print(prev)
#graph.dynamic_incremental_edge(source=3, target=4, weight=2)
graph.insert_worst_edge()
print("------------------FOREST-----------------------")
dist2, prev2 = Forest_apsp_PRED(graph, dist.copy(), prev.copy())
print(prev2)
print("Data is correct? ", Graph.testDistPred(dist2, prev2))
print("----------------------ABM-------------------")
dist3, prev3 = ABM_Update_PRED(graph, dist.copy(), prev.copy())
print(prev3)
print("Data is correct? ", Graph.testDistPred(dist3, prev3))
import os
import sys
import numpy as np
myPath = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, myPath + '/../')
from graph.Graph import Graph
from algorithms_prev.dijkstra_prev import *
from algorithms_prev.forest_pred import *
from algorithms_prev.abm_pred import *
graph = Graph.creategraph(20, .8)
dist_before, prev_before = Dijkstra_apsp_PREV(graph)
graph.insert_worst_edge()
def test_predecesors():
dist, pred = Forest_apsp_PRED(graph, dist_before.copy(),
prev_before.copy())
np.testing.assert_equal(True, Graph.testDistPred(dist, pred))
dist2, pred2 = ABM_Update_PRED(graph, dist_before.copy(),
prev_before.copy())
np.testing.assert_equal(True, Graph.testDistPred(dist2, pred2))
#np.testing.assert_array_equal(pred_dijkstra, pred_fw)
## Data graph
repetitions = 10
num_nodes = 300
num_nodes_max = 301
probability_edges = 0.4
multliplicador = 1000
for num_notes_current in range(num_nodes, num_nodes_max):
print("----------------------------------------------")
print("Nodes: ", num_notes_current)
time_list_abm = []
for i in range(repetitions):
graph2 = Graph.creategraph(num_notes_current, probability_edges)
result_before_dist2 = np.array(Floyd_Warshall(graph2))
graph2.insert_worst_edge()
## Warm
for i in range(5):
dist111 = Quinca(graph2, result_before_dist2)
dist1112 = ABM_Update(graph2, result_before_dist2)
dist1113 = Even_Gazit(graph2, result_before_dist2)
t2 = time()
dist2 = ABM_Update(graph2, result_before_dist2)
time_miliseconds2 = (time() - t2) * multliplicador
time_list_abm.append(time_miliseconds2)
print("abm: ", time_miliseconds2)
