Пример #1
0
    def __init__(self, state):
        """
        Initializes your Player. You can set up persistent state, do analysis
        on the input graph, engage in whatever pre-computation you need. This
        function must take less than Settings.INIT_TIMEOUT seconds.
        --- Parameters ---
        state : State
            The initial state of the game. See state.py for more information.
        """

        graph = state.get_graph()
        #e_dict = nx.eccentricity(graph)
        station = nx.center(graph)[0] if nx.center(graph) else graph.nodes()[len(graph.nodes()) / 2] #max(e_dict, key=lambda i: x[i])
        self.stations.append(station)
Пример #2
0
def nodelist(network):
    """Returns a drawable nodelist.

    This is designed for the concentric circle-based drawing functions of networkx.
    """
    # first off, find most largestly connected (hub) server for the center
    center = nx.center(network)
    center = center[0]  # returns a list of centers, and we don't want that

    # and create the layers off that
    added_nodes = [
        center,
    ]
    shells = [
        (center, ),
    ]  # holds recursive shells

    any_added = True
    while any_added:
        any_added = False
        new_shell = []
        for node in shells[-1]:
            new_neighbors = nx.all_neighbors(network, node)
            for n in new_neighbors:
                if n not in added_nodes:
                    new_shell.append(n)
                    added_nodes.append(n)
                    any_added = True

        if len(new_shell) > 0:
            new_shell = (new_shell)  # make a tuple
            shells.append(new_shell)

    return shells
Пример #3
0
def Distance_measures(P, tipo, ruta):
    RUTA =  ruta + '/NetWX/files/'
    path = Path(RUTA)
    path.mkdir(parents = True,exist_ok = True)
    
    P_center            = []
    P_diameter          = []
    P_extrema_bounding  = []
    P_periphery         = []
    P_radius            = []
    for i in range(len(P)):
        P_center.append(center(P[i]))
        P_diameter.append(diameter(P[i]))
        P_extrema_bounding.append(extrema_bounding(P[i]))
        P_periphery.append(periphery(P[i]))
        P_radius.append(radius(P[i]))
    P_center           = DataFrame(P_center)
    P_diameter         = DataFrame(P_diameter)
    P_extrema_bounding = DataFrame(P_extrema_bounding)
    P_periphery        = DataFrame(P_periphery)
    P_radius           = DataFrame(P_radius)
    P_center.to_csv(RUTA + tipo + " - center.txt", sep = '\t',header = None,index = False)
    P_diameter.to_csv(RUTA + tipo +" - diameter.txt", sep = '\t',header = None,index = False)
    P_extrema_bounding.to_csv(RUTA + tipo +" - extrema_bounding.txt", sep = '\t',header = None,index = False)
    P_periphery.to_csv(RUTA + tipo + " - periphery.txt", sep = '\t',header = None,index = False)
    P_radius.to_csv(RUTA + tipo + " - radius.txt", sep = '\t',header = None,index = False)
                
            
Пример #4
0
    def twopi_layout(nx_graph, center=None):
        """
        Render the twopi layout. Ported from C code available at
        https://github.com/ellson/graphviz/blob/master/lib/twopigen/circle.c

        :param networkx.MultiDiGraph nx_graph: the networkx graph
        :param str center: the centered node
        :return:
        """
        if len(nx_graph.nodes()) == 0:
            return {}

        if len(nx_graph.nodes()) == 1:
            return {nx_graph.nodes()[0]: (0, 0)}
        #nx_graph = nx_graph.to_undirected()

        data = ExplorerScene._init_layout(nx_graph)
        if not center:
            center = networkx.center(nx_graph)[0]
        ExplorerScene._set_parent_nodes(nx_graph, data, center)
        ExplorerScene._set_subtree_size(nx_graph, data)
        data[center]['span'] = 2 * math.pi
        ExplorerScene._set_subtree_spans(nx_graph, data, center)
        data[center]['theta'] = 0.0
        ExplorerScene._set_positions(nx_graph, data, center)

        distances = networkx.shortest_path_length(nx_graph.to_undirected(),
                                                  center)
        nx_pos = {}
        for node in nx_graph.nodes():
            hyp = distances[node] + 1
            theta = data[node]['theta']
            nx_pos[node] = (hyp * math.cos(theta) * 100,
                            hyp * math.sin(theta) * 100)
        return nx_pos
Пример #5
0
    def twopi_layout(nx_graph, center=None):
        """
        Render the twopi layout. Ported from C code available at
        https://github.com/ellson/graphviz/blob/master/lib/twopigen/circle.c

        :param networkx.MultiDiGraph nx_graph: the networkx graph
        :param str center: the centered node
        :return:
        """
        if len(nx_graph.nodes()) == 0:
            return {}

        if len(nx_graph.nodes()) == 1:
            return {nx_graph.nodes()[0]: (0, 0)}
        #nx_graph = nx_graph.to_undirected()

        data = ExplorerScene._init_layout(nx_graph)
        if not center:
            center = networkx.center(nx_graph)[0]
        ExplorerScene._set_parent_nodes(nx_graph, data, center)
        ExplorerScene._set_subtree_size(nx_graph, data)
        data[center]['span'] = 2 * math.pi
        ExplorerScene._set_subtree_spans(nx_graph, data, center)
        data[center]['theta'] = 0.0
        ExplorerScene._set_positions(nx_graph, data, center)

        distances = networkx.shortest_path_length(nx_graph.to_undirected(), center)
        nx_pos = {}
        for node in nx_graph.nodes():
            hyp = distances[node] + 1
            theta = data[node]['theta']
            nx_pos[node] = (hyp * math.cos(theta) * 100, hyp * math.sin(theta) * 100)
        return nx_pos
Пример #6
0
def group_nodes(graph, size=3):
    root = nx.center(graph)[0]
    groups = []
    group = []

    for n in nx.dfs_preorder_nodes(graph, root):
        if graph.degree(n) < 2: continue
        # hit the terminal
        if len(group) >= 1 and not set(graph[n]).intersection(set(group)):
            groups.append(group)
            group = []
        # size cut
        if len(group) >= size:
            groups.append(group)
            group = []
        group.append(n)
    if group not in groups: groups.append(group)

    for i in range(len(groups)):
        # build sub-graph that includes degree = 1 elements
        group = groups[i]
        for n in group:
            for nn in graph[n]:
                if graph.degree(nn) == 1: group.append(nn)
        groups[i] = group

    return groups
