+ nDj%KRt^RIt^RIHtHt^RIHt^RIH t H t ^RI H t H t Ht^RIHt^RIHt.ROtRtRR ltRR lt]!R4R4t]!R4RRl4t]!R4RRR RR RR /Rll4t]!RR4R4tR#)zSVD decomposition functions.N)_apply_over_batch_deprecate_dtypes)_batched_linalg) LinAlgError _datacopied)_normalize_lapack_dtype_ensure_aligned_and_native HAS_ILP64)get_lapack_funcs)_asarray_validatedc VFppVR,pVR,pV^8wgKV^8d\RV R24hV^8gK=VR8XdVR 8XdRV R2p\V4h\RV) R V R V R24h R #) zAFormat/emit errors/warnings from a lowlevel batched routine. lapack_infonumz!SVD did not converge for slice = .gesddzslice z has a NaN entryzillegal value in zth argument of internal z for slice N)r ValueError)err_lst lapack_driverentryinformsgs&& R/data/cameron/venvs/s3viz/lib/python3.14/site-packages/scipy/linalg/_decomp_svd.py_format_emit_errors_warningsrs]#El 19ax!$EcU!"LMMax G+ "3%'78C$S/) 'w.F}o"3%q*TFrcd\V\4'g \R4hVR9dRV R2p\V4h\ WR7p\ RV4VP ^8d\RVP : 24hVPR,VPR,r\Ws4wrs\Ws4wrsT;'g \Wp4pT;'d+VP ^8H;'dVPR,pVP^8XEdZ\\P!^VP R74wrp VPR Rp \P"!W}R,V P R 7pV'd\P"!W}W3,V P R 7p\P$!V4VR &\P"!W}W3,V P R 7p\P$!V 4VR &MV\P"!W}V^3,V P R 7p\P"!W}^V 3,V P R 7pV'dWV3#V#V'dW8dW3MW3wppV'dZ\&'gMVV,\P(!\P*4P,8d\R V R V R24hM\-VV,V V,4p\&'g[\-VV,V V,4\P(!\P*4P,8d\RV R24h\.P0!WuW!V4pVR,pV'd \3VV4V'dVR R#V^,#)a[ Singular Value Decomposition. Factorizes the matrix `a` into two unitary matrices ``U`` and ``Vh``, and a 1-D array ``s`` of singular values (real, non-negative) such that ``a == U @ S @ Vh``, where ``S`` is a suitably shaped matrix of zeros with main diagonal ``s``. Parameters ---------- a : (..., M, N) array_like Matrix to decompose. full_matrices : bool, optional If True (default), `U` and `Vh` are of shape ``(M, M)``, ``(N, N)``. If False, the shapes are ``(M, K)`` and ``(K, N)``, where ``K = min(M, N)``. compute_uv : bool, optional Whether to compute also ``U`` and ``Vh`` in addition to ``s``. Default is True. overwrite_a : bool, optional Whether to overwrite data in `a` (may improve performance). Default is False. See :ref:`tutorial_linalg_overwrite` for details. check_finite : bool, optional Whether to check that the input matrix contains only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. lapack_driver : {'gesdd', 'gesvd'}, optional Whether to use the more efficient divide-and-conquer approach (``'gesdd'``) or general rectangular approach (``'gesvd'``) to compute the SVD. MATLAB and Octave use the ``'gesvd'`` approach. Default is ``'gesdd'``. Returns ------- U : ndarray Unitary matrix having left singular vectors as columns. Of shape ``(M, M)`` or ``(M, K)``, depending on `full_matrices`. Only present when ``compute_uv=True``. s : ndarray The singular values, sorted in non-increasing order. Of shape (K,), with ``K = min(M, N)``. Vh : ndarray Unitary matrix having right singular vectors as rows. Of shape ``(N, N)`` or ``(K, N)`` depending on `full_matrices`. Only present when ``compute_uv=True``. Raises ------ LinAlgError If SVD computation does not converge. See Also -------- svdvals : Compute singular values of a matrix. diagsvd : Construct the Sigma matrix, given the vector s. Notes ----- The array argument of this function, `a`, may have additional "batch" dimensions prepended to the core shape. In this case, the array is treated as a batch of lower-dimensional slices; see :ref:`linalg_batch` for details. Examples -------- >>> import numpy as np >>> from scipy import linalg >>> rng = np.random.default_rng() >>> m, n = 9, 6 >>> a = rng.standard_normal((m, n)) + 1.j*rng.standard_normal((m, n)) >>> U, s, Vh = linalg.svd(a) >>> U.shape, s.shape, Vh.shape ((9, 9), (6,), (6, 6)) Reconstruct the original matrix from the decomposition: >>> sigma = np.zeros((m, n)) >>> for i in range(min(m, n)): ... sigma[i, i] = s[i] >>> a1 = U @ sigma @ Vh >>> np.allclose(a, a1) True Alternatively, use ``full_matrices=False`` (notice that the shape of ``U`` is then ``(m, n)`` instead of ``(m, m)``): >>> U, s, Vh = linalg.svd(a, full_matrices=False) >>> U.shape, s.shape, Vh.shape ((9, 6), (6,), (6, 6)) >>> S = np.diag(s) >>> np.allclose(a, U @ S @ Vh) True >>> s2 = linalg.svd(a, compute_uv=False) >>> np.allclose(s, s2) True If the input matrix has more than two dimensions, it is interpreted as a batch of two-dimensional matrices: >>> aa = np.stack((a, 2*a)) >>> linalg.svdvals(aa)[0] == linalg.svdvals(a) array([ True, True, True, True, True, True]) >>> linalg.svdvals(aa)[1] == 2 * linalg.svdvals(a) array([ True, True, True, True, True, True]) zlapack_driver must be a stringz/lapack_driver must be "gesdd" or "gesvd", not "" check_finitesvdz&Expected at least ndim=2, got a1.ndim= F_CONTIGUOUSdtypeN)shaper".zIndexing a matrix size z x zu would incur integer overflow in LAPACK. Instead, either use using numpy.linalg.svd or buildSciPy with ILP64 support.zIndexing a matrix of z elements would incur an in integer overflow in LAPACK. Instead, either use using numpy.linalg.svd or buildSciPy with ILP64 support.)rgesvd)) isinstancestr TypeErrorrr rndimr#rrrflagssizernpeyer" empty_likeidentityr iinfoint32maxr_svdr)a full_matrices compute_uv overwrite_arrmessagea1mnu0s0v0 batch_shapesuvmax_mnmin_mnszresrs&&&&&& rrr%sV mS ) )899..CM?RST!! A 9BeR  ww{B"''DEE 88B<"q.b>OB0AOB55+b"4KOO277a<OObhh~6NK ww!|23 hhsm MM"$$6bhh G  bqf(">?? QZV,B9QZV!">??    :k C"gG$Wm<3Bx1v rc \V^VVR7#)a Compute singular values of a matrix. Parameters ---------- a : (M, N) array_like Matrix to decompose. overwrite_a : bool, optional Whether to overwrite data in `a` (may improve performance). Default is False. See :ref:`tutorial_linalg_overwrite` for details. check_finite : bool, optional Whether to check that the input matrix contains only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. Returns ------- s : (min(M, N),) ndarray The singular values, sorted in decreasing order. Raises ------ LinAlgError If SVD computation does not converge. See Also -------- svd : Compute the full singular value decomposition of a matrix. diagsvd : Construct the Sigma matrix, given the vector s. Notes ----- Array argument of this function, `a`, may have additional "batch" dimensions prepended to the core shape. In this case, the array is treated as a batch of lower-dimensional slices; see :ref:`linalg_batch` for details. Examples -------- >>> import numpy as np >>> from scipy.linalg import svdvals >>> m = np.array([[1.0, 0.0], ... [2.0, 3.0], ... [1.0, 1.0], ... [0.0, 2.0], ... [1.0, 0.0]]) >>> svdvals(m) array([ 4.28091555, 1.63516424]) If the input matrix has more than two dimensions, it is interpreted as a batch of two-dimensional matrices: >>> mm = np.stack((m, 2*m)) >>> svdvals(mm) array([[4.28091555, 1.63516424], [8.56183109, 3.27032847]]) We can verify the maximum singular value of `m` by computing the maximum length of `m @ u` over all the unit vectors `u` in the (x,y) plane. We approximate "all" the unit vectors with a large sample. Because of linearity, we only need the unit vectors with angles in ``[0, pi]``. >>> t = np.linspace(0, np.pi, 2000) >>> u = np.array([np.cos(t), np.sin(t)]) >>> np.linalg.norm(m @ u, axis=0).max() 4.2809152422538475 `p` is a projection matrix with rank 1. With exact arithmetic, its singular values would be ``[1, 0, 0, 0]``. >>> v = np.array([0.1, 0.3, 0.9, 0.3]) >>> p = np.outer(v, v) >>> svdvals(p) array([ 1.00000000e+00, 2.02021698e-17, 1.56692500e-17, 8.15115104e-34]) The singular values of an orthogonal matrix are all 1. Here, we create a random orthogonal matrix by using the ``rvs()`` method of `scipy.stats.ortho_group`. >>> from scipy.stats import ortho_group >>> orth = ortho_group.rvs(4) >>> svdvals(orth) array([ 1., 1., 1., 1.]) )r8r9r)r)r6r9rs&&&rsvdvalsrJsj qQK( **rcx\P!V4pVPPp\ V4pWQ8Xd7\P !V\P !WV, 3VR734#WR8Xd8\PV\P !W, V3VR73,#\R4h)a' Construct the sigma matrix in SVD from singular values and size M, N. Parameters ---------- s : (M,) or (N,) array_like Singular values M : int Size of the matrix whose singular values are `s`. N : int Size of the matrix whose singular values are `s`. Returns ------- S : (M, N) ndarray The S-matrix in the singular value decomposition See Also -------- svd : Singular value decomposition of a matrix svdvals : Compute singular values of a matrix. Examples -------- >>> import numpy as np >>> from scipy.linalg import diagsvd >>> vals = np.array([1, 2, 3]) # The array representing the computed svd >>> diagsvd(vals, 3, 4) array([[1, 0, 0, 0], [0, 2, 0, 0], [0, 0, 3, 0]]) >>> diagsvd(vals, 4, 3) array([[1, 0, 0], [0, 2, 0], [0, 0, 3], [0, 0, 0]]) r!zLength of s must be M or N.) r.diagr"charlenhstackzerosr_r)rBMNparttypMorNs&&& rdiagsvdrW0sP 771:D **//C q6D yyy$!U3 ?@AA uuT288QUAJc::;;677rc\VRR7wr#pVP^,VP^,reVf;\P!VP4P \ WV4,p\P!VRR7V,p\P!W78\R7pVRRV13,p V #)a Construct an orthonormal basis for the range of A using SVD. Parameters ---------- A : (M, N) array_like Input array rcond : float, optional Relative condition number. Singular values ``s`` smaller than ``rcond * max(s)`` are considered zero. Default: floating point eps * max(M,N). Returns ------- Q : (M, K) ndarray Orthonormal basis for the range of A. K = effective rank of A, as determined by rcond See Also -------- svd : Singular value decomposition of a matrix null_space : Matrix null space Examples -------- >>> import numpy as np >>> from scipy.linalg import orth >>> A = np.array([[2, 0, 0], [0, 5, 0]]) # rank 2 array >>> orth(A) array([[0., 1.], [1., 0.]]) >>> orth(A.T) array([[0., 1.], [1., 0.], [0., 0.]]) F)r7Ninitialr!NNN) rr#r.finfor"epsr4amaxsumint) ArcondrCrBvhrRrStolrQs && rorthrgesN1E*HA" 771:rxx{q }!%%A 1 ''!R 5 (C && $C !TcT' A Hrr9rrc\VRVW4R7wrVpVP^,VP^,rVf;\P!VP4P \ W4,p\P!VRR7V,p \P!Wj8\R7p W{R1R3,PP4p V #)a; Construct an orthonormal basis for the null space of A using SVD. Parameters ---------- A : (M, N) array_like Input array rcond : float, optional Relative condition number. Singular values ``s`` smaller than ``rcond * max(s)`` are considered zero. Default: floating point eps * max(M,N). overwrite_a : bool, optional Whether to overwrite `a`; may improve performance. Default is False. See :ref:`tutorial_linalg_overwrite` for details. check_finite : bool, optional Whether to check that the input matrix contains only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. lapack_driver : {'gesdd', 'gesvd'}, optional Whether to use the more efficient divide-and-conquer approach (``'gesdd'``) or general rectangular approach (``'gesvd'``) to compute the SVD. MATLAB and Octave use the ``'gesvd'`` approach. Default is ``'gesdd'``. Returns ------- Z : (N, K) ndarray Orthonormal basis for the null space of A. K = dimension of effective null space, as determined by rcond See Also -------- svd : Singular value decomposition of a matrix orth : Matrix range Examples -------- 1-D null space: >>> import numpy as np >>> from scipy.linalg import null_space >>> A = np.array([[1, 1], [1, 1]]) >>> ns = null_space(A) >>> ns * np.copysign(1, ns[0,0]) # Remove the sign ambiguity of the vector array([[ 0.70710678], [-0.70710678]]) 2-D null space: >>> from numpy.random import default_rng >>> rng = default_rng() >>> B = rng.random((3, 5)) >>> Z = null_space(B) >>> Z.shape (5, 2) >>> np.allclose(B.dot(Z), 0) True The basis vectors are orthonormal (up to rounding error): >>> Z.T.dot(Z) array([[ 1.00000000e+00, 6.92087741e-17], [ 6.92087741e-17, 1.00000000e+00]]) T)r7r9rrNrYrZr!r\) rr#r.r]r"r^r4r_r`raTconj) rbrcr9rrrCrBrdrRrSrerrfs &&$$$ r null_spacerksH1Dk ,KHA" 771:rxx{q }!%%A 1 ''!R 5 (C && $C 46 A Hrc \VRR7p\VP4^8wd\RVP 24h\ V4p?\VRR7p\VP4^8wd\RVP 24h\V4\V48wd4\RVP^, RVP^, 24h\ V4p?\ P !VPP4V4p\V4pVP^,VP^,8dV\ P !W$4, pM5V\ P !W4PP44, p???V^,R8pVP4'd9\ P!\ P!\VRR7R R44pMR p\ P!Wg\ P!\ P!VR R R 1,R R444pV#) a Compute the subspace angles between two matrices. Parameters ---------- A : (M, N) array_like The first input array. B : (M, K) array_like The second input array. Returns ------- angles : ndarray, shape (min(N, K),) The subspace angles between the column spaces of `A` and `B` in descending order. See Also -------- orth svd Notes ----- This computes the subspace angles according to the formula provided in [1]_. For equivalence with MATLAB and Octave behavior, use ``angles[0]``. .. versionadded:: 1.0 References ---------- .. [1] Knyazev A, Argentati M (2002) Principal Angles between Subspaces in an A-Based Scalar Product: Algorithms and Perturbation Estimates. SIAM J. Sci. Comput. 23:2008-2040. Examples -------- A Hadamard matrix, which has orthogonal columns, so we expect that the subspace angle to be :math:`\frac{\pi}{2}`: >>> import numpy as np >>> from scipy.linalg import hadamard, subspace_angles >>> rng = np.random.default_rng() >>> H = hadamard(4) >>> print(H) [[ 1 1 1 1] [ 1 -1 1 -1] [ 1 1 -1 -1] [ 1 -1 -1 1]] >>> np.rad2deg(subspace_angles(H[:, :2], H[:, 2:])) array([ 90., 90.]) And the subspace angle of a matrix to itself should be zero: >>> subspace_angles(H[:, :2], H[:, :2]) <= 2 * np.finfo(float).eps array([ True, True], dtype=bool) The angles between non-orthogonal subspaces are in between these extremes: >>> x = rng.standard_normal((4, 3)) >>> np.rad2deg(subspace_angles(x[:, :2], x[:, [2]])) array([ 55.832]) # random Trzexpected 2D array, got shape z/A and B must have the same number of rows, got z and g?)r9g?rYNgr&)r rNr#rrgr.dotrirjrJanyarcsinclipwherearccos) rbBQAQBQA_H_QBsigmamask mu_arcsinthetas && rsubspace_anglesr{sH 140A 177|q8 BCC aB 140A 177|q8 BCC 1vRJHHQK=aggaj\;< < aB ffRTTYY["%G G E xx{bhhqk! $ $ IINN,- - B A: D xxzzIIbgggaT&BCLM  HHTbiidd S"0M&N OE Lr)rrJrWrgr{rk)TTFTr)FT)rB)rb)N)rsr})__doc__numpyr.scipy._lib._utilrrr_miscrrlapackrrr scipy.linalg.lapackr _decompr __all__rrrJrWrgrkr{rrrs"A,RR0' Q(odV*r8/8/8h8- - `8K UK K $K K \8X&h'hr