def question3():
"""
calculates and plots running time of fast_targeted_order
versus targeted_order
for a series of increasingly larger UPA graphs
"""
t_o_times = []
f_t_o_times = []
graph_sizes = []
for num_nodes in range(10, 1000, 10):
graph_sizes.append(num_nodes)
curr_graph = app2_create_graphs.upa(num_nodes, 5)
t_o_start = time.time()
app2_provided.targeted_order(curr_graph)
t_o_times.append(time.time() - t_o_start)
f_t_o_start = time.time()
fast_order.fast_targeted_order(curr_graph)
f_t_o_times.append(time.time() - f_t_o_start)
pyplot.plot(graph_sizes, t_o_times, color='red', linestyle='-',
marker=None, label='targeted_order')
pyplot.plot(graph_sizes, f_t_o_times, color='blue', linestyle='-',
marker=None, label='fast_targeted_order')
pyplot.title('Comparison of algorithm running times: Desktop Python')
pyplot.xlabel('number of nodes in upa graph')
pyplot.ylabel('running time in seconds')
pyplot.grid(True)
pyplot.legend(loc='upper left')
pyplot.show()
def question4():
"""
create 3 graphs - subject each to a targeted attack order
plot the resulting largest cc for each
"""
network_graph = app2_provided.load_graph(app2_provided.NETWORK_URL)
attack_order = fast_order.fast_targeted_order(network_graph)
network_resil = bfs_visited.compute_resilience(network_graph, attack_order)
er_graph = app2_create_graphs.undirected_er(1239, 0.002)
while count_edges(er_graph) < 2900 or count_edges(er_graph) > 3190:
er_graph = app2_create_graphs.undirected_er(1239, 0.002)
attack_order = fast_order.fast_targeted_order(er_graph)
er_resil = bfs_visited.compute_resilience(er_graph, attack_order)
upa_graph = app2_create_graphs.upa(1239, 3)
attack_order = fast_order.fast_targeted_order(upa_graph)
upa_resil = bfs_visited.compute_resilience(upa_graph, attack_order)
pyplot.plot(range(1240), network_resil, color='red', linestyle='-',
marker=None, label='Network Graph')
pyplot.plot(range(1240), er_resil, color='blue', linestyle='-',
marker=None, label='ER Graph, p=0.002')
pyplot.plot(range(1240), upa_resil, color='green', linestyle='-',
marker=None, label='UPA Graph, m=3')
pyplot.title('Question 4\nComparison of Targeted Attack Graph Degradation')
pyplot.xlabel('Number of Nodes Removed')
pyplot.ylabel('Largest Connected Component')
pyplot.legend(loc='upper right')
pyplot.grid(True)
pyplot.show()
return network_resil, er_resil, upa_resil
def prepare_plot():
"""
prepare the plot of running time of targeted_order and fast_targeted_order
"""
initial_num = 5
targeted_plot = []
fast_targeted_plot = []
for num_nodes in range(10, 1000, 10):
graph = upa(num_nodes, initial_num)
gc.disable()
start_time = timeit.default_timer()
#start_time = int(round(timeit.default_timer()*1000))
targeted_order(graph)
end_time = timeit.default_timer()
#end_time = int(round(timeit.default_timer()*1000))
targeted_plot.append([num_nodes, (end_time - start_time)])
# fast_taregeted running time
start_time = timeit.default_timer()
#start_time = int(round(timeit.default_timer()*1000))
fast_targeted_order(graph)
end_time = timeit.default_timer()
#end_time = int(round(timeit.default_timer()*1000))
fast_targeted_plot.append([num_nodes, (end_time - start_time)])
gc.enable()
#print end_time - start_time
return [targeted_plot, fast_targeted_plot]
def prepare_plot():
"""
prepare the plot of running time of targeted_order and fast_targeted_order
"""
initial_num = 5
targeted_plot=[]
fast_targeted_plot = []
for num_nodes in range(10, 1000,10):
graph = upa(num_nodes, initial_num)
gc.disable()
start_time = timeit.default_timer()
#start_time = int(round(timeit.default_timer()*1000))
targeted_order(graph)
end_time = timeit.default_timer()
#end_time = int(round(timeit.default_timer()*1000))
targeted_plot.append([num_nodes, (end_time - start_time)])
# fast_taregeted running time
start_time = timeit.default_timer()
#start_time = int(round(timeit.default_timer()*1000))
fast_targeted_order(graph)
end_time = timeit.default_timer()
#end_time = int(round(timeit.default_timer()*1000))
fast_targeted_plot.append([num_nodes, (end_time - start_time)])
gc.enable()
#print end_time - start_time
return [targeted_plot, fast_targeted_plot]
def prepare_plot(graph):
"""
Takes a graph and function to load graph, calls random_order on graph and then
calls compute_resilience and returns the list of largest connected components
"""
#list_of_nodes = random_order(graph)
list_of_nodes = fast_targeted_order(graph)
connected_comps = compute_resilience(graph, list_of_nodes)
plot = []
#start_range = len(list_of_nodes)
for no_of_nodes_removed in range(0, len(list_of_nodes)):
plot.append([no_of_nodes_removed, connected_comps[no_of_nodes_removed]])
return plot
import erugraph as er
import upa
import compnetwork as comp
import project as proj
import random
import fast_targeted_order as fto
import targeted_order as to
compgraph = comp.load_graph("http://storage.googleapis.com/codeskulptor-alg/alg_rf7.txt")
p = float(3112)/float(906531)
ergraph =er.ERalg(1347,p)
m=3112/1347
upagraph = upa.UPAgraph(1347,m)
erresiliences = proj.compute_resilience(ergraph, fto.fast_targeted_order(ergraph))
uparesiliences = proj.compute_resilience(upagraph, fto.fast_targeted_order(upagraph))
compresiliences = proj.compute_resilience(compgraph, fto.fast_targeted_order(compgraph))
import matplotlib.pyplot as plt
plt.plot(range(1347 + 1), erresiliences, label = 'ER Graph, p = %s' % round(p,5))
plt.plot(range(1347 + 1), uparesiliences, label = 'UPA Graph, m = %s' % m)
plt.plot(range(1347 + 1), compresiliences, label = 'Computer Graph')
#plt.xscale('log')
#plt.yscale('log')
plt.title("Line plot of ER, computer network and \n UPA graph's resiliencies as vertices get removed in targeted order")
plt.xlabel('Number of vertices removed')
plt.ylabel('Size (order) of largest component left')
plt.legend()
plt.show()