Пример #7
0
    def updateGraphStats(self, graph):

        origgraph = graph
        if nx.is_connected(graph):
            random = 0
        else:
            connectedcomp = nx.connected_component_subgraphs(graph)
            graph = max(connectedcomp)

        if len(graph) > 1:
            pathlength = nx.average_shortest_path_length(graph)
        else:
            pathlength = 0

        # print graph.nodes(), len(graph), nx.is_connected(graph)

        stats = {
            "radius": nx.radius(graph),
            "density": nx.density(graph),
            "nodecount": len(graph.nodes()),
            "center": nx.center(graph),
            "avgcluscoeff": nx.average_clustering(graph),
            "nodeconnectivity": nx.node_connectivity(graph),
            "components": nx.number_connected_components(graph),
            "avgpathlength": pathlength
        }

        # print "updated graph stats", stats
        return stats
Пример #8
0
def answer_twelve():
        
    # Your Code Here
    G = answer_six()
    center = nx.center(G)[0]
    node = answer_eleven()[0]
    return len(nx.minimum_node_cut(G, center, node))
Пример #9
0
def get_nations_network_by_year(year):
    cursor = get_db().cursor()
    cursor.execute(
        """SELECT reporting, reporting_slug, partner, partner_slug, flow*Unit/ifnull(rate,1) as flow, expimp,
                    reporting_continent, partner_continent,reporting_type,partner_type
                    FROM flow_joined
                    WHERE reporting NOT LIKE "Worl%%"
                    AND partner NOT LIKE "Worl%%"
                    AND partner_slug IS NOT "NA"
                    AND partner_slug IS NOT "Unknown"
                    AND flow is not NULL
                    AND year = %s
                    """ % (year))

    table = [list(r) for r in cursor]

    json_sql_response = []

    for row in table:
        json_sql_response.append({
            "reporting": row[0],
            "reporting_id": row[1],
            "partner": row[2],
            "partner_id": row[3],
            "flow": row[4],
            "expimp": row[5],
            "reporting_continent": row[6],
            "partner_continent": row[7],
            "reporting_type": row[8],
            "partner_type": row[9]
        })

    # Create a graph instance
    G = nx.Graph()

    nodes = []
    for row in table:
        nodes.append(row[1])
        nodes.append(row[3])
        # add edge to the graph
        G.add_edge(row[1], row[3])

    nodes = set(nodes)

    # add nodes to graph
    G.add_nodes_from(nodes)
    if len(G.nodes()) > 0:
        stats = {
            "average_clustering": nx.average_clustering(G),
            "center": nx.center(G),
            "diameter": nx.diameter(G),
            "eccentricity": nx.eccentricity(G)
        }
    else:
        stats = []
    json_response = {}
    json_response["stats"] = stats
    json_response["network"] = json_sql_response

    return json.dumps(json_response, encoding="UTF8")
Пример #10
0
def answer_ten():

    # Your Code Here
    G_sc = answer_six()
    center = nx.center(G_sc)

    return set(center)  # Your Answer Here
Пример #11
0
def mkMatch(network, method):
    g_ = network
    if 'kclick' in method:  # k-click communities
        # k_ = int(method.replace('kclick', ''))
        svs = [i for i in x.algorithms.community.k_clique_communities(g_, 10)]
        gg = x.Graph()
        for i, sv in enumerate(svs):
            gg.add_node(i, weight=len(sv), children=sv)
    elif method == 'lab':  # label propagation
        svs = [
            i for i in x.algorithms.community.label_propagation_communities(g_)
        ]
        gg = x.Graph()
        for i, sv in enumerate(svs):
            gg.add_node(i, weight=len(sv), children=sv)
    elif method == 'cp':
        sub = [i for i in x.connected_component_subgraphs(g_)]
        g = sub[0]
        per = set(x.periphery(g))
        if len(sub) > 1:
            for per_ in sub[1:]:
                per.update(per_.nodes())
        cen = set(x.center(g))
        pc = per.union(cen)
        nodes = set(g.nodes())
        inter = nodes.difference(pc)
        gg = x.Graph()
        gg.add_node(0, label='center', weight=len(cen), children=cen)
        gg.add_node(1, label='intermediary', weight=len(inter), children=inter)
        gg.add_node(2, label='periphery', weight=len(per), children=per)
    return gg  # meta-network
Пример #12
0
def adjustUMI(umiList, dist=1):
    umi_count, umi_set_list = countList(umiList)
    # 1. compare all umis find singleton and creat Graph to get center
    umiG = nx.Graph()
    singleton_umi = deepcopy(umi_set_list)
    umi_map = {}
    for u1, u2 in combinations(umi_set_list, 2):
        if hDistance(u1, u2) <= 1:
            umiG.add_edges_from([(u1, u2)])
            if u1 in singleton_umi:
                singleton_umi.remove(u1)
            if u2 in singleton_umi:
                singleton_umi.remove(u2)
    if singleton_umi:
        for eachSgl in singleton_umi:
            umi_map[eachSgl] = eachSgl
    if list(nx.connected_components(umiG)):
        for eachG in nx.connected_component_subgraphs(umiG):
            centerUmilist = nx.center(eachG)
            if len(centerUmilist) == 1:
                for rawUmi in list(nx.connected_components(eachG))[0]:
                    umi_map[rawUmi] = centerUmilist[0]
            else:
                max_umiCount = 0
                centerUmi = ""
                for cenUmi in centerUmilist:
                    if umi_count[cenUmi] > max_umiCount:
                        max_umiCount = umi_count[cenUmi]
                        centerUmi = cenUmi
                for rawUmi in list(nx.connected_components(eachG))[0]:
                    umi_map[rawUmi] = centerUmi
    return umi_map
Пример #13
0
def answer_twelve():

    G_sc = answer_six()
    center = nx.center(G_sc)[0]
    mynode = answer_eleven()[0]

    return len(nx.minimum_node_cut(G_sc, center, mynode))
def info(graph):
    """Function that take the graph whose information is to be displayed
       Information includes - 
       number of nodes - Total number of nodes
       number of edges - Total number of edges
       Average degree - Degree of nodes (Indegree+ Outdegree)
       radius - Minimum eccentricity
       diameter - Maximum eccentricity
       eccentricity - Eccentricity of a node v is the maximum distance from v to
        all other nodes in graph.
       center - Set of nodes with eccentricity equal to radius.
       periphery - Set of nodes with eccentricity equal to the diameter.
       Density
    """
    try:
        print("-" * 10, "Node Attributes", "-" * 10)
        print(n.info(graph))
        print("-" * 10, "Distance Measures", "-" * 10)
        print("radius: %d" % n.radius(graph))
        print("diameter: %d" % n.diameter(graph))
        print("eccentricity: %s" % n.eccentricity(graph))
        print("center: %s" % n.center(graph))
        print("periphery: %s" % n.periphery(graph))
        print("density: %s" % n.density(graph))
    except Exception as ex:
        print(ex)
    return graph
