h}7HSrSSKJr SSKrSSKJrJr /SQr\RS5r \RS5r S r S r S r\RSS j5r\RSS j5r\RSSj5r\"S5\R"SS9S55rg)z Eulerian circuits and graphs. ) combinationsN)arbitrary_elementnot_implemented_for) is_eulerianeulerian_circuiteulerizeis_semieulerianhas_eulerian_path eulerian_pathc ^TR5(a2[U4SjT55=(a [R"T5$[STR 555=(a [R "T5$)aReturns True if and only if `G` is Eulerian. A graph is *Eulerian* if it has an Eulerian circuit. An *Eulerian circuit* is a closed walk that includes each edge of a graph exactly once. Graphs with isolated vertices (i.e. vertices with zero degree) are not considered to have Eulerian circuits. Therefore, if the graph is not connected (or not strongly connected, for directed graphs), this function returns False. Parameters ---------- G : NetworkX graph A graph, either directed or undirected. Examples -------- >>> nx.is_eulerian(nx.DiGraph({0: [3], 1: [2], 2: [3], 3: [0, 1]})) True >>> nx.is_eulerian(nx.complete_graph(5)) True >>> nx.is_eulerian(nx.petersen_graph()) False If you prefer to allow graphs with isolated vertices to have Eulerian circuits, you can first remove such vertices and then call `is_eulerian` as below example shows. >>> G = nx.Graph([(0, 1), (1, 2), (0, 2)]) >>> G.add_node(3) >>> nx.is_eulerian(G) False >>> G.remove_nodes_from(list(nx.isolates(G))) >>> nx.is_eulerian(G) True c3j># UH(nTRU5TRU5:Hv M* g7fN in_degree out_degree).0nGs K/var/www/html/env/lib/python3.13/site-packages/networkx/algorithms/euler.py is_eulerian..As) 78!AKKNall1o -qs03c36# UHupUS-S:Hv M g7f)rrNrvds rrrFs1jdaq1uzj) is_directedallnxis_strongly_connecteddegree is_connectedrs`rrrsgR }} 78  *&&q) * 1ahhj1 1 Hbooa6HHcF[U5=(a [U5(+$)zReturn True iff `G` is semi-Eulerian. G is semi-Eulerian if it has an Eulerian path but no Eulerian circuit. See Also -------- has_eulerian_path is_eulerian )r rr%s rr r Is Q  6 A$66r&c`^[T5(dg[T5(a [T5$TR5(a6U4SjT5upTR U5TR U5:aU$U$TVs/sHnTR U5S-S:wdMUPM! snSnU$s snf)zYReturn a suitable starting vertex for an Eulerian path. If no path exists, return None. Nc3t># UH-nTRU5TRU5:wdM)Uv M/ g7frr)rrrs rr#_find_path_start..cs*DQ!++a.ALLO"C!!Qs(8 8rr)r rrrrrr#)rv1v2rstarts` r_find_path_startr.Ws Q  1~~ ##}}DQD << akk"o -II6Aq!qA!5A6q9 7s =B+B+c## UR5(aURnURnOURnURnU/nSnU(akUSnU"U5S:XaUbXV4v UnUR 5 O5[ U"U55upxURU5 URXh5 U(aMjgg7f)Nr rr out_edgesr#edgespoprappend remove_edge) rsourcer#r3 vertex_stack last_vertexcurrent_vertex_ next_vertexs r_simplegraph_eulerian_circuitr=ps}} 8LK %b) . !Q &&"33(K    .u^/DENA    , MM. 6 ,s B;C?Cc## UR5(aURnURnOURnURnUS4/nSnSnU(arUSupxU"U5S:XaUbXWU4v XxpeUR 5 O9[ U"USS95n U upn URX45 URX{U 5 U(aMqgg7f)Nr0rT)keysr1) rr7r#r3r8r9last_keyr: current_keytripler;r<next_keys r_multigraph_eulerian_circuitrDs}} TN#LKH &22&6# . !Q &&"H==$2    &u^$'GHF'- $AH    7 8 MM.x @ ,s CC  C c## [U5(d[R"S5eUR5(aUR 5nOUR 5nUc [ U5nUR5(a*[X5Hup4nU(aX4U4v MX44v M g[X5ShvN gN7f)azReturns an iterator over the edges of an Eulerian circuit in `G`. An *Eulerian circuit* is a closed walk that includes each edge of a graph exactly once. Parameters ---------- G : NetworkX graph A graph, either directed or undirected. source : node, optional Starting node for circuit. keys : bool If False, edges generated by this function will be of the form ``(u, v)``. Otherwise, edges will be of the form ``(u, v, k)``. This option is ignored unless `G` is a multigraph. Returns ------- edges : iterator An iterator over edges in the Eulerian circuit. Raises ------ NetworkXError If the graph is not Eulerian. See Also -------- is_eulerian Notes ----- This is a linear time implementation of an algorithm adapted from [1]_. For general information about Euler tours, see [2]_. References ---------- .. [1] J. Edmonds, E. L. Johnson. Matching, Euler tours and the Chinese postman. Mathematical programming, Volume 5, Issue 1 (1973), 111-114. .. [2] https://en.wikipedia.org/wiki/Eulerian_path Examples -------- To get an Eulerian circuit in an undirected graph:: >>> G = nx.complete_graph(3) >>> list(nx.eulerian_circuit(G)) [(0, 2), (2, 1), (1, 0)] >>> list(nx.eulerian_circuit(G, source=1)) [(1, 2), (2, 0), (0, 1)] To get the sequence of vertices in an Eulerian circuit:: >>> [u for u, v in nx.eulerian_circuit(G)] [0, 2, 1] zG is not Eulerian.N) rr! NetworkXErrorrreversecopyr is_multigraphrDr=rr7r?urks rrrs~ q>>344}} IIK FFH ~"1%3A>GA!Ag d ? 1;;;sB8C:C;CcH[R"U5(agUR5(aURnURnUbX1X!- S:wagSnSnUH7nX&X6- S:XaUS- nMX6X&- S:XaUS- nM+X&X6:wdM7 g US:*=(a" US:*=(a [R "U5$UbUR US-S:wag[SUR 555S:H=(a [R"U5$)aReturn True iff `G` has an Eulerian path. An Eulerian path is a path in a graph which uses each edge of a graph exactly once. If `source` is specified, then this function checks whether an Eulerian path that starts at node `source` exists. A directed graph has an Eulerian path iff: - at most one vertex has out_degree - in_degree = 1, - at most one vertex has in_degree - out_degree = 1, - every other vertex has equal in_degree and out_degree, - and all of its vertices belong to a single connected component of the underlying undirected graph. If `source` is not None, an Eulerian path starting at `source` exists if no other node has out_degree - in_degree = 1. This is equivalent to either there exists an Eulerian circuit or `source` has out_degree - in_degree = 1 and the conditions above hold. An undirected graph has an Eulerian path iff: - exactly zero or two vertices have odd degree, - and all of its vertices belong to a single connected component. If `source` is not None, an Eulerian path starting at `source` exists if either there exists an Eulerian circuit or `source` has an odd degree and the conditions above hold. Graphs with isolated vertices (i.e. vertices with zero degree) are not considered to have an Eulerian path. Therefore, if the graph is not connected (or not strongly connected, for directed graphs), this function returns False. Parameters ---------- G : NetworkX Graph The graph to find an euler path in. source : node, optional Starting node for path. Returns ------- Bool : True if G has an Eulerian path. Examples -------- If you prefer to allow graphs with isolated vertices to have Eulerian path, you can first remove such vertices and then call `has_eulerian_path` as below example shows. >>> G = nx.Graph([(0, 1), (1, 2), (0, 2)]) >>> G.add_node(3) >>> nx.has_eulerian_path(G) False >>> G.remove_nodes_from(list(nx.isolates(G))) >>> nx.has_eulerian_path(G) True See Also -------- is_eulerian eulerian_path TFrrc36# UHupUS-S:Hv M g7f)rrNNrrs rr$has_eulerian_path..Ks5*$!1q5A:*r) r!rrrris_weakly_connectedr#sumr$)rr7insoutsunbalanced_insunbalanced_outsrs rr r s~ ~~a}}kk||  $,"<"AAv1$!#36!Q&1$47"  a  VOq$8 VR=S=STU=V  !((6"2Q"6!";5!((*55:Qrq?QQr&c #~# [X5(d[R"S5eUR5(aUR 5nUb[R "U5SLa [ U5nUR5(a*[X5Hup4nU(aX4U4v MX44v M g[X5ShvN gUR5nUc [ U5nUR5(asU(a6[[X5VVVs/sH up4oTX54PM snnn5ShvN g[[X5VVVs/sH up4oTU4PM snnn5ShvN g[[X5VVs/sHup4XC4PM snn5ShvN gNs snnnfNws snnnfNJs snnfN7f)aGReturn an iterator over the edges of an Eulerian path in `G`. Parameters ---------- G : NetworkX Graph The graph in which to look for an eulerian path. source : node or None (default: None) The node at which to start the search. None means search over all starting nodes. keys : Bool (default: False) Indicates whether to yield edge 3-tuples (u, v, edge_key). The default yields edge 2-tuples Yields ------ Edge tuples along the eulerian path. Warning: If `source` provided is not the start node of an Euler path will raise error even if an Euler Path exists. zGraph has no Eulerian paths.NF) r r!rFrrGrr.rIrDr=rHreversedrJs rr r Ns, Q ' '=>>}} IIK >R^^A.%7%a(F ??  7Ba'M$J C 5Q? ? ? FFH >%a(F ??  #.J1.UV.U71Y.UV$+G+RS+RaV+RS $A!$LM$LDA!$LM   @W T N smCF=F!AF=F# & F=2F*3F= F,  F=(F3)F=F5  F=F;F=#F=,F=5F=directedT) returns_graphc UR5S:Xa[R"S5e[R"U5(d[R"S5eUR 5VVs/sHupUS-S:XdMUPM nnn[R "U5n[U5S:XaU$[US5VVs/sHupAXA[R"XUS904PM nnn[U5S-n[R"5nUHBupUR5H)upIX:wdM URXAU[U 5- U S9 M+ MD [R"[[R"U555n U R5H=upAXtUSn UR![R"R%U 55 M? U$s snnfs snnf) a@Transforms a graph into an Eulerian graph. If `G` is Eulerian the result is `G` as a MultiGraph, otherwise the result is a smallest (in terms of the number of edges) multigraph whose underlying simple graph is `G`. Parameters ---------- G : NetworkX graph An undirected graph Returns ------- G : NetworkX multigraph Raises ------ NetworkXError If the graph is not connected. See Also -------- is_eulerian eulerian_circuit References ---------- .. [1] J. Edmonds, E. L. Johnson. Matching, Euler tours and the Chinese postman. Mathematical programming, Volume 5, Issue 1 (1973), 111-114. .. [2] https://en.wikipedia.org/wiki/Eulerian_path .. [3] http://web.math.princeton.edu/math_alive/5/Notes1.pdf Examples -------- >>> G = nx.complete_graph(10) >>> H = nx.eulerize(G) >>> nx.is_eulerian(H) True rzCannot Eulerize null graphzG is not connectedrrN)r7target)weightpathr^)orderr!NetworkXPointlessConceptr$rFr# MultiGraphlenr shortest_pathGraphitemsadd_edgelistmax_weight_matchingr3add_edges_fromutilspairwise) rrrodd_degree_nodesmodd_deg_pairs_pathsupper_bound_on_max_path_lengthGpPsP best_matchingr^s rr r sV wwyA~))*FGG ??1  344&'hhj?jdaAEQJj? aA ! !!1155DA   Q7 895&)VaZ" B$HHJDAv !?#a&!Hq%HHT""8"8"<=>M##%uQx **401& HE@ s/GG$G)NFr)__doc__ itertoolsrnetworkxr!rjrr__all__ _dispatchablerr r.r=rDrr r r rr&rrys#: 0I0If 7 727,A0M<M<`[R[R|33lZ %O &!O r&