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)