Пример #15
0
    def SaveGraph(self, filename):
        logging.debug("From SVNFileNetwork.SaveGraph")

        print "saving the file network graph to %s" % filename
        plt.clf()
        #pos = NX.spring_layout(self, dim=2, iterations=20)
        logging.info("starting layout using pydot_layout")
        pos = NX.pydot_layout(self, prog='neato')
        print "finished layout"
        logging.info("finished layout using pydot_layout")
        plt.figure(figsize=(8.0, 8.0))
        NX.draw_networkx_nodes(self, pos, node_size=10)
        NX.draw_networkx_edges(self, pos)
        # display revision nodes in different colors
        revnodes = self.getNodes(SVNNetworkRevisionNode)
        NX.draw_networkx_nodes(
            self, pos, revnodes, node_color='g', node_size=30)
        # display center nodes with larger size
        NX.draw_networkx_nodes(
            self, pos, NX.center(self), node_color='b', node_size=50)

        ax = plt.gca()
        plt.setp(ax.get_yticklabels(), visible=False)
        plt.setp(ax.get_xticklabels(), visible=False)

        plt.savefig(filename, dpi=100, format="png")
        self.PrintGraphStat()
        print "Saved ..."
Пример #16
0
    def updateGraphStats(self, graph):

        origgraph = graph
        if nx.is_connected(graph):
            random = 0
        else:
            connectedcomp = nx.connected_component_subgraphs(graph)
            graph = max(connectedcomp)

        if len(graph) > 1:
            pathlength = nx.average_shortest_path_length(graph)
        else:
            pathlength = 0

        # print graph.nodes(), len(graph), nx.is_connected(graph)

        stats = {
            "radius": nx.radius(graph),
            "density": nx.density(graph),
            "nodecount": len(graph.nodes()),
            "center": nx.center(graph),
            "avgcluscoeff": nx.average_clustering(graph),
            "nodeconnectivity": nx.node_connectivity(graph),
            "components": nx.number_connected_components(graph),
            "avgpathlength": pathlength
        }

        # print "updated graph stats", stats
        return stats
Пример #17
0
def print_graph_info(graph):
  e = nx.eccentricity(graph)
  print 'graph with %u nodes, %u edges' % (len(graph.nodes()), len(graph.edges()))
  print 'radius: %s' %  nx.radius(graph, e) # min e
  print 'diameter: %s' % nx.diameter(graph, e) # max e
  print 'len(center): %s' % len(nx.center(graph, e)) # e == radius
  print 'len(periphery): %s' % len(nx.periphery(graph, e)) # e == diameter
Пример #18
0
    def SaveGraph(self, filename):
        logging.debug("From SVNFileNetwork.SaveGraph")

        print("saving the file network graph to %s" % filename)
        plt.clf()
        #pos = NX.spring_layout(self, dim=2, iterations=20)
        logging.info("starting layout using pydot_layout")
        pos = NX.pydot_layout(self, prog='neato')
        print("finished layout")
        logging.info("finished layout using pydot_layout")
        plt.figure(figsize=(8.0, 8.0))
        NX.draw_networkx_nodes(self, pos, node_size=10)
        NX.draw_networkx_edges(self, pos)
        # display revision nodes in different colors
        revnodes = self.getNodes(SVNNetworkRevisionNode)
        NX.draw_networkx_nodes(
            self, pos, revnodes, node_color='g', node_size=30)
        # display center nodes with larger size
        NX.draw_networkx_nodes(
            self, pos, NX.center(self), node_color='b', node_size=50)

        ax = plt.gca()
        plt.setp(ax.get_yticklabels(), visible=False)
        plt.setp(ax.get_xticklabels(), visible=False)

        plt.savefig(filename, dpi=100, format="png")
        self.PrintGraphStat()
        print("Saved ...")
Пример #19
0
    def basic_stats(self):
        #not decided on what level to deal with this yet:
        #either return error un not dealing with unconnected files,
        #or making it deal with unconnected files: the latter.
        #How about with dealing with each independently.
        #    if not nx.is_connected(g):
        #        conl= nx.connected_components(g)
        #        for n in conl:
        #            turn n into graph if it isnt
        #            calculate ec, per, cnt
        #            how and when to visualise the subgraphs?
        #            iterate to next n

        if nx.is_connected(self.nx_graph):
            ec = nx.eccentricity(self.nx_graph) 
        else:
            ec = 'NA - graph is not connected'

        per = nx.periphery(self.nx_graph)
        cnt = nx.center(self.nx_graph)
        result = { #"""fast betweenness algorithm"""  
            'bbc': nx.brandes_betweenness_centrality(self.nx_graph),
            'tn': nx.triangles(self.nx_graph), # number of triangles
            'ec': ec,
            'per': per,
            'cnt': cnt,
            'Per': self.nx_graph.subgraph(per),
            'Cnt': self.nx_graph.subgraph(cnt)
            }
        return result
Пример #20
0
def Properties(G, verbose=0):
    txt = ''
    pathlengths = []
    for v in G.nodes():
        spl = nx.single_source_shortest_path_length(G, v)
        #print('%s %s' % (v,spl),file=sys.stderr)
        for p in spl.values():
            pathlengths.append(p)

    txt += "average shortest path length %s\n" % (sum(pathlengths) /
                                                  len(pathlengths))

    # histogram of path lengths
    dist = {}
    for p in pathlengths:
        if p in dist:
            dist[p] += 1
        else:
            dist[p] = 1

    txt += "length #paths"
    verts = dist.keys()
    for d in sorted(verts):
        txt += '%s %d\n' % (d, dist[d])

    txt += 'radius: %d\n' % nx.radius(G)
    txt += 'diameter: %d\n' % nx.diameter(G)
    #txt+= 'eccentricity: %s\n' % nx.eccentricity(G)
    txt += 'center: %s\n' % nx.center(G)
    #txt+= 'periphery: %s\n' % nx.periphery(G)
    txt += 'density: %s\n' % nx.density(G)
    return txt
Пример #21
0
    def extract_simple_features(self, graph):
        res = {}
        try:
            print('diameter: ', nx.diameter(graph))
            print('eccentricity: ', nx.eccentricity(graph))
            print('center: ', nx.center(graph))
            print('periphery: ', nx.periphery(graph))
            res['connected'] = True
        except Exception as e:
            print('Graph not connected')
            res['connected'] = False

        res['density'] = '{:.6f}'.format(nx.density(graph))
        res['Avg_degree'] = '{:.6f}'.format(
            sum([i[1] for i in nx.degree(graph)]) / len(nx.degree(graph)))
        res['Avg_weight'] = '{:.6f}'.format(
            sum([graph[edge[0]][edge[1]]['weight'] for edge in graph.edges]) /
            len([graph[edge[0]][edge[1]]['weight'] for edge in graph.edges]))
        res['edges'] = len(graph.edges)
        res['nodes'] = len(graph.nodes)
        res['self_loops'] = len(list(nx.nodes_with_selfloops(graph)))
        res['edge_to_node_ratio'] = '{:.6f}'.format(
            len(graph.nodes) / len(graph.edges))
        res['negative_edges'] = nx.is_negatively_weighted(graph)
        return res
