a 1bL@sdZddlZddlZddlmZddlZddlmZm Z gdZ eddgdddZ e d dd d Z dd d Z dddZdddZe d d ddZe d d!ddZe d d"ddZddZdS)#z0 Generators and functions for bipartite graphs. N)reduce)nodes_or_numberpy_random_state)configuration_modelhavel_hakimi_graphreverse_havel_hakimi_graphalternating_havel_hakimi_graphpreferential_attachment_graph random_graphgnmk_random_graphcomplete_bipartite_graphcstd|}|rtd\}|\}t|tjrLfddD|j|dd|jdd|fdd|Dd d |d |j d <|S) a)Returns the complete bipartite graph `K_{n_1,n_2}`. The graph is composed of two partitions with nodes 0 to (n1 - 1) in the first and nodes n1 to (n1 + n2 - 1) in the second. Each node in the first is connected to each node in the second. Parameters ---------- n1 : integer Number of nodes for node set A. n2 : integer Number of nodes for node set B. create_using : NetworkX graph instance, optional Return graph of this type. Notes ----- Node labels are the integers 0 to `n_1 + n_2 - 1`. The nodes are assigned the attribute 'bipartite' with the value 0 or 1 to indicate which bipartite set the node belongs to. This function is not imported in the main namespace. To use it use nx.bipartite.complete_bipartite_graph rDirected Graph not supportedcsg|] }|qSr.0i)n1rGlib/python3.9/site-packages/networkx/algorithms/bipartite/generators.py 8z,complete_bipartite_graph.. bipartiter c3s |]}D]}||fVq qdSNr)ruv)bottomrr ;rz+complete_bipartite_graph..zcomplete_bipartite_graph(,)name) nx empty_graph is_directed NetworkXError isinstancenumbersZIntegraladd_nodes_fromadd_edges_fromZgraph)rZn2 create_usingGtopr)rrrr s   r c stjd|tjd}|r$tdtt}t}t}||ksbtd|d|t||}tdkstdkr|Sfddt dD}dd|Dfd dt |D}d d|D| | | fd d t |Dd |_ |S)aReturns a random bipartite graph from two given degree sequences. Parameters ---------- aseq : list Degree sequence for node set A. bseq : list Degree sequence for node set B. create_using : NetworkX graph instance, optional Return graph of this type. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. The graph is composed of two partitions. Set A has nodes 0 to (len(aseq) - 1) and set B has nodes len(aseq) to (len(bseq) - 1). Nodes from set A are connected to nodes in set B by choosing randomly from the possible free stubs, one in A and one in B. Notes ----- The sum of the two sequences must be equal: sum(aseq)=sum(bseq) If no graph type is specified use MultiGraph with parallel edges. If you want a graph with no parallel edges use create_using=Graph() but then the resulting degree sequences might not be exact. The nodes are assigned the attribute 'bipartite' with the value 0 or 1 to indicate which bipartite set the node belongs to. This function is not imported in the main namespace. To use it use nx.bipartite.configuration_model rdefaultr/invalid degree sequences, sum(aseq)!=sum(bseq),rcsg|]}|g|qSrrrraseqrrrwrz'configuration_model..cSsg|]}|D]}|q qSrrrZsubseqxrrrrxrcsg|]}|g|qSrrr0bseqlenarrrzrcSsg|]}|D]}|q qSrrr3rrrr{rc3s|]}||gVqdSrrr)astubsbstubsrrrrz&configuration_model..Zbipartite_configuration_model) r!r" MultiGraphr#r$lensum_add_nodes_with_bipartite_labelmaxrangeZshuffler(r ) r2r6r)seedr*lenbsumasumbstubsr)r2r8r6r9r7rr@s."    rc sHtjd|tjd}|r$tdtt}t}t}||ksbtd|d|t||}tdkstdkr|Sfddt dD}fddt |D}| |r>| \} } | dkrq>| || d D]>} | d } | | | | dd 8<| ddkr| | qqd |_|S) aReturns a bipartite graph from two given degree sequences using a Havel-Hakimi style construction. The graph is composed of two partitions. Set A has nodes 0 to (len(aseq) - 1) and set B has nodes len(aseq) to (len(bseq) - 1). Nodes from the set A are connected to nodes in the set B by connecting the highest degree nodes in set A to the highest degree nodes in set B until all stubs are connected. Parameters ---------- aseq : list Degree sequence for node set A. bseq : list Degree sequence for node set B. create_using : NetworkX graph instance, optional Return graph of this type. Notes ----- The sum of the two sequences must be equal: sum(aseq)=sum(bseq) If no graph type is specified use MultiGraph with parallel edges. If you want a graph with no parallel edges use create_using=Graph() but then the resulting degree sequences might not be exact. The nodes are assigned the attribute 'bipartite' with the value 0 or 1 to indicate which bipartite set the node belongs to. This function is not imported in the main namespace. To use it use nx.bipartite.havel_hakimi_graph rr-rr/rcsg|]}||gqSrrr0r1rrrrz&havel_hakimi_graph..csg|]}||gqSrrr0r6naseqrrrrNr Zbipartite_havel_hakimi_graphr!r"r:r#r$r;r<r=r>r?sortpopadd_edgeremover ) r2r6r)r*nbseqrBrCr8r9degreertargetrrr2r6rFrrs<      rc sFtjd|tjd}|r$tdtt}t}t}||ksbtd|d|t||}tdkstdkr|Sfddt dD}fddt |D}| | |r<| \} } | dkrq<|d| D]>} | d } | | | | dd 8<| ddkr| | qqd |_|S) aReturns a bipartite graph from two given degree sequences using a Havel-Hakimi style construction. The graph is composed of two partitions. Set A has nodes 0 to (len(aseq) - 1) and set B has nodes len(aseq) to (len(bseq) - 1). Nodes from set A are connected to nodes in the set B by connecting the highest degree nodes in set A to the lowest degree nodes in set B until all stubs are connected. Parameters ---------- aseq : list Degree sequence for node set A. bseq : list Degree sequence for node set B. create_using : NetworkX graph instance, optional Return graph of this type. Notes ----- The sum of the two sequences must be equal: sum(aseq)=sum(bseq) If no graph type is specified use MultiGraph with parallel edges. If you want a graph with no parallel edges use create_using=Graph() but then the resulting degree sequences might not be exact. The nodes are assigned the attribute 'bipartite' with the value 0 or 1 to indicate which bipartite set the node belongs to. This function is not imported in the main namespace. To use it use nx.bipartite.reverse_havel_hakimi_graph rr-rr/rcsg|]}||gqSrrr0r1rrrrz.reverse_havel_hakimi_graph..csg|]}||gqSrrr0r5rrrrr Z$bipartite_reverse_havel_hakimi_graphrG) r2r6r)r*rArBrCr8r9rMrrNrr)r2r6r7rrs<      rcstjd|tjd}|r$tdtt}t}t}||ksbtd|d|t||}tdkstdkr|Sfddt dD}fddt |D}|r| | \} } | dkrq| |d| d } || | d d } d dt | | D} t| t| t| krP| | | D]B}|d }|| ||dd 8<|ddkrT||qTqd |_|S)aReturns a bipartite graph from two given degree sequences using an alternating Havel-Hakimi style construction. The graph is composed of two partitions. Set A has nodes 0 to (len(aseq) - 1) and set B has nodes len(aseq) to (len(bseq) - 1). Nodes from the set A are connected to nodes in the set B by connecting the highest degree nodes in set A to alternatively the highest and the lowest degree nodes in set B until all stubs are connected. Parameters ---------- aseq : list Degree sequence for node set A. bseq : list Degree sequence for node set B. create_using : NetworkX graph instance, optional Return graph of this type. Notes ----- The sum of the two sequences must be equal: sum(aseq)=sum(bseq) If no graph type is specified use MultiGraph with parallel edges. If you want a graph with no parallel edges use create_using=Graph() but then the resulting degree sequences might not be exact. The nodes are assigned the attribute 'bipartite' with the value 0 or 1 to indicate which bipartite set the node belongs to. This function is not imported in the main namespace. To use it use nx.bipartite.alternating_havel_hakimi_graph rr-rr/rcsg|]}||gqSrrr0r1rrrOrz2alternating_havel_hakimi_graph..csg|]}||gqSrrr0rErrrPrNcSsg|]}|D]}|q qSrr)rzr4rrrrYrr Z(bipartite_alternating_havel_hakimi_graph)r!r"r:r#r$r;r<r=r>r?rHrIzipappendrJrKr )r2r6r)r*rLrBrCr8r9rMrZsmallZlargerDrNrrrOrrsF!    rc s:tjd|tjdr$td|dkr>td|dt}t|dfddtd|D}|r0|dr |dd}|d|| |kst|krt}j |dd  ||qpfd dt|tD}t d d |} | | }j |dd  ||qp||dqjd _S)a^Create a bipartite graph with a preferential attachment model from a given single degree sequence. The graph is composed of two partitions. Set A has nodes 0 to (len(aseq) - 1) and set B has nodes starting with node len(aseq). The number of nodes in set B is random. Parameters ---------- aseq : list Degree sequence for node set A. p : float Probability that a new bottom node is added. create_using : NetworkX graph instance, optional Return graph of this type. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. References ---------- .. [1] Guillaume, J.L. and Latapy, M., Bipartite graphs as models of complex networks. Physica A: Statistical Mechanics and its Applications, 2006, 371(2), pp.795-813. .. [2] Jean-Loup Guillaume and Matthieu Latapy, Bipartite structure of all complex networks, Inf. Process. Lett. 90, 2004, pg. 215-221 https://doi.org/10.1016/j.ipl.2004.03.007 Notes ----- The nodes are assigned the attribute 'bipartite' with the value 0 or 1 to indicate which bipartite set the node belongs to. This function is not imported in the main namespace. To use it use nx.bipartite.preferential_attachment_graph rr-rr z probability z > 1csg|]}|g|qSrrr0r1rrrrz1preferential_attachment_graph..rcsg|]}|g|qSr)rM)rb)r*rrrrcSs||Srr)r4yrrrrz/preferential_attachment_graph..Z'bipartite_preferential_attachment_model)r!r"r:r#r$r;r=r?rKrandomZadd_noderJrchoicer ) r2pr)r@rFZvvsourcerNZbbZbbstubsr)r*r2rr gs0(     r Fc Cs`t}t|||}|r"t|}d|d|d|d|_|dkrH|S|dkr\t||Std|}d}d}||krtd|} |dt | |}||kr||kr||}|d}q||krr| |||qr|r\d}d}||kr\td|} |dt | |}||krB||krB||}|d}q||kr| |||q|S)uoReturns a bipartite random graph. This is a bipartite version of the binomial (Erdős-Rényi) graph. The graph is composed of two partitions. Set A has nodes 0 to (n - 1) and set B has nodes n to (n + m - 1). Parameters ---------- n : int The number of nodes in the first bipartite set. m : int The number of nodes in the second bipartite set. p : float Probability for edge creation. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. directed : bool, optional (default=False) If True return a directed graph Notes ----- The bipartite random graph algorithm chooses each of the n*m (undirected) or 2*nm (directed) possible edges with probability p. This algorithm is $O(n+m)$ where $m$ is the expected number of edges. The nodes are assigned the attribute 'bipartite' with the value 0 or 1 to indicate which bipartite set the node belongs to. This function is not imported in the main namespace. To use it use nx.bipartite.random_graph See Also -------- gnp_random_graph, configuration_model References ---------- .. [1] Vladimir Batagelj and Ulrik Brandes, "Efficient generation of large random networks", Phys. Rev. E, 71, 036113, 2005. zfast_gnp_random_graph(rrrr g?) r!Graphr=DiGraphr r mathlogrWintrJ) nmrYr@directedr*ZlprwZlrrrrr s@-      r c Cst}t|||}|r"t|}d|d|d|d|_|dksL|dkrP|S||}||krptj|||dSdd|jdd D}tt|t|}d } | |kr| |} | |} | || vrqq| | | | d7} q|S) aReturns a random bipartite graph G_{n,m,k}. Produces a bipartite graph chosen randomly out of the set of all graphs with n top nodes, m bottom nodes, and k edges. The graph is composed of two sets of nodes. Set A has nodes 0 to (n - 1) and set B has nodes n to (n + m - 1). Parameters ---------- n : int The number of nodes in the first bipartite set. m : int The number of nodes in the second bipartite set. k : int The number of edges seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. directed : bool, optional (default=False) If True return a directed graph Examples -------- from nx.algorithms import bipartite G = bipartite.gnmk_random_graph(10,20,50) See Also -------- gnm_random_graph Notes ----- If k > m * n then a complete bipartite graph is returned. This graph is a bipartite version of the `G_{nm}` random graph model. The nodes are assigned the attribute 'bipartite' with the value 0 or 1 to indicate which bipartite set the node belongs to. This function is not imported in the main namespace. To use it use nx.bipartite.gnmk_random_graph zbipartite_gnm_random_graph(rrr )r)cSs g|]\}}|ddkr|qS)rrr)rradrrrr;rz%gnmk_random_graph..T)datar) r!r\r=r]r r ZnodeslistsetrXrJ) rarbkr@rcr*Z max_edgesr+rZ edge_countrrrrrr s*,       r cCsd|td||tttd|dg|}|ttt|||dg|t||d|S)Nrr r)r'r?dictrRupdater!Zset_node_attributes)r*r7rArTrrrr=Js $r=)N)NN)N)N)N)NN)NF)NF)__doc__r^r& functoolsrZnetworkxr!Znetworkx.utilsrr__all__r rrrrr r r r=rrrrs(   ) F J I M F U E