ó ,µ[c@sædZddlmZddlmZddlZddlmZddl TddgZ dd „Z d „Z d „Zd „Zdd „Zedd„Zedƒedƒd„ƒƒZd„Zd„Zd„Zdd„ZdS(s%Functions for generating line graphs.iÿÿÿÿ(t combinations(t defaultdictN(tarbitrary_element(t*t line_graphtinverse_line_graphcCs=|jƒr!t|d|ƒ}nt|dtd|ƒ}|S(sºReturns the line graph of the graph or digraph `G`. The line graph of a graph `G` has a node for each edge in `G` and an edge joining those nodes if the two edges in `G` share a common node. For directed graphs, nodes are adjacent exactly when the edges they represent form a directed path of length two. The nodes of the line graph are 2-tuples of nodes in the original graph (or 3-tuples for multigraphs, with the key of the edge as the third element). For information about self-loops and more discussion, see the **Notes** section below. Parameters ---------- G : graph A NetworkX Graph, DiGraph, MultiGraph, or MultiDigraph. create_using : NetworkX graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Returns ------- L : graph The line graph of G. Examples -------- >>> import networkx as nx >>> G = nx.star_graph(3) >>> L = nx.line_graph(G) >>> print(sorted(map(sorted, L.edges()))) # makes a 3-clique, K3 [[(0, 1), (0, 2)], [(0, 1), (0, 3)], [(0, 2), (0, 3)]] Notes ----- Graph, node, and edge data are not propagated to the new graph. For undirected graphs, the nodes in G must be sortable, otherwise the constructed line graph may not be correct. *Self-loops in undirected graphs* For an undirected graph `G` without multiple edges, each edge can be written as a set `\{u, v\}`. Its line graph `L` has the edges of `G` as its nodes. If `x` and `y` are two nodes in `L`, then `\{x, y\}` is an edge in `L` if and only if the intersection of `x` and `y` is nonempty. Thus, the set of all edges is determined by the set of all pairwise intersections of edges in `G`. Trivially, every edge in G would have a nonzero intersection with itself, and so every node in `L` should have a self-loop. This is not so interesting, and the original context of line graphs was with simple graphs, which had no self-loops or multiple edges. The line graph was also meant to be a simple graph and thus, self-loops in `L` are not part of the standard definition of a line graph. In a pairwise intersection matrix, this is analogous to excluding the diagonal entries from the line graph definition. Self-loops and multiple edges in `G` add nodes to `L` in a natural way, and do not require any fundamental changes to the definition. It might be argued that the self-loops we excluded before should now be included. However, the self-loops are still "trivial" in some sense and thus, are usually excluded. *Self-loops in directed graphs* For a directed graph `G` without multiple edges, each edge can be written as a tuple `(u, v)`. Its line graph `L` has the edges of `G` as its nodes. If `x` and `y` are two nodes in `L`, then `(x, y)` is an edge in `L` if and only if the tail of `x` matches the head of `y`, for example, if `x = (a, b)` and `y = (b, c)` for some vertices `a`, `b`, and `c` in `G`. Due to the directed nature of the edges, it is no longer the case that every edge in `G` should have a self-loop in `L`. Now, the only time self-loops arise is if a node in `G` itself has a self-loop. So such self-loops are no longer "trivial" but instead, represent essential features of the topology of `G`. For this reason, the historical development of line digraphs is such that self-loops are included. When the graph `G` has multiple edges, once again only superficial changes are required to the definition. References ---------- * Harary, Frank, and Norman, Robert Z., "Some properties of line digraphs", Rend. Circ. Mat. Palermo, II. Ser. 9 (1960), 161--168. * Hemminger, R. L.; Beineke, L. W. (1978), "Line graphs and line digraphs", in Beineke, L. W.; Wilson, R. J., Selected Topics in Graph Theory, Academic Press Inc., pp. 271--305. t create_usingt selfloops(t is_directedt _lg_directedt_lg_undirectedtFalse(tGRtL((s7lib/python2.7/site-packages/networkx/generators/line.pyRsZ cCs%|jƒrd„}n d„}|S(sÈReturns a function which returns a sorted node for line graphs. When constructing a line graph for undirected graphs, we must normalize the ordering of nodes as they appear in the edge. cSs&||kr|||fS|||fS(N((tutvtkey((s7lib/python2.7/site-packages/networkx/generators/line.pyt sorted_nodescSs ||kr||fS||fS(N((RR((s7lib/python2.7/site-packages/networkx/generators/line.pyR„s(t is_multigraph(R R((s7lib/python2.7/site-packages/networkx/generators/line.pyt _node_funcys   cs7ˆjƒr!d‡fd†}nd‡fd†}|S(sKReturns the edges from G, handling keys for multigraphs as necessary. csˆj|dtƒS(Ntkeys(tedgestTrue(tnbunch(R (s7lib/python2.7/site-packages/networkx/generators/line.pyt get_edgesŽscs ˆj|ƒS(N(R(R(R (s7lib/python2.7/site-packages/networkx/generators/line.pyR‘sN(RtNone(R R((R s7lib/python2.7/site-packages/networkx/generators/line.pyt _edge_func‰s cCs ||kr||fS||fS(sÃReturns a sorted edge. During the construction of a line graph for undirected graphs, the data structure can be a multigraph even though the line graph will never have multiple edges between its nodes. For this reason, we must make sure not to add any edge more than once. This requires that we build up a list of edges to add and then remove all duplicates. And so, we must normalize the representation of the edges. ((RR((s7lib/python2.7/site-packages/networkx/generators/line.pyt _sorted_edge–s cCswtjd|d|jƒ}t|ƒ}xI|ƒD]>}|j|ƒx(||dƒD]}|j||ƒqUWq1W|S(s5Return the line graph L of the (multi)digraph G. Edges in G appear as nodes in L, represented as tuples of the form (u,v) or (u,v,key) if G is a multidigraph. A node in L corresponding to the edge (u,v) is connected to every node corresponding to an edge (v,w). Parameters ---------- G : digraph A directed graph or directed multigraph. create_using : NetworkX graph constructor, optional Graph type to create. If graph instance, then cleared before populated. Default is to use the same graph class as `G`. itdefaulti(tnxt empty_grapht __class__Rtadd_nodetadd_edge(R RR Rt from_nodetto_node((s7lib/python2.7/site-packages/networkx/generators/line.pyR ¤s  cCs tjd|d|jƒ}t|ƒ}t|ƒ}|r?dnd}tgƒ}x§|D]Ÿ}g||ƒD]} || Œ^qk} t| ƒdkr©|j| dƒnxKt| ƒD]=\} } |j g| | |D]} t | | ƒ^q׃q¶WqXW|j |ƒ|S(sReturn the line graph L of the (multi)graph G. Edges in G appear as nodes in L, represented as sorted tuples of the form (u,v), or (u,v,key) if G is a multigraph. A node in L corresponding to the edge {u,v} is connected to every node corresponding to an edge that involves u or v. Parameters ---------- G : graph An undirected graph or multigraph. selfloops : bool If `True`, then self-loops are included in the line graph. If `False`, they are excluded. create_using : NetworkX graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Notes ----- The standard algorithm for line graphs of undirected graphs does not produce self-loops. iRi( RRRRRtsettlenR t enumeratetupdateRtadd_edges_from(R RRR RRtshiftRRtxtnodestitatb((s7lib/python2.7/site-packages/networkx/generators/line.pyR Âs    %9 tdirectedt multigraphc Cs‹|jƒdks$|jƒdkr<d}tj|ƒ‚nt|ƒ}t||ƒ}d„|jƒDƒ}x/|D]'}x|D]}||cd7$s iisEG is not a line graph (vertex found in more than two partition cells)(tnumber_of_edgestnumber_of_nodesRt NetworkXErrort_select_starting_cellt_find_partitionR+tmaxtvaluesttupletGraphtadd_nodes_fromRR%R$t intersectionR!( R tmsgt starting_celltPtP_counttpRtWtHR-R.((s7lib/python2.7/site-packages/networkx/generators/line.pyRös('$   2   "'cCs±|\}}||kr.tjd|ƒ‚n||j|ƒkr_tjd||fƒ‚ng}xE|j|ƒD]4}||j|ƒkru|j|||fƒququW|S(s/ Return list of all triangles containing edge esVertex %s not in graphsEdge (%s, %s) not in graph(RR4t neighborstappend(R teRRt triangle_listR*((s7lib/python2.7/site-packages/networkx/generators/line.pyt _triangles7s  cCsx6|D].}||jƒkrtjd|ƒ‚qqWx^tt|dƒƒD]G}|d|j|dƒkrOtjd|d|dfƒ‚qOqOWttƒ}xG|D]?}x6|j|ƒD]%}||krÃ||cd7t G_partitionR?tpartitioned_verticesRtdeg_utnew_cellRR=((s7lib/python2.7/site-packages/networkx/generators/line.pyR6ps&        !cCsØ|dkr'tt|jƒƒƒ}n:|}|d||dkrad}tj||ƒ‚nt||ƒ}t|ƒ}|dkr‘|}nC|dkre|d}|\}} } gt||| fƒD] } | ^qÌ} gt|| | fƒD] } | ^qô} t| ƒdkrLt| ƒdkr3|}qbt|d| | fƒSqÔt|d|| fƒSnod}g}x7|D]/}t ||ƒrx|d7}|j |ƒqxqxW|dkrÌ|dkrÌ|}n|d|koç|knr¿t gƒ}x,|D]$}x|D]} |j | ƒq WqÿWt|ƒ|dkr§xX|D]P}xG|D]?}||krQ||j |ƒkrQd}tj|ƒ‚qQqQWqDWt|ƒ}qÔd}tj|ƒ‚nd}tj|ƒ‚|S( s` Select a cell to initiate _find_partition Parameters ---------- G : NetworkX Graph starting_edge: an edge to build the starting cell from Returns ------- Tuple of vertices in G Raises ------ NetworkXError If it is determined that G is not a line graph Notes ----- If starting edge not specified then pick an arbitrary edge - doesn't matter which. However, this function may call itself requiring a specific starting edge. Note that the r, s notation for counting triangles is the same as in the Roussopoulos paper cited above. iis*starting_edge (%s, %s) is not in the Grapht starting_edgeisCG is not a line graph (odd triangles do not form complete subgraph)sNG is not a line graph (incorrect number of odd triangles around starting edge)N(RRRIRRR4RHR%R5RNRER$taddRDR9(R RVRFR=t e_trianglestrR>RKR-R.tcR*tac_edgestbc_edgestst odd_trianglesttriangle_nodesRR((s7lib/python2.7/site-packages/networkx/generators/line.pyR5ŸsZ      ((          !(t__doc__t itertoolsRt collectionsRtnetworkxRtnetworkx.utilsRtnetworkx.utils.decoratorst__all__RRRRRR R R tnot_implemented_forRRHRNR6R5(((s7lib/python2.7/site-packages/networkx/generators/line.pyt s$    a   4 @  + /