def parseCSVGraphAnalysis(G):
    global headers
    row = ''
    data = nx.info(G).split('\n')
    nameG = data[0].split(':')[1].strip()
    if saveGEXF:
        nx.write_gexf(G, nameG + '.gexf')
    if headers:
        row = 'Name' + separator + separator.join(
            val.split(':')[0] for val in data[2:])
        row += (separator + 'Density') if selected[0] else ''
        row += (separator + 'Diameter') if selected[1] else ''
        row += (separator + 'Degrees') if selected[2] else ''
        row += (separator + 'Eccentricity') if selected[3] else ''
        row += (separator + 'Center') if selected[4] else ''
        row += (separator + 'Periphery') if selected[5] else ''
        row += '\n'
        headers = False
    row += nameG + separator + separator.join(
        val.split(':')[1].strip() for val in data[2:])
    row += (separator + str(nx.density(G))) if selected[0] else ''
    row += (separator + str(nx.diameter(G))) if selected[1] else ''
    row += (separator + str(nx.degree(G))) if selected[2] else ''
    row += (separator + str(nx.eccentricity(G))) if selected[3] else ''
    row += (separator + str(nx.center(G))) if selected[4] else ''
    row += (separator + str(nx.periphery(G))) if selected[5] else ''
    return row
Пример #23
0
def nodelist(network):
    """Returns a drawable nodelist.

    This is designed for the concentric circle-based drawing functions of networkx.
    """
    # first off, find most largestly connected (hub) server for the center
    center = nx.center(network)
    center = center[0]  # returns a list of centers, and we don't want that

    # and create the layers off that
    added_nodes = [center, ]
    shells = [(center,), ]  # holds recursive shells

    any_added = True
    while any_added:
        any_added = False
        new_shell = []
        for node in shells[-1]:
            new_neighbors = nx.all_neighbors(network, node)
            for n in new_neighbors:
                if n not in added_nodes:
                    new_shell.append(n)
                    added_nodes.append(n)
                    any_added = True

        if len(new_shell) > 0:
            new_shell = (new_shell)  # make a tuple
            shells.append(new_shell)

    return shells
Пример #24
0
def analyze_distance():
    center = nx.center(G)
    barycenter = nx.barycenter(G)
    diameter = nx.diameter(G)
    table = prettytable.PrettyTable(['center', 'barycenter', 'diameter'])
    table.add_row([center, barycenter, diameter])
    print(table)
Пример #25
0
def make_graph(graph_object, color_map):
    """Makes the graph and returns variables needed for further visualization
    :return center: center node
    :return title: the label of the center node used for titling visualizations
    :return node_count: the number of nodes
    :return fig1: the graph
    """

    fig1 = plt.figure()
    center = nx.center(graph_object)[0]
    title = graph_object.nodes[center]['label']

    # degrees = nx.degree(graph_object)
    node_count = len(nx.nodes(graph_object))

    # layout for display
    pos = nx.spring_layout(graph_object)

    # draw function
    nx.draw(graph_object, pos=pos, node_color=color_map, node_size=1000)

    # add node labels
    node_labels = nx.get_node_attributes(graph_object, 'label')
    nx.draw_networkx_labels(graph_object, pos=pos, labels=node_labels)

    # add edge labels
    edge_labels = nx.get_edge_attributes(graph_object, 'PARTICIPATION_TYPE')
    nx.draw_networkx_edge_labels(graph_object, pos, edge_labels)
    return center, title, node_count, fig1
Пример #26
0
def get_nations_network_by_year(year):
  cursor = get_db().cursor()
  cursor.execute("""SELECT reporting, reporting_slug, partner, partner_slug, Flow, expimp,
                    reporting_continent, partner_continent,reporting_type,partner_type
                    FROM flow_joined
                    WHERE reporting NOT LIKE "Worl%%"
                    AND partner NOT LIKE "Worl%%"
                    AND Flow != "null"
                    AND year = %s
                    """%(year)
              )

  table = [list(r) for r in cursor]

  json_sql_response=[]

  for row in table:
    json_sql_response.append({
      "reporting": row[0],
      "reporting_id": row[1],
      "partner": row[2],
      "partner_id": row[3],
      "flow": row[4],
      "expimp": row[5],
      "reporting_continent": row[6],
      "partner_continent": row[7],
      "reporting_type": row[8],
      "partner_type": row[9]
      })


  # Create a graph instance
  G=nx.Graph()

  nodes = []
  for row in table:
    nodes.append(row[1])
    nodes.append(row[3])
    # add edge to the graph
    G.add_edge(row[1], row[3])

  nodes = set(nodes)

  # add nodes to graph
  G.add_nodes_from(nodes)
  if len(G.nodes())>0:
    stats = {
      "average_clustering": nx.average_clustering(G),
      "center": nx.center(G),
      "diameter": nx.diameter(G),
      "eccentricity": nx.eccentricity(G)
    }
  else:
    stats=[]
  json_response = {}
  json_response["stats"] = stats
  json_response["network"] = json_sql_response

  return json.dumps(json_response,encoding="UTF8")
Пример #27
0
def verify_graph(nx_graph):
    g_gen = Graph()
    for edge in nx.edges(nx_graph):
        g_gen.add_edge(*edge)

    diameter, center = g_gen.diameter_center()
    assert (center in nx.center(nx_graph)) == True
    assert diameter == nx.diameter(nx_graph)
def answer_ten():
        
    # Your Code Here
#     r = nx.radius(G_sc)
#     e = nx.eccentricity(G_sc)
#     n = [node for node in e.items() if node[1] == r]
#     set([node[0] for node in n])
    return set(nx.center(G_sc)) # Your Answer Here
def find_central(G):
    try:
        cen = nx.center(G)
    except nx.exception.NetworkXError:
        print('Graph is not connected')
        cen = {}
    print('Central: ', cen)
    return cen
Пример #30
0
        def point_to_new_cluster(clust):

            try:

                sub = self.collapsed_clusters[clust.cluster]
                return utilities.Cluster_Entry(sub, nx.center(self.clusters[sub])[0])
            except KeyError:
                return clust
def answer_twelve():
        
    # Your Code Here
    n = answer_eleven()[0]
    c = nx.center(G_sc)[0]
#     cut = nx.minimum_node_cut(G=G_sc, s=c, t=n)
    conn = nx.node_connectivity(G_sc, s=c, t=n) - 1
    return conn # Your Answer Here
Пример #32
0
def print_graph_info(graph):
    e = nx.eccentricity(graph)
    print 'graph with %u nodes, %u edges' % (len(
        graph.nodes()), len(graph.edges()))
    print 'radius: %s' % nx.radius(graph, e)  # min e
    print 'diameter: %s' % nx.diameter(graph, e)  # max e
    print 'len(center): %s' % len(nx.center(graph, e))  # e == radius
    print 'len(periphery): %s' % len(nx.periphery(graph, e))  # e == diameter
