def plot_remove(g): """ #remove the node with largest cut, plot the size of connected components with respect to number of nodes removed. Two methods: target & random remove #argument: g -- graph #return: a list of dictionaries, keys are the number of nodes removed, values are the largest CC of each graph """ graph1 = comp182.copy_graph(g) graph2 = comp182.copy_graph(g) ############################ # target remove result1 = {} nodeRemoved = 0 # create an array of nodes from max cut to min cut nodeToBeRemoved = sorted(graph1, key = lambda node:len(graph1[node]), reverse = True) CC = connected_components.connected_components(graph1) CC.sort(key=len,reverse=True) # sort CC from biggest to smallest result1[0] = len(CC[0]) # add biggest CC to the original graph while (nodeRemoved < len(graph1)): nodeRemoved += 1 remove_node = nodeToBeRemoved[0] graph1.pop(remove_node,None) # remove node, update g for node in graph1: if graph1[node] & {remove_node} == {remove_node}: graph1[node].remove(remove_node) nodeToBeRemoved.remove(remove_node) CC = connected_components.connected_components(graph1) CC.sort(key=len,reverse=True) # sort CC from biggest to smallest result1[nodeRemoved] = len(CC[0]) # add biggest CC to the original graph ########################## # random remove result2 = {} nodeRemoved = 0 CC = connected_components.connected_components(graph2) CC.sort(key=len,reverse=True) # sort CC from biggest to smallest result1[0] = len(CC[0]) # add biggest CC to the original graph while (nodeRemoved < len(graph2)): nodeRemoved += 1 graph2 = random_remove(graph2) CC = connected_components.connected_components(graph2) CC.sort(key=len,reverse=True) # sort CC from biggest to smallest result2[nodeRemoved] = len(CC[0]) # add biggest CC to the original graph ############################# # plot result = [result1, result2] # target, then random return result
def analyze_graphs(): """ Runs all six experiments and plots the pictorial graphs. Arguments: None Returns: None""" #Analyzes the network graph and creates similar perimeters for Erdos and UPA graph nodes = node_count_function(networktopology) print "Nodes in Network graph:", nodes string1, edgesavg = average_edge_per_node(networktopology) edges = edge_count(networktopology) print "Averge Number of Edges:", edgesavg totaldegree = provided.total_degree(networktopology) print "Total degree of Network graph:", totaldegree probabilityerdos = float(edges)/(nodes*(nodes-1)/2.0) print "Probability P for Erdos:", probabilityerdos upa = provided.upa(nodes,edgesavg) #Saves the grahes to be modified. savedrandomgraph = comp182.copy_graph(upa) erdos = provided.erdos_renyi(nodes,probabilityerdos) savederdosgraph = comp182.copy_graph(erdos) savednetworkgraph = comp182.copy_graph(networktopology) #runs the different attacks on the various graphs randomgraphattack = random_attack(comp182.copy_graph(upa)) print "First plot finished." randomgraphtargeted = targeted_attack(comp182.copy_graph(upa)) print "Second plot finished." erdosgraphattack = random_attack(comp182.copy_graph(erdos)) print "Third plot finished." erdosgraphtargeted = targeted_attack(comp182.copy_graph(erdos)) print "Fourth plot finished." networkgraphattack = random_attack(comp182.copy_graph(savednetworkgraph)) print "Fifth plot finished." networkgraphtargeted = targeted_attack(savednetworkgraph) print "Sixth plot finished." #formats the pictorial graph labelerdos = "Erdos({}, {})".format(nodes,probabilityerdos) labelupa = "UPA({},{})".format(nodes,edgesavg) labels = ["Network Graph"+"Targeted", "Network Graph"+"Random", labelerdos+"Targeted", labelerdos+"Random",labelupa+"Targeted", labelupa+"Random"] comp182.plot_lines([networkgraphtargeted, networkgraphattack, erdosgraphtargeted, erdosgraphattack, randomgraphtargeted, randomgraphattack],"Resiliency of Graphs' Attacks", "Nodes Removded", "Largest Connected-Component", labels, filename="Resiliency of Graphs' Attacks")
def gn_graph_partition(g): """ Partition the graph g using the Girvan-Newman method. Requires connected_components, shortest_path_edge_betweenness, and compute_q to be defined. This function assumes/requires these functions to return the values specified in the homework handout. Arguments: g -- undirected graph Returns: A list of tuples where each tuple contains a Q value and a list of connected components. """ ### Start with initial graph c = connected_components(g) q = compute_q(g, c) partitions = [(q, c)] ### Copy graph so we can partition it without destroying original newg = comp182.copy_graph(g) ### Iterate until there are no remaining edges in the graph while True: ### Compute betweenness on the current graph btwn = shortest_path_edge_betweenness(newg) #print "something is left" #print "between value", btwn if not btwn: #print "between value:", btwn ### No information was computed, we're done break ### Find all the edges with maximum betweenness and remove them maxbtwn = max(btwn.values()) maxedges = [edge for edge, b in btwn.iteritems() if b == maxbtwn] remove_edges(newg, maxedges) ### Compute the new list of connected components c = connected_components(newg) #print c if len(c) > len(partitions[-1][1]): ### This is a new partitioning, compute Q and add it to ### the list of partitions. q = compute_q(g, c) partitions.append((q, c)) return partitions
def gn_graph_partition(g): """ Partition the graph g using the Girvan-Newman method. Requires connected_components, shortest_path_edge_betweenness, and compute_q to be defined. This function assumes/requires these functions to return the values specified in the homework handout. Arguments: g -- undirected graph Returns: A list of tuples where each tuple contains a Q value and a list of connected components. """ ### Start with initial graph c = connected_components(g) q = compute_q(g, c) partitions = [(q, c)] ### Copy graph so we can partition it without destroying original newg = comp182.copy_graph(g) ### Iterate until there are no remaining edges in the graph while True: ### Compute betweenness on the current graph btwn = shortest_path_edge_betweenness(newg) #print 'shortest path edge betweenness function working' if not btwn: ### No information was computed, we're done break ### Find all the edges with maximum betweenness and remove them maxbtwn = max(btwn.values()) maxedges = [edge for edge, b in btwn.iteritems() if b == maxbtwn] remove_edges(newg, maxedges) ### Compute the new list of connected components c = connected_components(newg) #print 'connected componets function working' if len(c) > len(partitions[-1][1]): ### This is a new partitioning, compute Q and add it to ### the list of partitions. q = compute_q(g, c) #print 'compute Q function working' partitions.append((q, c)) return partitions