+ jU Rt^RIt^RIHt.ROt]P !RR7RRl4t]P !RR7RRl4t]!R4]!R4]P !RR7R RR R R R RR/Rl444t ]!R4]!R4]P !RR7RRl444t ]!R4]!R4]P !RR7RRl444t RRlt R#)a{Laplacian matrix of graphs. All calculations here are done using the out-degree. For Laplacians using in-degree, use `G.reverse(copy=False)` instead of `G` and take the transpose. The `laplacian_matrix` function provides an unnormalized matrix, while `normalized_laplacian_matrix`, `directed_laplacian_matrix`, and `directed_combinatorial_laplacian_matrix` are all normalized. N)not_implemented_forweight) edge_attrsc^RIpVf \V4p\P!WVRR7pVPwrVVP P VP^R7^3We3R7P4pWt, #)u Returns the Laplacian matrix of G. The graph Laplacian is the matrix L = D - A, where A is the adjacency matrix and D is the diagonal matrix of node degrees. Parameters ---------- G : graph A NetworkX graph nodelist : list, optional The rows and columns are ordered according to the nodes in nodelist. If nodelist is None, then the ordering is produced by G.nodes(). weight : string or None, optional (default='weight') The edge data key used to compute each value in the matrix. If None, then each edge has weight 1. Returns ------- L : SciPy sparse array The Laplacian matrix of G. Notes ----- For MultiGraph, the edges weights are summed. This returns an unnormalized matrix. For a normalized output, use `normalized_laplacian_matrix`, `directed_laplacian_matrix`, or `directed_combinatorial_laplacian_matrix`. This calculation uses the out-degree of the graph `G`. To use the in-degree for calculations instead, use `G.reverse(copy=False)` and take the transpose. See Also -------- :func:`~networkx.convert_matrix.to_numpy_array` normalized_laplacian_matrix directed_laplacian_matrix directed_combinatorial_laplacian_matrix :func:`~networkx.linalg.spectrum.laplacian_spectrum` Examples -------- For graphs with multiple connected components, L is permutation-similar to a block diagonal matrix where each block is the respective Laplacian matrix for each component. >>> G = nx.Graph([(1, 2), (2, 3), (4, 5)]) >>> print(nx.laplacian_matrix(G).toarray()) [[ 1 -1 0 0 0] [-1 2 -1 0 0] [ 0 -1 1 0 0] [ 0 0 0 1 -1] [ 0 0 0 -1 1]] >>> edges = [ ... (1, 2), ... (2, 1), ... (2, 4), ... (4, 3), ... (3, 4), ... ] >>> DiG = nx.DiGraph(edges) >>> print(nx.laplacian_matrix(DiG).toarray()) [[ 1 -1 0 0] [-1 2 -1 0] [ 0 0 1 -1] [ 0 0 -1 1]] Notice that node 4 is represented by the third column and row. This is because by default the row/column order is the order of `G.nodes` (i.e. the node added order -- in the edgelist, 4 first appears in (2, 4), before node 3 in edge (4, 3).) To control the node order of the matrix, use the `nodelist` argument. >>> print(nx.laplacian_matrix(DiG, nodelist=[1, 2, 3, 4]).toarray()) [[ 1 -1 0 0] [-1 2 0 -1] [ 0 0 1 -1] [ 0 0 -1 1]] This calculation uses the out-degree of the graph `G`. To use the in-degree for calculations instead, use `G.reverse(copy=False)` and take the transpose. >>> print(nx.laplacian_matrix(DiG.reverse(copy=False)).toarray().T) [[ 1 -1 0 0] [-1 1 -1 0] [ 0 0 2 -1] [ 0 0 -1 1]] References ---------- .. [1] Langville, Amy N., and Carl D. Meyer. Google’s PageRank and Beyond: The Science of Search Engine Rankings. Princeton University Press, 2006. Ncsrnodelistrformataxisshape) scipylistnxto_scipy_sparse_arrayr sparse dia_arraysumtocsr)GrrspAnmDs&&& `/home/luca/screen-checking/.venv/lib/python3.14/site-packages/networkx/linalg/laplacianmatrix.pylaplacian_matrixrspH7   fUSA 77DA QUUU]A.qf=CCEA 5LcL^RIp^RIpVf \V4p\P!WVRR7pVP wrgVP ^R7pVPPV^3Wf3R7P4p W, p VPRR7;_uu_4RVPV4, p RRR4^X VPV 4&VPPV ^3Wf3R7P4p WV ,,# +'giLa;i) u Returns the normalized Laplacian matrix of G. The normalized graph Laplacian is the matrix .. math:: N = D^{-1/2} L D^{-1/2} where `L` is the graph Laplacian and `D` is the diagonal matrix of node degrees [1]_. Parameters ---------- G : graph A NetworkX graph nodelist : list, optional The rows and columns are ordered according to the nodes in nodelist. If nodelist is None, then the ordering is produced by G.nodes(). weight : string or None, optional (default='weight') The edge data key used to compute each value in the matrix. If None, then each edge has weight 1. Returns ------- N : SciPy sparse array The normalized Laplacian matrix of G. Notes ----- For MultiGraph, the edges weights are summed. See :func:`to_numpy_array` for other options. If the Graph contains selfloops, D is defined as ``diag(sum(A, 1))``, where A is the adjacency matrix [2]_. This calculation uses the out-degree of the graph `G`. To use the in-degree for calculations instead, use `G.reverse(copy=False)` and take the transpose. For an unnormalized output, use `laplacian_matrix`. Examples -------- >>> import numpy as np >>> edges = [ ... (1, 2), ... (2, 1), ... (2, 4), ... (4, 3), ... (3, 4), ... ] >>> DiG = nx.DiGraph(edges) >>> print(nx.normalized_laplacian_matrix(DiG).toarray()) [[ 1. -0.70710678 0. 0. ] [-0.70710678 1. -0.70710678 0. ] [ 0. 0. 1. -1. ] [ 0. 0. -1. 1. ]] Notice that node 4 is represented by the third column and row. This is because by default the row/column order is the order of `G.nodes` (i.e. the node added order -- in the edgelist, 4 first appears in (2, 4), before node 3 in edge (4, 3).) To control the node order of the matrix, use the `nodelist` argument. >>> print(nx.normalized_laplacian_matrix(DiG, nodelist=[1, 2, 3, 4]).toarray()) [[ 1. -0.70710678 0. 0. ] [-0.70710678 1. 0. -0.70710678] [ 0. 0. 1. -1. ] [ 0. 0. -1. 1. ]] >>> G = nx.Graph(edges) >>> print(nx.normalized_laplacian_matrix(G).toarray()) [[ 1. -0.70710678 0. 0. ] [-0.70710678 1. -0.5 0. ] [ 0. -0.5 1. -0.70710678] [ 0. 0. -0.70710678 1. ]] See Also -------- laplacian_matrix normalized_laplacian_spectrum directed_laplacian_matrix directed_combinatorial_laplacian_matrix References ---------- .. [1] Fan Chung-Graham, Spectral Graph Theory, CBMS Regional Conference Series in Mathematics, Number 92, 1997. .. [2] Steve Butler, Interlacing For Weighted Graphs Using The Normalized Laplacian, Electronic Journal of Linear Algebra, Volume 16, pp. 90-98, March 2007. .. [3] Langville, Amy N., and Carl D. Meyer. Google’s PageRank and Beyond: The Science of Search Engine Rankings. Princeton University Press, 2006. Nrrr r ignoredivide?) numpyrrrrr rrrrerrstatesqrtisinf) rrrnprrr_diagsrL diags_sqrtDHs &&& rnormalized_laplacian_matrixr.sB7   fUSA 77DA EEqEME UAJqf5;;=A A H % %2775>)  &'(Jrxx #$   j!_QF  ; A A CB R= & %s !D D# multigraph undirectedr normalizedFqg?c^RIHp^RIp^RIpVf \ V4p\ V4p\ V4U U u/uFwrWbK p p p ^Tu;8:dR8:gM\R4h^VP,V,p V!\4p V!\4p^VPRV ,4R VPRV ,4^^/pVPV^R7Fwpp pVV 9gW9dKV V,W,ppV VV3;;,^, uu&V VV3;;,^,uu&VVV3;;,RV,, uu&VVV3;;,RV,, uu&K ...pppVP4EF"wpp VV 9gW9dKV V,W,ppVV8wgK0V VV3,^8Xd?VPV4VPV4VPVVV3,4K~VPV4VPV4VPVVV3,WVV3,,,4VPV4VPV4VPVVV3,WVV3,,,4EK% VPPVVV33W3\ R7pVP#V4P%^R7P'4pV'dVP)R R 7;_uu_4R VP+V4, pRRR4^XVP-V4&VPP/V^3W3R 7P14pVVV,,pVP3V4pVPP/V^3W3\ R7P14pVV, #uup p i +'giL;i)u Returns the magnetic Laplacian matrix of DiGraph G. The magnetic Laplacian matrix (also called the q-magnetic Laplacian) is a Hermitian matrix for directed graphs that encodes edge directionality via complex phases [1]_. Given a weighted directed graph, :math:`G = (V, E, W)`, with :math:`W` the weighted adjacency matrix, the symmetrized weighted adjacency matrix is defined as :math:`W' = 0.5 (W + W^{T})`. A skew-symmetric term :math:`\delta` is introduced to encode directionality, where ..math:: \delta_{jk} = \begin{cases} +1 & \text{if} j \to k \text{ is an edge and } k \to j \text{ is not}, \\ -1 & \text{if} k \to j \text{ is an edge and } j \to k \text{ is not}, \\ 0 & \text{if both or neither edge is present.} \end{cases} Then, the magnetic Laplacian matrix is defined as: .. math:: L^{(q)} := D - H^{(q)} where :math:`H^{(q)}` is the Hermitian adjacency matrix with entries :math:`H^{(q)}_{jk} = W'_{jk} e^{2\pi i q \delta_{jk}}`, and :math:`D` is the degree matrix associated with the symmetrized weight adjacency matrix :math:`W'`. If `normalized` is True, compute the normalized version using the Moore-Penrose inverse :math:`D^{+}}` of the degree matrix :math:`D`. The normalized formula is then: .. math:: L^{(q)}_{norm} = (D^{+})^{0.5} L^{(q)} (D^{+})^{0.5} Parameters ---------- G : DiGraph A directed graph nodelist : list, optional (default=list(G)) Node ordering for row/columns. normalized : bool, optional (default=False) Bool that encodes if return the magnetic Laplacian or the normalized magnetic Laplacian. If True returns the normalized version. q : float, optional (default=0.25) The phase of the magnetic potential is the charge parameter 0 <= q <= 0.5. At q=0 returns the standard Laplacian. weight : string or None, optional (default='weight') Edge attribute key for weights. If None, all edges have weight 1. Returns ------- L : SciPy sparse array (complex dtype) The magnetic Laplacian matrix of `G` if not `normalized` and the normalized version if `normalized` Raises ------ ValueError If q is not between 0 and 0.5 NetworkXNotImplemented If `G` is undirected or a multigraph References ---------- .. [1] Fanuel, M., Alaíz, C. M., Fernández, Á., & Suykens, J. A. (2018). Magnetic eigenmaps for the visualization of directed graphs. Applied and Computational Harmonic Analysis, 44(1), 189–199. ) defaultdictNg?z-Parameter q must be a value between 0 and 0.5y?)datadefault)r dtyper r r!r#r y) collectionsr4r$rrlen enumerate ValueErrorpiintfloatexpedgesappendr csr_arraycomplexabsrravelr%r&r'rrones)rrr1r2rr4r(rriv node_indexphasedelta_phase_edgematrix_weightsphasesuwtuivirowscolsr5Hr*r,r-rs&$$$$ rmagnetic_laplacian_matrixrVs_`(7 H A#,X#67#641!$#6J7 McMHII IME#3' 'NU #Re )rs;. X&j'jZX&n'nb\"\"X&WW$)W-1W:BW'##W|\"\"X&\'##\~\"\"X&R-'##R-jL r