Пример #33
0
def find_central(G):  #set of nodes that have eccentricity equal to the radius
    try:
        cen = nx.center(G)
    except nx.exception.NetworkXError:
        print('Graph is not connected')
        cen = {}
    print('Central: ', cen)
    return cen
Пример #34
0
def get_graph_center(G):

	center= nx.center(G)
	non_center = [node for node in G.nodes if node not in center]

	G2 = G.copy()
	G2.remove_nodes_from(non_center)

	return center, G2
Пример #35
0
def answer_ten():
    G = answer_six()

    # Manual calculate:
    # ec = nx.eccentricity(G)
    # radius = nx.radius(G)
    # return set([node for node, value in ec.items() if value==radius])

    return set(nx.center(G))
Пример #36
0
def getDiffusionModelLabels(adjacency,
                            repetitions=1000,
                            threshold=0.5,
                            patient0=None):

    import networkx as nx
    import ndlib.models.ModelConfig as mc
    from ndlib.models.epidemics.IndependentCascadesModel import IndependentCascadesModel

    if patient0 is None:
        patient0 = nx.center(nx.from_numpy_matrix(adjacency))[
            0]  # A-4: 50, B-4: 71; A-6: 42, B-4: 26

    A = adjacency.copy()
    g = nx.from_numpy_matrix(A)
    cfg = mc.Configuration()
    cfg.add_model_initial_configuration("Infected", set(list([patient0])))

    if threshold is None:
        threshold = 0.5
    for e in g.edges():
        cfg.add_edge_configuration("threshold", e, threshold)

    model = IndependentCascadesModel(g)
    model.set_initial_status(cfg)

    if repetitions is None:
        repetitions = 1000
    res_probs = np.zeros((A.shape[0], repetitions))
    res_Probs = np.zeros(res_probs.shape)

    iteration_results = []
    for rep in range(repetitions):
        model.reset()
        itr = 0
        while True:
            itr += 1
            iteration_result = model.iteration()
            iteration_results.append(iteration_result)

            for node, status in iteration_result['status'].items():
                if status == 1:
                    res_probs[node, rep] = itr

            if len(iteration_result['status']) == 0:
                break

        res_Probs[res_probs[:, rep] > 1,
                  rep] = 1.0 / (res_probs[res_probs[:, rep] > 1, rep] - 1.)

    res_Prob = np.mean(res_Probs, 1)
    res_Prob[patient0] = np.mean(res_Prob[np.argwhere(
        adjacency[patient0, :])][:, 0])

    #    import matplotlib.pyplot as plt
    #    plt.imshow(np.repeat(res_Prob.reshape((len(res_Prob),1)),10,axis=1))
    return res_Prob
Пример #37
0
 def jordanCenter(graph):
     if len(graph.nodes) == 1:
         return graph.nodes[0], 0
     if not nx.is_connected(graph):
         conComp = max(nx.connected_components(graph), key=len)
         graph = graph.subraph(conComp)
     center = nx.center(graph)[0]
     radius = nx.radius(graph)
     return center, radius
Пример #38
0
def answer_twelve():
    nodes_to_cut = set()
    G_sc = answer_six()
    target = answer_eleven()[0]
    sources = nx.center(G_sc)
    for source in sources:
        min_nodes_to_cut = nx.minimum_node_cut(G_sc, s=source, t=target)
        nodes_to_cut.update(min_nodes_to_cut)
    n_min_nodes_to_cut = len(nodes_to_cut)
    return n_min_nodes_to_cut
Пример #39
0
def answer_twelve():
    # Your Code Here
    G_sc = answer_six()
    node_11 = answer_eleven()[0]
    center_nodes = nx.center(G_sc)

    no_cut_nodes = len(
        [nx.minimum_node_cut(G_sc, cn, node_11) for cn in center_nodes][0])

    return no_cut_nodes
 def f33(self):
     return "ND"
     start = 0
     try:
         res = len(nx.center(self.G))
     except nx.exception.NetworkXError:
         res = "ND"
     stop = 0
     # self.feature_time.append(stop - start)
     return res
 def f33(self):
     return "ND"
     start = 0
     try:
         res = len(nx.center(self.G))
     except nx.exception.NetworkXError:
         res = "ND"
     stop = 0
     # self.feature_time.append(stop - start)
     return res
Пример #42
0
    def _get_prototype_id(self):
        node_graph = nx.Graph()

        for i in range(self.total_instances):
            for j in range(i + 1, self.total_instances):
                node_graph.add_edge(i, j, weight = \
                                    self.base_similarity_matrix[i, j])

        T = nx.minimum_spanning_tree(node_graph)
        list_of_centers = nx.center(T)
        return list_of_centers[0]
Пример #43
0
def LeaderInCluster( graphObj, moldict ):
    leaderList = []
    for eachSubGraph in nx.connected_component_subgraphs( graphObj ):
        centerlist = nx.center(eachSubGraph)
        if len(centerlist) < 1:
            raise "A subgraph with less than 1 center"
        leaderID   = RandomPickFromList(centerlist)
        leaderList.append( leaderID )
        graphSize  = len(eachSubGraph)
        moldict[ leaderID ][ "size" ] = graphSize
    return leaderList
def test_center(testgraph):
    """
    Testing center function for graphs.
    """

    a, b = testgraph
    nx_center = nx.center(a)
    sg_center = sg.digraph_distance_measures.center(b, b.nodes())
    nx_center = array(nx_center, dtype = uint32)
    nx_center.sort()
    sg_center.sort()
    assert_equal(nx_center, sg_center)
Пример #45
0
    def __get_centroid(self, cluster=None):
        """Get the centroid of a cluster in the graph or the centroid of the graph.

        Parameters
        ----------
        cluster : list
            Nodes list of a cluster.

        Returns
        -------
        centroid_node   : int
            Centroid node of a cluster.
        """
        # centroid of a cluster
        if cluster:
            subgraph = self.graph.subgraph(cluster)
            centroid = nx.center(subgraph)
        # centroid of the graph
        else:
            centroid = nx.center(self.graph)

        # choose randomly if more than one centroid found
        centroid_node = choice(centroid) if len(centroid) > 1 else centroid
        return centroid_node
Пример #46
0
 def connectivity(self):
     components = list(nx.connected_component_subgraphs(self.G))
     print('Connected components number: ')
     print(len(components))
     giant = components.pop(0)
     print('Giant component radius: ')
     print(nx.radius(giant))
     print('Giant component diameter: ')
     print(nx.diameter(giant))
     center = nx.center(giant)
     print('Giant component center: ')
     for i in xrange(len(center)):
         print(self.singer_dict[int(center[i])].split('|')[0])
     inf = self.get_graph_info(giant)
     for i in xrange(len(inf)):
         print(inf[i])
Пример #47
0
def append_central_nodes(graph, table_data):
    """Append periphery nodes to table_data."""

    # first, setup all values to false
    for node in graph.nodes(data=True):
        node_name = gen_username(node[1]['first_name'],
                                 node[1]['last_name'],
                                 node[0])
        if node_name in table_data:
            table_data[node_name].append('')
        else:
            table_data[node_name] = ['']

    # second, update these values to True for periphery
    for uid in nx.center(graph):
        node_name = gen_username(graph.node[uid]['first_name'],
                                 graph.node[uid]['last_name'],
                                 uid)
        table_data[node_name][-1] = 'True'
def generateGraphFromFile():
    g = nx.Graph()
    nodes = []
    with open("File.txt") as f:
        for line in f:
            line = line.replace("\n","")
            lineArr = line.split(" ")
            dummy = tuple(lineArr[0:3])
            nodes.append(dummy)


    g.add_weighted_edges_from(nodes)
    matrixPaths = nx.floyd_warshall_numpy(g,nodelist=None, weight='weight')
    #print matrixPaths
    listNodes = g.nodes()
    #print listNodes
    center = nx.center(g,e=None)
    #print center
    pos=nx.spring_layout(g)
    return (center, matrixPaths, listNodes,g,pos)
Пример #49
0
def report_components(g):
	components = nx.connected_component_subgraphs(g)
	print "Components: %d" % len(components)
	c_data = {}
	for i in range(len(components)):
		c = components[i]
		if len(c.nodes()) > 5: # Avoid reporting on many small components
			c_data["nodes"] = len(c.nodes())
			c_data["edges"] = len(c.edges())
			c_data["avg_clustering"] = nx.average_clustering(c)
			c_data["diameter"] = nx.diameter(c)
			c_data["radius"] = nx.radius(c)
			c_data["center"] = len(nx.center(c))
			c_data["periphery"] = len(nx.periphery(c))

			print "* Component %d:" % i
			for k in c_data:
				print "--- %s: %s" % (k, c_data[k])

	return c_data
Пример #50
0
    def SaveMST(self, filename):
        logging.debug("From SVNFileNetwork.SaveMST")

        mstGraph = self._getMSTGraph()

        print "saving MST of the file network graph to %s" % filename
        plt.clf()
        #pos = NX.spring_layout(self, dim=2, iterations=20)
        logging.info("starting layout using pydot_layout")
        pos = NX.pydot_layout(mstGraph, prog='neato')
        print "finished layout"
        logging.info("finished layout using pydot_layout")
        plt.figure(figsize=(8.0, 8.0))

        NX.draw_networkx_nodes(mstGraph, pos, node_size=10)
        NX.draw_networkx_edges(mstGraph, pos)
        # display center nodes with larger size
        NX.draw_networkx_nodes(
            mstGraph, pos, NX.center(mstGraph), node_color='b', node_size=50)
        # create node labels
        label = dict()
        for node in mstGraph.nodes_iter():
            dirname, fname = os.path.split(node.name())
            label[node] = fname
        NX.draw_networkx_labels(mstGraph, pos, label, font_size=8)

        # disable X and Y tick labels
        ax = plt.gca()
        plt.setp(ax.get_yticklabels(), visible=False)
        plt.setp(ax.get_xticklabels(), visible=False)

        plt.savefig(filename, dpi=100, format="png")
        print "Saved MST..."
        print "saving MST treemap"
        jsfilename, ext = os.path.splitext(filename)
        jsfilename = jsfilename + '.js'
        print "treemap filename %s" % jsfilename
        outfile = open(jsfilename, "w")
        self.treemapNodeDict['Root'].writejson(
            outfile, 'closeness', 'betweenness')
        outfile.close()
Пример #51
0
# Define the equivalent NetworkX graph to test against

gnx = nx.Graph()

gnx.add_edge(0, 1)
gnx.add_edge(1, 2)
gnx.add_edge(1, 3)
gnx.add_edge(4, 1)

assert g.degree(0) == gnx.degree(0)
assert g.degree(1) == gnx.degree(1)
assert g.degree(4) == gnx.degree(4)

diameter, center = g.diameter_center()
assert (center in nx.center(gnx)) == True

# Use network x to generate a random graph and replicate it as a custom graph.
# Then check it returns the same value for some functions


def verify_graph(nx_graph):
    g_gen = Graph()
    for edge in nx.edges(nx_graph):
        g_gen.add_edge(*edge)

    diameter, center = g_gen.diameter_center()
    assert (center in nx.center(nx_graph)) == True
    assert diameter == nx.diameter(nx_graph)

verify_graph(nx.sedgewick_maze_graph())
Пример #52
0
def extended_stats(G, connectivity=False, anc=False, ecc=False, bc=False, cc=False):
    """
    Calculate extended topological stats and metrics for a graph.

    Many of these algorithms have an inherently high time complexity. Global
    topological analysis of large complex networks is extremely time consuming
    and may exhaust computer memory. Consider using function arguments to not
    run metrics that require computation of a full matrix of paths if they
    will not be needed.

    Parameters
    ----------
    G : networkx multidigraph
    connectivity : bool
        if True, calculate node and edge connectivity
    anc : bool
        if True, calculate average node connectivity
    ecc : bool
        if True, calculate shortest paths, eccentricity, and topological metrics
        that use eccentricity
    bc : bool
        if True, calculate node betweenness centrality
    cc : bool
        if True, calculate node closeness centrality

    Returns
    -------
    stats : dict
        dictionary of network measures containing the following elements (some
        only calculated/returned optionally, based on passed parameters):

          - avg_neighbor_degree
          - avg_neighbor_degree_avg
          - avg_weighted_neighbor_degree
          - avg_weighted_neighbor_degree_avg
          - degree_centrality
          - degree_centrality_avg
          - clustering_coefficient
          - clustering_coefficient_avg
          - clustering_coefficient_weighted
          - clustering_coefficient_weighted_avg
          - pagerank
          - pagerank_max_node
          - pagerank_max
          - pagerank_min_node
          - pagerank_min
          - node_connectivity
          - node_connectivity_avg
          - edge_connectivity
          - eccentricity
          - diameter
          - radius
          - center
          - periphery
          - closeness_centrality
          - closeness_centrality_avg
          - betweenness_centrality
          - betweenness_centrality_avg

    """

    stats = {}
    full_start_time = time.time()

    # create a DiGraph from the MultiDiGraph, for those metrics that require it
    G_dir = nx.DiGraph(G)

    # create an undirected Graph from the MultiDiGraph, for those metrics that
    # require it
    G_undir = nx.Graph(G)

    # get the largest strongly connected component, for those metrics that
    # require strongly connected graphs
    G_strong = get_largest_component(G, strongly=True)

    # average degree of the neighborhood of each node, and average for the graph
    avg_neighbor_degree = nx.average_neighbor_degree(G)
    stats['avg_neighbor_degree'] = avg_neighbor_degree
    stats['avg_neighbor_degree_avg'] = sum(avg_neighbor_degree.values())/len(avg_neighbor_degree)

    # average weighted degree of the neighborhood of each node, and average for
    # the graph
    avg_weighted_neighbor_degree = nx.average_neighbor_degree(G, weight='length')
    stats['avg_weighted_neighbor_degree'] = avg_weighted_neighbor_degree
    stats['avg_weighted_neighbor_degree_avg'] = sum(avg_weighted_neighbor_degree.values())/len(avg_weighted_neighbor_degree)

    # degree centrality for a node is the fraction of nodes it is connected to
    degree_centrality = nx.degree_centrality(G)
    stats['degree_centrality'] = degree_centrality
    stats['degree_centrality_avg'] = sum(degree_centrality.values())/len(degree_centrality)

    # calculate clustering coefficient for the nodes
    stats['clustering_coefficient'] = nx.clustering(G_undir)

    # average clustering coefficient for the graph
    stats['clustering_coefficient_avg'] = nx.average_clustering(G_undir)

    # calculate weighted clustering coefficient for the nodes
    stats['clustering_coefficient_weighted'] = nx.clustering(G_undir, weight='length')

    # average clustering coefficient (weighted) for the graph
    stats['clustering_coefficient_weighted_avg'] = nx.average_clustering(G_undir, weight='length')

    # pagerank: a ranking of the nodes in the graph based on the structure of
    # the incoming links
    pagerank = nx.pagerank(G_dir, weight='length')
    stats['pagerank'] = pagerank

    # node with the highest page rank, and its value
    pagerank_max_node = max(pagerank, key=lambda x: pagerank[x])
    stats['pagerank_max_node'] = pagerank_max_node
    stats['pagerank_max'] = pagerank[pagerank_max_node]

    # node with the lowest page rank, and its value
    pagerank_min_node = min(pagerank, key=lambda x: pagerank[x])
    stats['pagerank_min_node'] = pagerank_min_node
    stats['pagerank_min'] = pagerank[pagerank_min_node]

    # if True, calculate node and edge connectivity
    if connectivity:
        start_time = time.time()

        # node connectivity is the minimum number of nodes that must be removed
        # to disconnect G or render it trivial
        stats['node_connectivity'] = nx.node_connectivity(G_strong)

        # edge connectivity is equal to the minimum number of edges that must be
        # removed to disconnect G or render it trivial
        stats['edge_connectivity'] = nx.edge_connectivity(G_strong)
        log('Calculated node and edge connectivity in {:,.2f} seconds'.format(time.time() - start_time))

    # if True, calculate average node connectivity
    if anc:
        # mean number of internally node-disjoint paths between each pair of
        # nodes in G, i.e., the expected number of nodes that must be removed to
        # disconnect a randomly selected pair of non-adjacent nodes
        start_time = time.time()
        stats['node_connectivity_avg'] = nx.average_node_connectivity(G)
        log('Calculated average node connectivity in {:,.2f} seconds'.format(time.time() - start_time))

    # if True, calculate shortest paths, eccentricity, and topological metrics
    # that use eccentricity
    if ecc:
        # precompute shortest paths between all nodes for eccentricity-based
        # stats
        start_time = time.time()
        sp = {source:dict(nx.single_source_dijkstra_path_length(G_strong, source, weight='length')) for source in G_strong.nodes()}

        log('Calculated shortest path lengths in {:,.2f} seconds'.format(time.time() - start_time))

        # eccentricity of a node v is the maximum distance from v to all other
        # nodes in G
        eccentricity = nx.eccentricity(G_strong, sp=sp)
        stats['eccentricity'] = eccentricity

        # diameter is the maximum eccentricity
        diameter = nx.diameter(G_strong, e=eccentricity)
        stats['diameter'] = diameter

        # radius is the minimum eccentricity
        radius = nx.radius(G_strong, e=eccentricity)
        stats['radius'] = radius

        # center is the set of nodes with eccentricity equal to radius
        center = nx.center(G_strong, e=eccentricity)
        stats['center'] = center

        # periphery is the set of nodes with eccentricity equal to the diameter
        periphery = nx.periphery(G_strong, e=eccentricity)
        stats['periphery'] = periphery

    # if True, calculate node closeness centrality
    if cc:
        # closeness centrality of a node is the reciprocal of the sum of the
        # shortest path distances from u to all other nodes
        start_time = time.time()
        closeness_centrality = nx.closeness_centrality(G, distance='length')
        stats['closeness_centrality'] = closeness_centrality
        stats['closeness_centrality_avg'] = sum(closeness_centrality.values())/len(closeness_centrality)
        log('Calculated closeness centrality in {:,.2f} seconds'.format(time.time() - start_time))

    # if True, calculate node betweenness centrality
    if bc:
        # betweenness centrality of a node is the sum of the fraction of
        # all-pairs shortest paths that pass through node
        start_time = time.time()
        betweenness_centrality = nx.betweenness_centrality(G, weight='length')
        stats['betweenness_centrality'] = betweenness_centrality
        stats['betweenness_centrality_avg'] = sum(betweenness_centrality.values())/len(betweenness_centrality)
        log('Calculated betweenness centrality in {:,.2f} seconds'.format(time.time() - start_time))

    log('Calculated extended stats in {:,.2f} seconds'.format(time.time()-full_start_time))
    return stats
 def test_center(self):
     assert_equal(set(networkx.center(self.G)),set([6, 7, 10, 11]))
Пример #54
0
rows and columns. We may also think of a submatrix as formed by deleting 
the remaining rows and columns from M.

Given: An inconsistent character table C on at most 100 taxa.

Return: A submatrix of C′ representing a consistent character table on 
the same taxa and formed by deleting a single row of C. 
(If multiple solutions exist, you may return any one.)
'''

import numpy as np
import networkx as nx

def reverse_symbol(a):
    return (a == 0).astype(int)
        
table = open('rosalind_cset.txt').read().split()
mat = np.array([list(i.rstrip()) for i in table], dtype=int)
n = len(table)

G = nx.Graph()
for i in range(n-1):
    for j in range(1, n):
        a = mat[i] + mat[j]
        b = mat[i] + reverse_symbol(mat[j])
        if 0 in a and 2 in a and 0 in b and 2 in b:
            G.add_edge(i, j)

table.pop(nx.center(G)[0])           
open('rosalind_cset_sub.txt', 'wt').write('\n'.join(table))
Пример #55
0
    def step(self, state):
        """
        Determine actions based on the current state of the city. Called every
        time step. This function must take less than Settings.STEP_TIMEOUT
        seconds.
        --- Parameters ---
        state : State
            The state of the game. See state.py for more information.
        --- Returns ---
        commands : dict list
            Each command should be generated via self.send_command or
            self.build_command. The commands are evaluated in order.
        """
        self.current_order_edges = set()
        graph = state.get_graph()
        commands = []
        if not self.has_built_station:
            station = max([node for node in nx.center(graph)], key=graph.degree)
            commands.append(self.build_command(station))
            self.stations.append(station)
            # this one can always be assumed to be built
            self.has_built_station = True

        # Check if new station was successfully built
        if self.new_station is not None and state.get_graph().node[self.new_station]["is_station"]:
            self.stations.append(self.new_station)
            self.new_station = None

        pending_orders = state.get_pending_orders()

        RATIO = 3
        if len(self.stations) < self.max_stations:
            if len(pending_orders) > sum([graph.degree(station) for station in self.stations]) / RATIO:
                # New station
                available_nodes = [node for node in graph.nodes() if node not in self.stations]
                order_nodes = [o.get_node() for o in pending_orders]

                def heuristic(n):
                    t = (graph.degree(n), min([nx.shortest_path_length(graph, n, s) for s in self.stations]))
                    # geometric mean of these two
                    # closest to orders
                    return (
                        -sum([nx.shortest_path_length(graph, n, order_node) for order_node in order_nodes]),
                        (t[0] * t[1]) ** (1 / 2),
                    )

                self.new_station = max(available_nodes, key=heuristic)
                commands.append(self.build_command(self.new_station))
                # do not use it yet, check next turn if it was built

        if len(pending_orders) > 0:
            # Choose orders to fulfill
            chosen_orders = sorted(pending_orders, key=lambda k: state.money_from(k))

            # Assign each order to closest station
            # Generate graph of free edges
            self.available_graph = state.get_graph()
            self.available_graph.remove_edges_from(
                [edge for edge in self.available_graph.edges() if self.available_graph.edge[edge[0]][edge[1]]["in_use"]]
            )
            for order in chosen_orders:
                key = lambda x: Player.shortest_from_station(graph, x, order.get_node())
                possible_stations = sorted(self.stations, key=key)
                # Check each station by order starting from closest
                for station in possible_stations:
                    if station is None:  # dummy, no path actually exists
                        continue
                    try:
                        paths = list(nx.all_shortest_paths(self.available_graph, station, order.get_node()))
                    except nx.NetworkXNoPath:
                        continue
                    # TODO: choose a good path, not just the first one in the list, closest to station/order is best?
                    found = False
                    for path in paths:
                        if self.path_is_valid(state, path):
                            commands.append(self.send_command(order, path))
                            self.current_order_edges |= set(path)
                            found = True
                            break
                    if found:
                        break
        return commands
Пример #56
0
def main ():
    """ main """
    global options, args, pg
    # TODO: Do something more interesting here...
    pg = nx.read_gml('/home/cyn/FFHS/NA-15-ZH/PVA3/power.gml')
    print("Exercise 3:\n---------------------------------------------------")
    print("Nodes: "), pg.number_of_nodes()
    print("Edges: "), pg.number_of_edges()
    graph_degree = pg.degree()
    print("Degree of Nodes: "), graph_degree
    
    print("\nExercise 4:\n---------------------------------------------------")
    average_degree(pg)
    print("Degree_histogram list: "), nx.degree_histogram(pg)
    export_histogram()
    
    print("\nExercise 5:\n---------------------------------------------------")
    max_degree = find_highest_degree(pg)
    print("Highest degree: "), max_degree
    print("Node/s with highest degree: "), \
        find_nodes_with_degree(pg,max_degree)
    cc = list(nx.connected_component_subgraphs(pg))
    print("Number of CC in the Power-Grid: "), len(cc)
    
    print("\nExercise 6:\n---------------------------------------------------")
    print("Diameter: "), nx.diameter(pg)
    print("Center: "), nx.center(pg)
    
    print("\nExercise 7:\n---------------------------------------------------")
    subnodes = list()
    
    for x in range(10, max_degree+1):
        if len(find_nodes_with_degree(pg,x)) != 0:
            subnodes.extend(find_nodes_with_degree(pg,x))            
    
    sg = pg.subgraph(subnodes)
    scc = list(nx.connected_component_subgraphs(sg))
    print("Number of CC in Subgraph: "), len(scc)   
    max_cc = 0
    largest_cc_id = 0    
    
    for x in range(0, len(scc)):
        if scc[x].number_of_nodes() > max_cc:
            max_cc = scc[x].number_of_nodes()
            largest_cc_id = x
    
    print("Largest component: "), max_cc
    nx.draw_spectral(scc[largest_cc_id])
    plt.savefig('/home/cyn/FFHS/NA-15-ZH/PVA3/largest_connected_component.png')
    plt.close()
    
    print("\nExercise 8:\n---------------------------------------------------")
    lg = make_largest_diameter_graph(10)
    average_degree(lg)
    print("Center: "), nx.center(lg)
    nx.draw_spectral(lg)
    plt.savefig('/home/cyn/FFHS/NA-15-ZH/PVA3/largest_diameter_10.png')
    plt.close()

    sdg = make_smallest_diameter_graph(10)
    average_degree(sdg)
    print("Center: "), nx.center(sdg)
    nx.draw_circular(sdg)
    plt.savefig('/home/cyn/FFHS/NA-15-ZH/PVA3/smallest_diameter_10.png')
    plt.close()
Пример #57
0
 def test_bound_center(self):
     assert_equal(set(networkx.center(self.G, usebounds=True)), set([6, 7, 10, 11]))
def find_optimal_tree_root(nx_tree_input):

    tree_root=nx.center(nx_tree_input)
    return tree_root[0]
Пример #59
0
    final_graph = {}
    client = pymongo.MongoClient()
    db = client.final
    for val in db.collection_names():
        final_graph[int(val)] = load_from_mongo('final', str(val))[0]['reciprocal_friends']
    final_graph[24551258] = intersection


    # Start creating the graph peice by peice.
    G=nx.from_dict_of_lists(final_graph)
    pos=nx.spring_layout(G) # positions for all nodes
    nx.draw_networkx_nodes(G,pos,node_size=3)
    nx.draw_networkx_edges(G,pos,width=1)
    nx.draw_networkx_labels(G,pos,font_size=2,font_family='sans-serif')
    plt.show()

    
    print("the number of nodes of the network is " + str(G.size()))
    print("The diameter of the network is: " + str(nx.diameter(G)))
    print("The average distance of the network is " + str(nx.center(G)))









def center(net):
    return setSize(nx.center(net,e=eccentricity_list(net)), net.number_of_nodes(),'center')