KhNSr/SQrSSKrSSKrSSKrSSKJrJr SSKJ r SSK J r J r J r JrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r)J*r*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2J3r3J4r5J6r7J8r9J:r;Jr?J@rAJBrCJDrE SSKFJGrG SSKHJIrIJJrJ SS KKJLrLJMrM SS KNJOrO SS KPJQrQ "S S \5rR"SS\5rS"SS\5rT"SS\5rU"SS\5rV\R"\3RSS9rX\rY\ "S5"SS\Z55r[Sr\Sr]Sr^Sr_Sr`SraS rbS!rc\\\\\\\\0rd\\\\\\\\0re\4S"jrf\4S#jrgS$rhS%riS&rjS'rkS(rlS)rmS*rnS+rBSwS,jro\X"\o5SwS-j5rpS.rq\X"\q5S/5rrSwS0jrs\X"\s5SxS2j5rtS3ru\X"\u5S45rvS5rw\X"\w5S65rxSS7.S8jry\X"\y5S9S7.S:j5rzS;r{\X"\{5S<5r:SwS=jr|\X"\|5SyS>j5r}\X"\u5S?5r~SwS@jr\X"\5SzSAj5rSBr\X"\u5SC5r\X"\5SzSDj5rS{SEjr\X"\5S|SFj5rSGr\X"\5SH5rSwSIjr\X"\5SwSJj5rS}SSK.SLjjr\X"\5S~SSK.SMjj5rS}SSK.SNjjr\X"\5S~\GSK.SOjj5r\X"\u5SP5r\X"\u5SQ5rSwSRjr\X"\5SwSSj5rSTrS{SUjr\X"\5SSVj5rSSW.SXjr\X"\5SSW.SYj5rSwSZjrSS[jrSwS\jrSS].S^jr\X"\5SS].S_j5r4SSS`.Sajr\X"\5SSS`.Sbj5r6SSc.Sdjr\X"\5SeSc.Sfj5r8Sgr\X"\5Sh5r>SSi.Sjjr\X"\5S1Si.Skj5r<\=R\>> from numpy import linalg as LA >>> LA.inv(np.zeros((2,2))) Traceback (most recent call last): File "", line 1, in File "...linalg.py", line 350, in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype))) File "...linalg.py", line 249, in solve raise LinAlgError('Singular matrix') numpy.linalg.LinAlgError: Singular matrix r\N)r^r_r`ra__doc__rcr\rdrerrIsrdrc[S5e)NzSingular matrixrerrflags re_raise_linalgerror_singularrgs ' ((rdc[S5e)NzMatrix is not positive definiter~rs re_raise_linalgerror_nonposdefrjs 7 88rdc[S5e)NzEigenvalues did not converger~rs re-_raise_linalgerror_eigenvalues_nonconvergencerms 4 55rdc[S5e)NzSVD did not converger~rs re%_raise_linalgerror_svd_nonconvergencerps , --rdc[S5e)Nz,SVD did not converge in Linear Least Squaresr~rs re_raise_linalgerror_lstsqrss D EErdc[S5e)Nz:Incorrect argument found while performing QR factorizationr~rs re_raise_linalgerror_qrrvs ) **rdcL[U5n[USUR5nX4$)N__array_wrap__)r'getattrr)anewwraps re _makearrayr{s( !*C 1&(:(: ;D 9rdc"[U[5$N) issubclassr1)ts re isComplexTypers a ))rdc,[RX5$r)_real_types_mapgetrdefaults re _realTypers   q **rdc,[RX5$r)_complex_types_maprrs re _complexTypers  ! !! --rdcr[nSnUHnURRn[U[5(aV[ U5(aSn[ USS9nU[La[nM[Uc$[SURR<S35eM[nM U(a[Un[U4$[U4$)NFT)rz array type z is unsupported in linalg) r,dtypetyperr0rrr- TypeErrornamerr/)arrays result_type is_complexrtype_rts re _commonTypersKJ   eW % %U##! 5$/BV|$ !()) !K(5  ##{""rdc /nUHanURRS;a3UR[X"RR S5S95 MPURU5 Mc [ U5S:XaUS$U$)N)=|rrr")r byteorderappendr' newbyteorderlen)rretarrs re_to_native_byte_orderrsi C 99  j 0 JJws))*@*@*EF G JJsO   3x1}1v  rdcfUH+nURS:wdM[SUR-5e g)Nz9%d-dimensional array given. Array must be two-dimensionalndimrrrs re _assert_2drs5  66Q;&()/0 0rdcfUH+nURS:dM[SUR-5e g)NrzB%d-dimensional array given. Array must be at least two-dimensionalrrs re_assert_stacked_2drs5  66A:/1289 9rdcXUH$nURSSup#X#:wdM[S5e g)Nz-Last 2 dimensions of the array must be square)shaper)rrmns re_assert_stacked_squarers. wwrs| 6MN NrdchUH,n[U5R5(aM#[S5e g)Nz#Array must not contain infs or NaNs)r:r3rrs re_assert_finiters) {  CD DrdcdURS:H=(a [URSS5S:H$)Nr"r)sizer@r)rs re _is_empty_2drs) 88q= 6T#))BC.1Q66rdc[USS5$)z Transpose each matrix in a stack of matrices. Unlike np.transpose, this only swaps the last two axes, rather than all of them Parameters ---------- a : (...,M,N) array_like Returns ------- aT : (...,N,M) ndarray r)rFrs rerOrOs Ar2 rdcX4$rr\)rbaxess re_tensorsolve_dispatcherr 6Mrdc[U5up[U5nURnUbQ[[ SU55nUH%nUR U5 UR XF5 M' URU5nURXAR- *SnSnUHnX-nM URUS-:wa [S5eURX5nUR5nU"[X55n XylU $)a Solve the tensor equation ``a x = b`` for x. It is assumed that all indices of `x` are summed over in the product, together with the rightmost indices of `a`, as is done in, for example, ``tensordot(a, x, axes=x.ndim)``. Parameters ---------- a : array_like Coefficient tensor, of shape ``b.shape + Q``. `Q`, a tuple, equals the shape of that sub-tensor of `a` consisting of the appropriate number of its rightmost indices, and must be such that ``prod(Q) == prod(b.shape)`` (in which sense `a` is said to be 'square'). b : array_like Right-hand tensor, which can be of any shape. axes : tuple of ints, optional Axes in `a` to reorder to the right, before inversion. If None (default), no reordering is done. Returns ------- x : ndarray, shape Q Raises ------ LinAlgError If `a` is singular or not 'square' (in the above sense). See Also -------- numpy.tensordot, tensorinv, numpy.einsum Examples -------- >>> import numpy as np >>> a = np.eye(2*3*4) >>> a.shape = (2*3, 4, 2, 3, 4) >>> rng = np.random.default_rng() >>> b = rng.normal(size=(2*3, 4)) >>> x = np.linalg.tensorsolve(a, b) >>> x.shape (2, 3, 4) >>> np.allclose(np.tensordot(a, x, axes=3), b) True Nr"rrzfInput arrays must satisfy the requirement prod(a.shape[b.ndim:]) == prod(a.shape[:b.ndim]))rr'rlistrangeremoveinsertrOrrrreshaperavelr) rrrranallaxeskoldshaper@ress rerrsdmGA A B uQ|$A NN1  NN2 ! KK wwFF|}%H D   vv >  $A  A uQ{ CI JrdcX4$rr\)rrs re_solve_dispatcherr<rrdc[U5up[U5 [U5 [U5up[X5upEURS:Xa[ R nO[ Rn[U5(aSOSn[[SSSSS9 U"XUS9nSSS5 U"WRUS S 95$!,(df  N$=f) a Solve a linear matrix equation, or system of linear scalar equations. Computes the "exact" solution, `x`, of the well-determined, i.e., full rank, linear matrix equation `ax = b`. Parameters ---------- a : (..., M, M) array_like Coefficient matrix. b : {(M,), (..., M, K)}, array_like Ordinate or "dependent variable" values. Returns ------- x : {(..., M,), (..., M, K)} ndarray Solution to the system a x = b. Returned shape is (..., M) if b is shape (M,) and (..., M, K) if b is (..., M, K), where the "..." part is broadcasted between a and b. Raises ------ LinAlgError If `a` is singular or not square. See Also -------- scipy.linalg.solve : Similar function in SciPy. Notes ----- Broadcasting rules apply, see the `numpy.linalg` documentation for details. The solutions are computed using LAPACK routine ``_gesv``. `a` must be square and of full-rank, i.e., all rows (or, equivalently, columns) must be linearly independent; if either is not true, use `lstsq` for the least-squares best "solution" of the system/equation. .. versionchanged:: 2.0 The b array is only treated as a shape (M,) column vector if it is exactly 1-dimensional. In all other instances it is treated as a stack of (M, K) matrices. Previously b would be treated as a stack of (M,) vectors if b.ndim was equal to a.ndim - 1. References ---------- .. [1] G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando, FL, Academic Press, Inc., 1980, pg. 22. Examples -------- Solve the system of equations: ``x0 + 2 * x1 = 1`` and ``3 * x0 + 5 * x1 = 2``: >>> import numpy as np >>> a = np.array([[1, 2], [3, 5]]) >>> b = np.array([1, 2]) >>> x = np.linalg.solve(a, b) >>> x array([-1., 1.]) Check that the solution is correct: >>> np.allclose(np.dot(a, x), b) True rDD->Ddd->dcallignorerinvalidoverrGunder signatureNFcopy) rrrrrrUsolve1rrr<rastype) rr_rrresult_tgufuncrrs rerr@sT a=DAq1mGAa#KA vv{%%$$(++I 2F B 19 - B . //  B Bs B:: CcU4$rr\)rinds re_tensorinv_dispatcherr 4Krdrc[U5nURnSnUS:aX!SUSU-nX!SHnX5-nM O [S5eURUS5n[ U5nUR"U6$)a; Compute the 'inverse' of an N-dimensional array. The result is an inverse for `a` relative to the tensordot operation ``tensordot(a, b, ind)``, i. e., up to floating-point accuracy, ``tensordot(tensorinv(a), a, ind)`` is the "identity" tensor for the tensordot operation. Parameters ---------- a : array_like Tensor to 'invert'. Its shape must be 'square', i. e., ``prod(a.shape[:ind]) == prod(a.shape[ind:])``. ind : int, optional Number of first indices that are involved in the inverse sum. Must be a positive integer, default is 2. Returns ------- b : ndarray `a`'s tensordot inverse, shape ``a.shape[ind:] + a.shape[:ind]``. Raises ------ LinAlgError If `a` is singular or not 'square' (in the above sense). See Also -------- numpy.tensordot, tensorsolve Examples -------- >>> import numpy as np >>> a = np.eye(4*6) >>> a.shape = (4, 6, 8, 3) >>> ainv = np.linalg.tensorinv(a, ind=2) >>> ainv.shape (8, 3, 4, 6) >>> rng = np.random.default_rng() >>> b = rng.normal(size=(4, 6)) >>> np.allclose(np.tensordot(ainv, b), np.linalg.tensorsolve(a, b)) True >>> a = np.eye(4*6) >>> a.shape = (24, 8, 3) >>> ainv = np.linalg.tensorinv(a, ind=1) >>> ainv.shape (8, 3, 24) >>> rng = np.random.default_rng() >>> b = rng.normal(size=24) >>> np.allclose(np.tensordot(ainv, b, 1), np.linalg.tensorsolve(a, b)) True rr"NzInvalid ind argument.r)r'r ValueErrorrr)rrrr@invshaperias rerrsr  AwwH D QwD>HTcN2$A ID 011 $A QB ::x  rdcU4$rr\rs re_unary_dispatcherrrrdc4[U5up[U5 [U5 [U5up#[ U5(aSOSn[ [ SSSSS9 [R"XS9nSSS5 U"WRUSS 95$!,(df  N$=f) a Compute the inverse of a matrix. Given a square matrix `a`, return the matrix `ainv` satisfying ``a @ ainv = ainv @ a = eye(a.shape[0])``. Parameters ---------- a : (..., M, M) array_like Matrix to be inverted. Returns ------- ainv : (..., M, M) ndarray or matrix Inverse of the matrix `a`. Raises ------ LinAlgError If `a` is not square or inversion fails. See Also -------- scipy.linalg.inv : Similar function in SciPy. numpy.linalg.cond : Compute the condition number of a matrix. numpy.linalg.svd : Compute the singular value decomposition of a matrix. Notes ----- Broadcasting rules apply, see the `numpy.linalg` documentation for details. If `a` is detected to be singular, a `LinAlgError` is raised. If `a` is ill-conditioned, a `LinAlgError` may or may not be raised, and results may be inaccurate due to floating-point errors. References ---------- .. [1] Wikipedia, "Condition number", https://en.wikipedia.org/wiki/Condition_number Examples -------- >>> import numpy as np >>> from numpy.linalg import inv >>> a = np.array([[1., 2.], [3., 4.]]) >>> ainv = inv(a) >>> np.allclose(a @ ainv, np.eye(2)) True >>> np.allclose(ainv @ a, np.eye(2)) True If a is a matrix object, then the return value is a matrix as well: >>> ainv = inv(np.matrix(a)) >>> ainv matrix([[-2. , 1. ], [ 1.5, -0.5]]) Inverses of several matrices can be computed at once: >>> a = np.array([[[1., 2.], [3., 4.]], [[1, 3], [3, 5]]]) >>> inv(a) array([[[-2. , 1. ], [ 1.5 , -0.5 ]], [[-1.25, 0.75], [ 0.75, -0.25]]]) If a matrix is close to singular, the computed inverse may not satisfy ``a @ ainv = ainv @ a = eye(a.shape[0])`` even if a `LinAlgError` is not raised: >>> a = np.array([[2,4,6],[2,0,2],[6,8,14]]) >>> inv(a) # No errors raised array([[-1.12589991e+15, -5.62949953e+14, 5.62949953e+14], [-1.12589991e+15, -5.62949953e+14, 5.62949953e+14], [ 1.12589991e+15, 5.62949953e+14, -5.62949953e+14]]) >>> a @ inv(a) array([[ 0. , -0.5 , 0. ], # may vary [-0.5 , 0.625, 0.25 ], [ 0. , 0. , 1. ]]) To detect ill-conditioned matrices, you can use `numpy.linalg.cond` to compute its *condition number* [1]_. The larger the condition number, the more ill-conditioned the matrix is. As a rule of thumb, if the condition number ``cond(a) = 10**k``, then you may lose up to ``k`` digits of accuracy on top of what would be lost to the numerical method due to loss of precision from arithmetic methods. >>> from numpy.linalg import cond >>> cond(a) np.float64(8.659885634118668e+17) # may vary It is also possible to detect ill-conditioning by inspecting the matrix's singular values directly. The ratio between the largest and the smallest singular value is the condition number: >>> from numpy.linalg import svd >>> sigma = svd(a, compute_uv=False) # Do not compute singular vectors >>> sigma.max()/sigma.min() 8.659885634118668e+17 # may vary D->Dd->drrrrNFr) rrrrrr<rrUrr)rrrrrainvs rerrsRmGAq1a.KA'**I 2F B  8 B  H5 1 22 B Bs B  BcU4$rr\)rrs re_matrix_power_dispatcherrerrdc[U5n[U5 [U5 [R"U5nUR [:wa[nO"URS:Xa[nO [S5eUS:Xa1[U5n[URSUR S9US'U$US:a[U5n[!U5nUS :XaU$US:XaU"X5$US :XaU"U"X5U5$S=pEUS:a7UcUOU"XD5n[#US5upU(a UcUOU"XT5nUS:aM7U$![ an[ S5UeSnAff=f) a Raise a square matrix to the (integer) power `n`. For positive integers `n`, the power is computed by repeated matrix squarings and matrix multiplications. If ``n == 0``, the identity matrix of the same shape as M is returned. If ``n < 0``, the inverse is computed and then raised to the ``abs(n)``. .. note:: Stacks of object matrices are not currently supported. Parameters ---------- a : (..., M, M) array_like Matrix to be "powered". n : int The exponent can be any integer or long integer, positive, negative, or zero. Returns ------- a**n : (..., M, M) ndarray or matrix object The return value is the same shape and type as `M`; if the exponent is positive or zero then the type of the elements is the same as those of `M`. If the exponent is negative the elements are floating-point. Raises ------ LinAlgError For matrices that are not square or that (for negative powers) cannot be inverted numerically. Examples -------- >>> import numpy as np >>> from numpy.linalg import matrix_power >>> i = np.array([[0, 1], [-1, 0]]) # matrix equiv. of the imaginary unit >>> matrix_power(i, 3) # should = -i array([[ 0, -1], [ 1, 0]]) >>> matrix_power(i, 0) array([[1, 0], [0, 1]]) >>> matrix_power(i, -3) # should = 1/(-i) = i, but w/ f.p. elements array([[ 0., 1.], [-1., 0.]]) Somewhat more sophisticated example >>> q = np.zeros((4, 4)) >>> q[0:2, 0:2] = -i >>> q[2:4, 2:4] = i >>> q # one of the three quaternion units not equal to 1 array([[ 0., -1., 0., 0.], [ 1., 0., 0., 0.], [ 0., 0., 0., 1.], [ 0., 0., -1., 0.]]) >>> matrix_power(q, 2) # = -np.eye(4) array([[-1., 0., 0., 0.], [ 0., -1., 0., 0.], [ 0., 0., -1., 0.], [ 0., 0., 0., -1.]]) zexponent must be an integerNrz6matrix_power not supported for stacks of object arraysr"rr.r)rDrroperatorindexrrobjectrrr5NotImplementedErrorr*rRrrrAdivmod)rrefmatmulzresultbits rerrisZD 1 Aq1> NN1   ww& 1! DF F Av qMQWWR[0# Q F F Av aq} awq}a(( A a%A 1  .Qgf.@F a% MU >56A=>sD66 E E  E)uppercU4$rr\)rrs re_cholesky_dispatcherrrrdFcfU(a[RO[Rn[U5up[ U5 [ U5 [ U5upE[U5(aSOSn[[SSSSS9 U"XS9nSSS5 U"WRUSS 95$!,(df  N$=f) a Cholesky decomposition. Return the lower or upper Cholesky decomposition, ``L * L.H`` or ``U.H * U``, of the square matrix ``a``, where ``L`` is lower-triangular, ``U`` is upper-triangular, and ``.H`` is the conjugate transpose operator (which is the ordinary transpose if ``a`` is real-valued). ``a`` must be Hermitian (symmetric if real-valued) and positive-definite. No checking is performed to verify whether ``a`` is Hermitian or not. In addition, only the lower or upper-triangular and diagonal elements of ``a`` are used. Only ``L`` or ``U`` is actually returned. Parameters ---------- a : (..., M, M) array_like Hermitian (symmetric if all elements are real), positive-definite input matrix. upper : bool If ``True``, the result must be the upper-triangular Cholesky factor. If ``False``, the result must be the lower-triangular Cholesky factor. Default: ``False``. Returns ------- L : (..., M, M) array_like Lower or upper-triangular Cholesky factor of `a`. Returns a matrix object if `a` is a matrix object. Raises ------ LinAlgError If the decomposition fails, for example, if `a` is not positive-definite. See Also -------- scipy.linalg.cholesky : Similar function in SciPy. scipy.linalg.cholesky_banded : Cholesky decompose a banded Hermitian positive-definite matrix. scipy.linalg.cho_factor : Cholesky decomposition of a matrix, to use in `scipy.linalg.cho_solve`. Notes ----- Broadcasting rules apply, see the `numpy.linalg` documentation for details. The Cholesky decomposition is often used as a fast way of solving .. math:: A \mathbf{x} = \mathbf{b} (when `A` is both Hermitian/symmetric and positive-definite). First, we solve for :math:`\mathbf{y}` in .. math:: L \mathbf{y} = \mathbf{b}, and then for :math:`\mathbf{x}` in .. math:: L^{H} \mathbf{x} = \mathbf{y}. Examples -------- >>> import numpy as np >>> A = np.array([[1,-2j],[2j,5]]) >>> A array([[ 1.+0.j, -0.-2.j], [ 0.+2.j, 5.+0.j]]) >>> L = np.linalg.cholesky(A) >>> L array([[1.+0.j, 0.+0.j], [0.+2.j, 1.+0.j]]) >>> np.dot(L, L.T.conj()) # verify that L * L.H = A array([[1.+0.j, 0.-2.j], [0.+2.j, 5.+0.j]]) >>> A = [[1,-2j],[2j,5]] # what happens if A is only array_like? >>> np.linalg.cholesky(A) # an ndarray object is returned array([[1.+0.j, 0.+0.j], [0.+2.j, 1.+0.j]]) >>> # But a matrix object is returned if A is a matrix object >>> np.linalg.cholesky(np.matrix(A)) matrix([[ 1.+0.j, 0.+0.j], [ 0.+2.j, 1.+0.j]]) >>> # The upper-triangular Cholesky factor can also be obtained. >>> np.linalg.cholesky(A, upper=True) array([[1.-0.j, 0.-2.j], [0.-0.j, 1.-0.j]]) rrrrrrNFr) rU cholesky_up cholesky_lorrrrrr<rr)rrrrrrrrs rerrsv+0] & &]5N5NFmGAq1a.KA'**I 3V B 1 * B . // B Bs =B"" B0cX4$rr\x1x2s re_outer_dispatcherrN 8Ordc[U5n[U5nURS:wdURS:wa([SUR<SUR<S35e[XSS9$)a^ Compute the outer product of two vectors. This function is Array API compatible. Compared to ``np.outer`` it accepts 1-dimensional inputs only. Parameters ---------- x1 : (M,) array_like One-dimensional input array of size ``N``. Must have a numeric data type. x2 : (N,) array_like One-dimensional input array of size ``M``. Must have a numeric data type. Returns ------- out : (M, N) ndarray ``out[i, j] = a[i] * b[j]`` See also -------- outer Examples -------- Make a (*very* coarse) grid for computing a Mandelbrot set: >>> rl = np.linalg.outer(np.ones((5,)), np.linspace(-2, 2, 5)) >>> rl array([[-2., -1., 0., 1., 2.], [-2., -1., 0., 1., 2.], [-2., -1., 0., 1., 2.], [-2., -1., 0., 1., 2.], [-2., -1., 0., 1., 2.]]) >>> im = np.linalg.outer(1j*np.linspace(2, -2, 5), np.ones((5,))) >>> im array([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j], [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j], [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j], [0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j], [0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]]) >>> grid = rl + im >>> grid array([[-2.+2.j, -1.+2.j, 0.+2.j, 1.+2.j, 2.+2.j], [-2.+1.j, -1.+1.j, 0.+1.j, 1.+1.j, 2.+1.j], [-2.+0.j, -1.+0.j, 0.+0.j, 1.+0.j, 2.+0.j], [-2.-1.j, -1.-1.j, 0.-1.j, 1.-1.j, 2.-1.j], [-2.-2.j, -1.-2.j, 0.-2.j, 1.-2.j, 2.-2.j]]) An example using a "vector" of letters: >>> x = np.array(['a', 'b', 'c'], dtype=object) >>> np.linalg.outer(x, [1, 2, 3]) array([['a', 'aa', 'aaa'], ['b', 'bb', 'bbb'], ['c', 'cc', 'ccc']], dtype=object) rz;Input arrays must be one-dimensional, but they are x1.ndim=z and x2.ndim=.Nout)rDrr _core_outerrs rerrRsgz BB BB ww!|rww!| wwjbggZq *   r4 ((rdcU4$rr\)rmodes re_qr_dispatcherr$rrdcUS;aYUS;aSn[R"U[SS9 SnO4US;aSn[R"U[SS9 S nO[S US 35e[ U5up[ U5 UR S S upE[U5upgURUSS9n[U5n[XE5n[U5(aSOSn [[SSSSS9 [R"X S9n S S S 5 US:Xa-[!USS U2S S 245n U RUSS9n U"U 5$US:Xa5[#U5n U RUSS9n W RUSS9n U"U 5U 4$US :XaURUSS9nU"U5$US:XaXE:aUn [R$nOUn [R&n[U5(aSOSn [[SSSSS9 U"UW U S9n S S S 5 [!USS U 2S S 245n W RUSS9n U RUSS9n [)U"U 5U"U 55$!,(df  GNN=f!,(df  Nm=f)a Compute the qr factorization of a matrix. Factor the matrix `a` as *qr*, where `q` is orthonormal and `r` is upper-triangular. Parameters ---------- a : array_like, shape (..., M, N) An array-like object with the dimensionality of at least 2. mode : {'reduced', 'complete', 'r', 'raw'}, optional, default: 'reduced' If K = min(M, N), then * 'reduced' : returns Q, R with dimensions (..., M, K), (..., K, N) * 'complete' : returns Q, R with dimensions (..., M, M), (..., M, N) * 'r' : returns R only with dimensions (..., K, N) * 'raw' : returns h, tau with dimensions (..., N, M), (..., K,) The options 'reduced', 'complete, and 'raw' are new in numpy 1.8, see the notes for more information. The default is 'reduced', and to maintain backward compatibility with earlier versions of numpy both it and the old default 'full' can be omitted. Note that array h returned in 'raw' mode is transposed for calling Fortran. The 'economic' mode is deprecated. The modes 'full' and 'economic' may be passed using only the first letter for backwards compatibility, but all others must be spelled out. See the Notes for more explanation. Returns ------- When mode is 'reduced' or 'complete', the result will be a namedtuple with the attributes `Q` and `R`. Q : ndarray of float or complex, optional A matrix with orthonormal columns. When mode = 'complete' the result is an orthogonal/unitary matrix depending on whether or not a is real/complex. The determinant may be either +/- 1 in that case. In case the number of dimensions in the input array is greater than 2 then a stack of the matrices with above properties is returned. R : ndarray of float or complex, optional The upper-triangular matrix or a stack of upper-triangular matrices if the number of dimensions in the input array is greater than 2. (h, tau) : ndarrays of np.double or np.cdouble, optional The array h contains the Householder reflectors that generate q along with r. The tau array contains scaling factors for the reflectors. In the deprecated 'economic' mode only h is returned. Raises ------ LinAlgError If factoring fails. See Also -------- scipy.linalg.qr : Similar function in SciPy. scipy.linalg.rq : Compute RQ decomposition of a matrix. Notes ----- This is an interface to the LAPACK routines ``dgeqrf``, ``zgeqrf``, ``dorgqr``, and ``zungqr``. For more information on the qr factorization, see for example: https://en.wikipedia.org/wiki/QR_factorization Subclasses of `ndarray` are preserved except for the 'raw' mode. So if `a` is of type `matrix`, all the return values will be matrices too. New 'reduced', 'complete', and 'raw' options for mode were added in NumPy 1.8.0 and the old option 'full' was made an alias of 'reduced'. In addition the options 'full' and 'economic' were deprecated. Because 'full' was the previous default and 'reduced' is the new default, backward compatibility can be maintained by letting `mode` default. The 'raw' option was added so that LAPACK routines that can multiply arrays by q using the Householder reflectors can be used. Note that in this case the returned arrays are of type np.double or np.cdouble and the h array is transposed to be FORTRAN compatible. No routines using the 'raw' return are currently exposed by numpy, but some are available in lapack_lite and just await the necessary work. Examples -------- >>> import numpy as np >>> rng = np.random.default_rng() >>> a = rng.normal(size=(9, 6)) >>> Q, R = np.linalg.qr(a) >>> np.allclose(a, np.dot(Q, R)) # a does equal QR True >>> R2 = np.linalg.qr(a, mode='r') >>> np.allclose(R, R2) # mode='r' returns the same R as mode='full' True >>> a = np.random.normal(size=(3, 2, 2)) # Stack of 2 x 2 matrices as input >>> Q, R = np.linalg.qr(a) >>> Q.shape (3, 2, 2) >>> R.shape (3, 2, 2) >>> np.allclose(a, np.matmul(Q, R)) True Example illustrating a common use of `qr`: solving of least squares problems What are the least-squares-best `m` and `y0` in ``y = y0 + mx`` for the following data: {(0,1), (1,0), (1,2), (2,1)}. (Graph the points and you'll see that it should be y0 = 0, m = 1.) The answer is provided by solving the over-determined matrix equation ``Ax = b``, where:: A = array([[0, 1], [1, 1], [1, 1], [2, 1]]) x = array([[y0], [m]]) b = array([[1], [0], [2], [1]]) If A = QR such that Q is orthonormal (which is always possible via Gram-Schmidt), then ``x = inv(R) * (Q.T) * b``. (In numpy practice, however, we simply use `lstsq`.) >>> A = np.array([[0, 1], [1, 1], [1, 1], [2, 1]]) >>> A array([[0, 1], [1, 1], [1, 1], [2, 1]]) >>> b = np.array([1, 2, 2, 3]) >>> Q, R = np.linalg.qr(A) >>> p = np.dot(Q.T, b) >>> np.dot(np.linalg.inv(R), p) array([ 1., 1.]) )reducedcompleterraw)ffullzcThe 'full' option is deprecated in favor of 'reduced'. For backward compatibility let mode default.r) stacklevelr&)r economicz$The 'economic' option is deprecated.r,zUnrecognized mode ''rNTrrrrrrrr.Fr(r'rr)warningswarnDeprecationWarningrrrrrrrminrr<rrUqr_r_rawrQrO qr_complete qr_reducedrk)rr#msgrrrrrmnrtaurqmcrs rerrsyL 66 = ?  MM#1a @D & &8C MM#1a @D24&:; ;mGAq 7723>> import numpy as np >>> from numpy import linalg as LA >>> x = np.random.random() >>> Q = np.array([[np.cos(x), -np.sin(x)], [np.sin(x), np.cos(x)]]) >>> LA.norm(Q[0, :]), LA.norm(Q[1, :]), np.dot(Q[0, :],Q[1, :]) (1.0, 1.0, 0.0) Now multiply a diagonal matrix by ``Q`` on one side and by ``Q.T`` on the other: >>> D = np.diag((-1,1)) >>> LA.eigvals(D) array([-1., 1.]) >>> A = np.dot(Q, D) >>> A = np.dot(A, Q.T) >>> LA.eigvals(A) array([ 1., -1.]) # random rzd->DrrrrNr"Fr)rrrrrrr<rrUrr3imagrealrrr)rrrrrws rerrmsLmGAq11a.KA'**I D x  "  ! !! 9 "    qvv{  A *H#H-H 88H58 )) " "s !C C,cU4$rr\)rUPLOs re_eigvalsh_dispatcherr@rrdcUR5nUS;a [S5eUS:Xa[RnO[Rn[ U5up[ U5 [U5 [U5upE[U5(aSOSn[[SSSSS9 U"XS 9nS S S 5 WR[U5S S 9$!,(df  N'=f) a Compute the eigenvalues of a complex Hermitian or real symmetric matrix. Main difference from eigh: the eigenvectors are not computed. Parameters ---------- a : (..., M, M) array_like A complex- or real-valued matrix whose eigenvalues are to be computed. UPLO : {'L', 'U'}, optional Specifies whether the calculation is done with the lower triangular part of `a` ('L', default) or the upper triangular part ('U'). Irrespective of this value only the real parts of the diagonal will be considered in the computation to preserve the notion of a Hermitian matrix. It therefore follows that the imaginary part of the diagonal will always be treated as zero. Returns ------- w : (..., M,) ndarray The eigenvalues in ascending order, each repeated according to its multiplicity. Raises ------ LinAlgError If the eigenvalue computation does not converge. See Also -------- eigh : eigenvalues and eigenvectors of real symmetric or complex Hermitian (conjugate symmetric) arrays. eigvals : eigenvalues of general real or complex arrays. eig : eigenvalues and right eigenvectors of general real or complex arrays. scipy.linalg.eigvalsh : Similar function in SciPy. Notes ----- Broadcasting rules apply, see the `numpy.linalg` documentation for details. The eigenvalues are computed using LAPACK routines ``_syevd``, ``_heevd``. Examples -------- >>> import numpy as np >>> from numpy import linalg as LA >>> a = np.array([[1, -2j], [2j, 5]]) >>> LA.eigvalsh(a) array([ 0.17157288, 5.82842712]) # may vary >>> # demonstrate the treatment of the imaginary part of the diagonal >>> a = np.array([[5+2j, 9-2j], [0+2j, 2-1j]]) >>> a array([[5.+2.j, 9.-2.j], [0.+2.j, 2.-1.j]]) >>> # with UPLO='L' this is numerically equivalent to using LA.eigvals() >>> # with: >>> b = np.array([[5.+0.j, 0.-2.j], [0.+2.j, 2.-0.j]]) >>> b array([[5.+0.j, 0.-2.j], [0.+2.j, 2.+0.j]]) >>> wa = LA.eigvalsh(a) >>> wb = LA.eigvals(b) >>> wa; wb array([1., 6.]) array([6.+0.j, 1.+0.j]) Lrv UPLO argument must be 'L' or 'U'rCD->drrrrrNFr)rrrU eigvalsh_lo eigvalsh_uprrrrrr<rrr)rr?rrrrrr=s rer r sR ::rdc:[U5up[U5 [U5 [U5 [ U5up#[ U5(aSOSn[ [SSSSS9 [R"XS9upVSSS5 [ U5(dA[WRS:H5(a$URnWRn[U5nO [U5nWRUS S 9n[!WRUS S 9U"U55$!,(df  N=f) a Compute the eigenvalues and right eigenvectors of a square array. Parameters ---------- a : (..., M, M) array Matrices for which the eigenvalues and right eigenvectors will be computed Returns ------- A namedtuple with the following attributes: eigenvalues : (..., M) array The eigenvalues, each repeated according to its multiplicity. The eigenvalues are not necessarily ordered. The resulting array will be of complex type, unless the imaginary part is zero in which case it will be cast to a real type. When `a` is real the resulting eigenvalues will be real (0 imaginary part) or occur in conjugate pairs eigenvectors : (..., M, M) array The normalized (unit "length") eigenvectors, such that the column ``eigenvectors[:,i]`` is the eigenvector corresponding to the eigenvalue ``eigenvalues[i]``. Raises ------ LinAlgError If the eigenvalue computation does not converge. See Also -------- eigvals : eigenvalues of a non-symmetric array. eigh : eigenvalues and eigenvectors of a real symmetric or complex Hermitian (conjugate symmetric) array. eigvalsh : eigenvalues of a real symmetric or complex Hermitian (conjugate symmetric) array. scipy.linalg.eig : Similar function in SciPy that also solves the generalized eigenvalue problem. scipy.linalg.schur : Best choice for unitary and other non-Hermitian normal matrices. Notes ----- Broadcasting rules apply, see the `numpy.linalg` documentation for details. This is implemented using the ``_geev`` LAPACK routines which compute the eigenvalues and eigenvectors of general square arrays. The number `w` is an eigenvalue of `a` if there exists a vector `v` such that ``a @ v = w * v``. Thus, the arrays `a`, `eigenvalues`, and `eigenvectors` satisfy the equations ``a @ eigenvectors[:,i] = eigenvalues[i] * eigenvectors[:,i]`` for :math:`i \in \{0,...,M-1\}`. The array `eigenvectors` may not be of maximum rank, that is, some of the columns may be linearly dependent, although round-off error may obscure that fact. If the eigenvalues are all different, then theoretically the eigenvectors are linearly independent and `a` can be diagonalized by a similarity transformation using `eigenvectors`, i.e, ``inv(eigenvectors) @ a @ eigenvectors`` is diagonal. For non-Hermitian normal matrices the SciPy function `scipy.linalg.schur` is preferred because the matrix `eigenvectors` is guaranteed to be unitary, which is not the case when using `eig`. The Schur factorization produces an upper triangular matrix rather than a diagonal matrix, but for normal matrices only the diagonal of the upper triangular matrix is needed, the rest is roundoff error. Finally, it is emphasized that `eigenvectors` consists of the *right* (as in right-hand side) eigenvectors of `a`. A vector `y` satisfying ``y.T @ a = z * y.T`` for some number `z` is called a *left* eigenvector of `a`, and, in general, the left and right eigenvectors of a matrix are not necessarily the (perhaps conjugate) transposes of each other. References ---------- G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando, FL, Academic Press, Inc., 1980, Various pp. Examples -------- >>> import numpy as np >>> from numpy import linalg as LA (Almost) trivial example with real eigenvalues and eigenvectors. >>> eigenvalues, eigenvectors = LA.eig(np.diag((1, 2, 3))) >>> eigenvalues array([1., 2., 3.]) >>> eigenvectors array([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]) Real matrix possessing complex eigenvalues and eigenvectors; note that the eigenvalues are complex conjugates of each other. >>> eigenvalues, eigenvectors = LA.eig(np.array([[1, -1], [1, 1]])) >>> eigenvalues array([1.+1.j, 1.-1.j]) >>> eigenvectors array([[0.70710678+0.j , 0.70710678-0.j ], [0. -0.70710678j, 0. +0.70710678j]]) Complex-valued matrix with real eigenvalues (but complex-valued eigenvectors); note that ``a.conj().T == a``, i.e., `a` is Hermitian. >>> a = np.array([[1, 1j], [-1j, 1]]) >>> eigenvalues, eigenvectors = LA.eig(a) >>> eigenvalues array([2.+0.j, 0.+0.j]) >>> eigenvectors array([[ 0. +0.70710678j, 0.70710678+0.j ], # may vary [ 0.70710678+0.j , -0. +0.70710678j]]) Be careful about round-off error! >>> a = np.array([[1 + 1e-9, 0], [0, 1 - 1e-9]]) >>> # Theor. eigenvalues are 1 +/- 1e-9 >>> eigenvalues, eigenvectors = LA.eig(a) >>> eigenvalues array([1., 1.]) >>> eigenvectors array([[1., 0.], [0., 1.]]) zD->DDzd->DDrrrrNgFr)rrrrrrr<rrUrr3r;r<rrrrX)rrrrrr=vts rerr3sFmGAq11a.KA(++I D x  "!!!9 "   AFFcM 2 2 FF WWX&) 8% (B QXXhUX3T"X >> " "s !D  DcUR5nUS;a [S5e[U5up[U5 [ U5 [ U5up4US:Xa[ RnO[ Rn[U5(aSOSn[[SSSSS9 U"XS 9upxS S S 5 WR[U5S S 9nWRUS S 9n[Xr"U55$!,(df  NH=f) a3 Return the eigenvalues and eigenvectors of a complex Hermitian (conjugate symmetric) or a real symmetric matrix. Returns two objects, a 1-D array containing the eigenvalues of `a`, and a 2-D square array or matrix (depending on the input type) of the corresponding eigenvectors (in columns). Parameters ---------- a : (..., M, M) array Hermitian or real symmetric matrices whose eigenvalues and eigenvectors are to be computed. UPLO : {'L', 'U'}, optional Specifies whether the calculation is done with the lower triangular part of `a` ('L', default) or the upper triangular part ('U'). Irrespective of this value only the real parts of the diagonal will be considered in the computation to preserve the notion of a Hermitian matrix. It therefore follows that the imaginary part of the diagonal will always be treated as zero. Returns ------- A namedtuple with the following attributes: eigenvalues : (..., M) ndarray The eigenvalues in ascending order, each repeated according to its multiplicity. eigenvectors : {(..., M, M) ndarray, (..., M, M) matrix} The column ``eigenvectors[:, i]`` is the normalized eigenvector corresponding to the eigenvalue ``eigenvalues[i]``. Will return a matrix object if `a` is a matrix object. Raises ------ LinAlgError If the eigenvalue computation does not converge. See Also -------- eigvalsh : eigenvalues of real symmetric or complex Hermitian (conjugate symmetric) arrays. eig : eigenvalues and right eigenvectors for non-symmetric arrays. eigvals : eigenvalues of non-symmetric arrays. scipy.linalg.eigh : Similar function in SciPy (but also solves the generalized eigenvalue problem). Notes ----- Broadcasting rules apply, see the `numpy.linalg` documentation for details. The eigenvalues/eigenvectors are computed using LAPACK routines ``_syevd``, ``_heevd``. The eigenvalues of real symmetric or complex Hermitian matrices are always real. [1]_ The array `eigenvalues` of (column) eigenvectors is unitary and `a`, `eigenvalues`, and `eigenvectors` satisfy the equations ``dot(a, eigenvectors[:, i]) = eigenvalues[i] * eigenvectors[:, i]``. References ---------- .. [1] G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando, FL, Academic Press, Inc., 1980, pg. 222. Examples -------- >>> import numpy as np >>> from numpy import linalg as LA >>> a = np.array([[1, -2j], [2j, 5]]) >>> a array([[ 1.+0.j, -0.-2.j], [ 0.+2.j, 5.+0.j]]) >>> eigenvalues, eigenvectors = LA.eigh(a) >>> eigenvalues array([0.17157288, 5.82842712]) >>> eigenvectors array([[-0.92387953+0.j , -0.38268343+0.j ], # may vary [ 0. +0.38268343j, 0. -0.92387953j]]) >>> (np.dot(a, eigenvectors[:, 0]) - ... eigenvalues[0] * eigenvectors[:, 0]) # verify 1st eigenval/vec pair array([5.55111512e-17+0.0000000e+00j, 0.00000000e+00+1.2490009e-16j]) >>> (np.dot(a, eigenvectors[:, 1]) - ... eigenvalues[1] * eigenvectors[:, 1]) # verify 2nd eigenval/vec pair array([0.+0.j, 0.+0.j]) >>> A = np.matrix(a) # what happens if input is a matrix object >>> A matrix([[ 1.+0.j, -0.-2.j], [ 0.+2.j, 5.+0.j]]) >>> eigenvalues, eigenvectors = LA.eigh(A) >>> eigenvalues array([0.17157288, 5.82842712]) >>> eigenvectors matrix([[-0.92387953+0.j , -0.38268343+0.j ], # may vary [ 0. +0.38268343j, 0. -0.92387953j]]) >>> # demonstrate the treatment of the imaginary part of the diagonal >>> a = np.array([[5+2j, 9-2j], [0+2j, 2-1j]]) >>> a array([[5.+2.j, 9.-2.j], [0.+2.j, 2.-1.j]]) >>> # with UPLO='L' this is numerically equivalent to using LA.eig() with: >>> b = np.array([[5.+0.j, 0.-2.j], [0.+2.j, 2.-0.j]]) >>> b array([[5.+0.j, 0.-2.j], [0.+2.j, 2.+0.j]]) >>> wa, va = LA.eigh(a) >>> wb, vb = LA.eig(b) >>> wa array([1., 6.]) >>> wb array([6.+0.j, 1.+0.j]) >>> va array([[-0.4472136 +0.j , -0.89442719+0.j ], # may vary [ 0. +0.89442719j, 0. -0.4472136j ]]) >>> vb array([[ 0.89442719+0.j , -0. +0.4472136j], [-0. +0.4472136j, 0.89442719+0.j ]]) rBrDrCzD->dDd->ddrrrrNFr)rrrrrrrUeigh_loeigh_uprr<rrrrh) rr?rrrrrr=rLs rerrsx ::= 2``. full_matrices : bool, optional If True (default), `u` and `vh` have the shapes ``(..., M, M)`` and ``(..., N, N)``, respectively. Otherwise, the shapes are ``(..., M, K)`` and ``(..., K, N)``, respectively, where ``K = min(M, N)``. compute_uv : bool, optional Whether or not to compute `u` and `vh` in addition to `s`. True by default. hermitian : bool, optional If True, `a` is assumed to be Hermitian (symmetric if real-valued), enabling a more efficient method for finding singular values. Defaults to False. Returns ------- When `compute_uv` is True, the result is a namedtuple with the following attribute names: U : { (..., M, M), (..., M, K) } array Unitary array(s). The first ``a.ndim - 2`` dimensions have the same size as those of the input `a`. The size of the last two dimensions depends on the value of `full_matrices`. Only returned when `compute_uv` is True. S : (..., K) array Vector(s) with the singular values, within each vector sorted in descending order. The first ``a.ndim - 2`` dimensions have the same size as those of the input `a`. Vh : { (..., N, N), (..., K, N) } array Unitary array(s). The first ``a.ndim - 2`` dimensions have the same size as those of the input `a`. The size of the last two dimensions depends on the value of `full_matrices`. Only returned when `compute_uv` is True. Raises ------ LinAlgError If SVD computation does not converge. See Also -------- scipy.linalg.svd : Similar function in SciPy. scipy.linalg.svdvals : Compute singular values of a matrix. Notes ----- The decomposition is performed using LAPACK routine ``_gesdd``. SVD is usually described for the factorization of a 2D matrix :math:`A`. The higher-dimensional case will be discussed below. In the 2D case, SVD is written as :math:`A = U S V^H`, where :math:`A = a`, :math:`U= u`, :math:`S= \mathtt{np.diag}(s)` and :math:`V^H = vh`. The 1D array `s` contains the singular values of `a` and `u` and `vh` are unitary. The rows of `vh` are the eigenvectors of :math:`A^H A` and the columns of `u` are the eigenvectors of :math:`A A^H`. In both cases the corresponding (possibly non-zero) eigenvalues are given by ``s**2``. If `a` has more than two dimensions, then broadcasting rules apply, as explained in :ref:`routines.linalg-broadcasting`. This means that SVD is working in "stacked" mode: it iterates over all indices of the first ``a.ndim - 2`` dimensions and for each combination SVD is applied to the last two indices. The matrix `a` can be reconstructed from the decomposition with either ``(u * s[..., None, :]) @ vh`` or ``u @ (s[..., None] * vh)``. (The ``@`` operator can be replaced by the function ``np.matmul`` for python versions below 3.5.) If `a` is a ``matrix`` object (as opposed to an ``ndarray``), then so are all the return values. Examples -------- >>> import numpy as np >>> rng = np.random.default_rng() >>> a = rng.normal(size=(9, 6)) + 1j*rng.normal(size=(9, 6)) >>> b = rng.normal(size=(2, 7, 8, 3)) + 1j*rng.normal(size=(2, 7, 8, 3)) Reconstruction based on full SVD, 2D case: >>> U, S, Vh = np.linalg.svd(a, full_matrices=True) >>> U.shape, S.shape, Vh.shape ((9, 9), (6,), (6, 6)) >>> np.allclose(a, np.dot(U[:, :6] * S, Vh)) True >>> smat = np.zeros((9, 6), dtype=complex) >>> smat[:6, :6] = np.diag(S) >>> np.allclose(a, np.dot(U, np.dot(smat, Vh))) True Reconstruction based on reduced SVD, 2D case: >>> U, S, Vh = np.linalg.svd(a, full_matrices=False) >>> U.shape, S.shape, Vh.shape ((9, 6), (6,), (6, 6)) >>> np.allclose(a, np.dot(U * S, Vh)) True >>> smat = np.diag(S) >>> np.allclose(a, np.dot(U, np.dot(smat, Vh))) True Reconstruction based on full SVD, 4D case: >>> U, S, Vh = np.linalg.svd(b, full_matrices=True) >>> U.shape, S.shape, Vh.shape ((2, 7, 8, 8), (2, 7, 3), (2, 7, 3, 3)) >>> np.allclose(b, np.matmul(U[..., :3] * S[..., None, :], Vh)) True >>> np.allclose(b, np.matmul(U[..., :3], S[..., None] * Vh)) True Reconstruction based on reduced SVD, 4D case: >>> U, S, Vh = np.linalg.svd(b, full_matrices=False) >>> U.shape, S.shape, Vh.shape ((2, 7, 8, 3), (2, 7, 3), (2, 7, 3, 3)) >>> np.allclose(b, np.matmul(U * S[..., None, :], Vh)) True >>> np.allclose(b, np.matmul(U, S[..., None] * Vh)) True r"N.raxisrzD->DdDzd->dddrrrrFrrEr)numpyrrrJrArKtake_along_axisrO conjugatertr rLrrrrUsvd_fsvd_srr<rrrr )rrRrSrT_nxrsusgnsidxrLrrrrrrvhs rer r gs=PmGA 7DAq'CAA1:c4R4i(D%%cb%9C##A"#5A##ACqL'9#CA13a<001;;=BT!Wab2 2 AAA73"9% %qa.KA 7723>> np.linalg.svdvals([[1, 2, 3, 4, 5], ... [1, 4, 9, 16, 25], ... [1, 8, 27, 64, 125]]) array([146.68862757, 5.57510612, 0.60393245]) Determine the rank of a matrix using singular values: >>> s = np.linalg.svdvals([[1, 2, 3], ... [2, 4, 6], ... [-1, 1, -1]]); s array([8.38434191e+00, 1.64402274e+00, 2.31534378e-16]) >>> np.count_nonzero(s > 1e-10) # Matrix of rank 2 2 FrSrT)r res rerr's^ qUe 44rdcU4$rr\)rfps re_cond_dispatcherrlYrrdc6[U5n[U5(a [S5eUb US:XdUS:Xa:[USS9n[ SS9 US:Xa US US - nO US US - nSSS5 O[ U5 [ U5 [U5upE[U5(aS OS n[ SS9 [R"XS 9n[XSS9[XqSS9-nSSS5 WRUSS9n[W5n[U5nUR5(aEU[U5RSS9)-nURS:a [ X8'OU(a [ US'URS:XaUSnU$!,(df  N=f!,(df  N=f)a Compute the condition number of a matrix. This function is capable of returning the condition number using one of seven different norms, depending on the value of `p` (see Parameters below). Parameters ---------- x : (..., M, N) array_like The matrix whose condition number is sought. p : {None, 1, -1, 2, -2, inf, -inf, 'fro'}, optional Order of the norm used in the condition number computation: ===== ============================ p norm for matrices ===== ============================ None 2-norm, computed directly using the ``SVD`` 'fro' Frobenius norm inf max(sum(abs(x), axis=1)) -inf min(sum(abs(x), axis=1)) 1 max(sum(abs(x), axis=0)) -1 min(sum(abs(x), axis=0)) 2 2-norm (largest sing. value) -2 smallest singular value ===== ============================ inf means the `numpy.inf` object, and the Frobenius norm is the root-of-sum-of-squares norm. Returns ------- c : {float, inf} The condition number of the matrix. May be infinite. See Also -------- numpy.linalg.norm Notes ----- The condition number of `x` is defined as the norm of `x` times the norm of the inverse of `x` [1]_; the norm can be the usual L2-norm (root-of-sum-of-squares) or one of a number of other matrix norms. References ---------- .. [1] G. Strang, *Linear Algebra and Its Applications*, Orlando, FL, Academic Press, Inc., 1980, pg. 285. Examples -------- >>> import numpy as np >>> from numpy import linalg as LA >>> a = np.array([[1, 0, -1], [0, 1, 0], [1, 0, 1]]) >>> a array([[ 1, 0, -1], [ 0, 1, 0], [ 1, 0, 1]]) >>> LA.cond(a) 1.4142135623730951 >>> LA.cond(a, 'fro') 3.1622776601683795 >>> LA.cond(a, np.inf) 2.0 >>> LA.cond(a, -np.inf) 1.0 >>> LA.cond(a, 1) 2.0 >>> LA.cond(a, -1) 1.0 >>> LA.cond(a, 2) 1.4142135623730951 >>> LA.cond(a, -2) 0.70710678118654746 # may vary >>> (min(LA.svd(a, compute_uv=False)) * ... min(LA.svd(LA.inv(a), compute_uv=False))) 0.70710678118654746 # may vary z#cond is not defined on empty arraysNrrFrSr)r3).r).r"rrrrrrWrr"r\)r'rrr r<rrrrrUrrrrIanyrr4) rfrkr_rrrrinvxnan_masks rerr]sxd  AA?@@yAFa2g e $ ( #BwgJ6*fI' * $ # 1q!!!n +A..FF ( # $$Q>> import numpy as np >>> from numpy.linalg import matrix_rank >>> matrix_rank(np.eye(4)) # Full rank matrix 4 >>> I=np.eye(4); I[-1,-1] = 0. # rank deficient matrix >>> matrix_rank(I) 3 >>> matrix_rank(np.ones((4,))) # 1 dimension - rank 1 unless all 0 1 >>> matrix_rank(np.zeros((4,))) 0 Nz#`tol` and `rtol` can't be both set.rr"Frir.rTrXkeepdimsrW) rr'rintr3r maxrr;repsr2rH)rurvrTrsrws rerrsx CO>?? Avvzs16{?## A%95A { <qwwrs|$uQWW~'9'99D4=g.Deede+d2cl3<( r **rdcU4$rr\)rrcondrTrss re_pinv_dispatcherrLrrdc [U5upUcKU[LaSnOTUc9[URSS5[ UR 5R -nOUnOU[La [S5e[U5n[U5(a>URSSupV[URSSXe4-UR S9nU"U5$UR5n[USUS9upn US[4[U S S S 9-n X:n [S XU S 9n SX)'[![#U 5[%U S[4[#U555nU"U5$)a) Compute the (Moore-Penrose) pseudo-inverse of a matrix. Calculate the generalized inverse of a matrix using its singular-value decomposition (SVD) and including all *large* singular values. Parameters ---------- a : (..., M, N) array_like Matrix or stack of matrices to be pseudo-inverted. rcond : (...) array_like of float, optional Cutoff for small singular values. Singular values less than or equal to ``rcond * largest_singular_value`` are set to zero. Broadcasts against the stack of matrices. Default: ``1e-15``. hermitian : bool, optional If True, `a` is assumed to be Hermitian (symmetric if real-valued), enabling a more efficient method for finding singular values. Defaults to False. rtol : (...) array_like of float, optional Same as `rcond`, but it's an Array API compatible parameter name. Only `rcond` or `rtol` can be set at a time. If none of them are provided then NumPy's ``1e-15`` default is used. If ``rtol=None`` is passed then the API standard default is used. .. versionadded:: 2.0.0 Returns ------- B : (..., N, M) ndarray The pseudo-inverse of `a`. If `a` is a `matrix` instance, then so is `B`. Raises ------ LinAlgError If the SVD computation does not converge. See Also -------- scipy.linalg.pinv : Similar function in SciPy. scipy.linalg.pinvh : Compute the (Moore-Penrose) pseudo-inverse of a Hermitian matrix. Notes ----- The pseudo-inverse of a matrix A, denoted :math:`A^+`, is defined as: "the matrix that 'solves' [the least-squares problem] :math:`Ax = b`," i.e., if :math:`\bar{x}` is said solution, then :math:`A^+` is that matrix such that :math:`\bar{x} = A^+b`. It can be shown that if :math:`Q_1 \Sigma Q_2^T = A` is the singular value decomposition of A, then :math:`A^+ = Q_2 \Sigma^+ Q_1^T`, where :math:`Q_{1,2}` are orthogonal matrices, :math:`\Sigma` is a diagonal matrix consisting of A's so-called singular values, (followed, typically, by zeros), and then :math:`\Sigma^+` is simply the diagonal matrix consisting of the reciprocals of A's singular values (again, followed by zeros). [1]_ References ---------- .. [1] G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando, FL, Academic Press, Inc., 1980, pp. 139-142. Examples -------- The following example checks that ``a * a+ * a == a`` and ``a+ * a * a+ == a+``: >>> import numpy as np >>> rng = np.random.default_rng() >>> a = rng.normal(size=(9, 6)) >>> B = np.linalg.pinv(a) >>> np.allclose(a, np.dot(a, np.dot(B, a))) True >>> np.allclose(B, np.dot(B, np.dot(a, B))) True NgV瞯>> import numpy as np >>> a = np.array([[1, 2], [3, 4]]) >>> (sign, logabsdet) = np.linalg.slogdet(a) >>> (sign, logabsdet) (-1, 0.69314718055994529) # may vary >>> sign * np.exp(logabsdet) -2.0 Computing log-determinants for a stack of matrices: >>> a = np.array([ [[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]] ]) >>> a.shape (3, 2, 2) >>> sign, logabsdet = np.linalg.slogdet(a) >>> (sign, logabsdet) (array([-1., -1., -1.]), array([ 0.69314718, 1.09861229, 2.07944154])) >>> sign * np.exp(logabsdet) array([-2., -3., -8.]) This routine succeeds where ordinary `det` does not: >>> np.linalg.det(np.eye(500) * 0.1) 0.0 >>> np.linalg.slogdet(np.eye(500) * 0.1) (1, -1151.2925464970228) zD->DdrNrFr) r'rrrrrrUr rrp)rrrreal_trrJlogdets rer r sR  Aq1a.KA x F(++I ((@LD ;;xe ,D ]]6] .F  &&rdc[U5n[U5 [U5 [U5up[ U5(aSOSn[ R "XS9nURUSS9nU$)a Compute the determinant of an array. Parameters ---------- a : (..., M, M) array_like Input array to compute determinants for. Returns ------- det : (...) array_like Determinant of `a`. See Also -------- slogdet : Another way to represent the determinant, more suitable for large matrices where underflow/overflow may occur. scipy.linalg.det : Similar function in SciPy. Notes ----- Broadcasting rules apply, see the `numpy.linalg` documentation for details. The determinant is computed via LU factorization using the LAPACK routine ``z/dgetrf``. Examples -------- The determinant of a 2-D array [[a, b], [c, d]] is ad - bc: >>> import numpy as np >>> a = np.array([[1, 2], [3, 4]]) >>> np.linalg.det(a) -2.0 # may vary Computing determinants for a stack of matrices: >>> a = np.array([ [[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]] ]) >>> a.shape (3, 2, 2) >>> np.linalg.det(a) array([-2., -3., -8.]) rrrFr)r'rrrrrUr r)rrrrrs rer r  sa^  Aq1a.KA'**I!1A &A HrdcX4$rr\)rrrs re_lstsq_dispatcherrV rrdc[U5up[U5upURS:HnU(a USS2[4n[X5 URSSupgURSSupXh:wa [ S5e[ X5up[U 5n Uc![U 5R[Xv5-n[U 5(aSOSn U S:Xa([URSSXiS-4-URS9n[[S S S S S 9 [ R""XUU S 9upnnSSS5 US:XaSWS 'U S:XaWS SU 24nWS SU 24nU(aWR%SS9nWU:wdXg::a ['/U 5nWR)U SS9nWR)U SS9nWR)U SS9nU"U5U"U5UU4$!,(df  N=f)a Return the least-squares solution to a linear matrix equation. Computes the vector `x` that approximately solves the equation ``a @ x = b``. The equation may be under-, well-, or over-determined (i.e., the number of linearly independent rows of `a` can be less than, equal to, or greater than its number of linearly independent columns). If `a` is square and of full rank, then `x` (but for round-off error) is the "exact" solution of the equation. Else, `x` minimizes the Euclidean 2-norm :math:`||b - ax||`. If there are multiple minimizing solutions, the one with the smallest 2-norm :math:`||x||` is returned. Parameters ---------- a : (M, N) array_like "Coefficient" matrix. b : {(M,), (M, K)} array_like Ordinate or "dependent variable" values. If `b` is two-dimensional, the least-squares solution is calculated for each of the `K` columns of `b`. rcond : float, optional Cut-off ratio for small singular values of `a`. For the purposes of rank determination, singular values are treated as zero if they are smaller than `rcond` times the largest singular value of `a`. The default uses the machine precision times ``max(M, N)``. Passing ``-1`` will use machine precision. .. versionchanged:: 2.0 Previously, the default was ``-1``, but a warning was given that this would change. Returns ------- x : {(N,), (N, K)} ndarray Least-squares solution. If `b` is two-dimensional, the solutions are in the `K` columns of `x`. residuals : {(1,), (K,), (0,)} ndarray Sums of squared residuals: Squared Euclidean 2-norm for each column in ``b - a @ x``. If the rank of `a` is < N or M <= N, this is an empty array. If `b` is 1-dimensional, this is a (1,) shape array. Otherwise the shape is (K,). rank : int Rank of matrix `a`. s : (min(M, N),) ndarray Singular values of `a`. Raises ------ LinAlgError If computation does not converge. See Also -------- scipy.linalg.lstsq : Similar function in SciPy. Notes ----- If `b` is a matrix, then all array results are returned as matrices. Examples -------- Fit a line, ``y = mx + c``, through some noisy data-points: >>> import numpy as np >>> x = np.array([0, 1, 2, 3]) >>> y = np.array([-1, 0.2, 0.9, 2.1]) By examining the coefficients, we see that the line should have a gradient of roughly 1 and cut the y-axis at, more or less, -1. We can rewrite the line equation as ``y = Ap``, where ``A = [[x 1]]`` and ``p = [[m], [c]]``. Now use `lstsq` to solve for `p`: >>> A = np.vstack([x, np.ones(len(x))]).T >>> A array([[ 0., 1.], [ 1., 1.], [ 2., 1.], [ 3., 1.]]) >>> m, c = np.linalg.lstsq(A, y)[0] >>> m, c (1.0 -0.95) # may vary Plot the data along with the fitted line: >>> import matplotlib.pyplot as plt >>> _ = plt.plot(x, y, 'o', label='Original data', markersize=10) >>> _ = plt.plot(x, m*x + c, 'r', label='Fitted line') >>> _ = plt.legend() >>> plt.show() rNrzIncompatible dimensionsz DDd->Ddidz ddd->ddidr"rrrrr.rrWFrT)rrr2rrrrrr;r}r|rr(rr<rrUrsqueezer&r)rrrrris_1drrm2n_rhsrr result_real_trrfresidsrankr_s rerrZ sB a=DAmGA FFaKE ajMq 77235(a[AS US 35e[1U5n X-n [8R:"XUS9nU[CXRS 9-nU$[-U5S:XGaUup[EX5n [EX5nX:Xa [AS 5eUS:Xa[GX U[H5nGOvUS:Xa[GX U[J5nGO]US:Xa7X:aUS-n[8R:"[1U5U S9R3US9nGO U[.:Xa6X:aU S-n [8R:"[1U5US9R3U S9nOUS:Xa6X:aUS-n[8R:"[1U5U S9R5US9nOU[.*:Xa6X:aU S-n [8R:"[1U5US9R5U S9nOcUS;a:[[8R:"UR=5U-RUS95nO#US:Xa[GX U[65nO [AS5eU(a4[MURN5nSXS 'SXS'URU5nU$[AS5e![(an [+S5U eSn A ff=f)a- Matrix or vector norm. This function is able to return one of eight different matrix norms, or one of an infinite number of vector norms (described below), depending on the value of the ``ord`` parameter. Parameters ---------- x : array_like Input array. If `axis` is None, `x` must be 1-D or 2-D, unless `ord` is None. If both `axis` and `ord` are None, the 2-norm of ``x.ravel`` will be returned. ord : {int, float, inf, -inf, 'fro', 'nuc'}, optional Order of the norm (see table under ``Notes`` for what values are supported for matrices and vectors respectively). inf means numpy's `inf` object. The default is None. axis : {None, int, 2-tuple of ints}, optional. If `axis` is an integer, it specifies the axis of `x` along which to compute the vector norms. If `axis` is a 2-tuple, it specifies the axes that hold 2-D matrices, and the matrix norms of these matrices are computed. If `axis` is None then either a vector norm (when `x` is 1-D) or a matrix norm (when `x` is 2-D) is returned. The default is None. keepdims : bool, optional If this is set to True, the axes which are normed over are left in the result as dimensions with size one. With this option the result will broadcast correctly against the original `x`. Returns ------- n : float or ndarray Norm of the matrix or vector(s). See Also -------- scipy.linalg.norm : Similar function in SciPy. Notes ----- For values of ``ord < 1``, the result is, strictly speaking, not a mathematical 'norm', but it may still be useful for various numerical purposes. The following norms can be calculated: ===== ============================ ========================== ord norm for matrices norm for vectors ===== ============================ ========================== None Frobenius norm 2-norm 'fro' Frobenius norm -- 'nuc' nuclear norm -- inf max(sum(abs(x), axis=1)) max(abs(x)) -inf min(sum(abs(x), axis=1)) min(abs(x)) 0 -- sum(x != 0) 1 max(sum(abs(x), axis=0)) as below -1 min(sum(abs(x), axis=0)) as below 2 2-norm (largest sing. value) as below -2 smallest singular value as below other -- sum(abs(x)**ord)**(1./ord) ===== ============================ ========================== The Frobenius norm is given by [1]_: :math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}` The nuclear norm is the sum of the singular values. Both the Frobenius and nuclear norm orders are only defined for matrices and raise a ValueError when ``x.ndim != 2``. References ---------- .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*, Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15 Examples -------- >>> import numpy as np >>> from numpy import linalg as LA >>> a = np.arange(9) - 4 >>> a array([-4, -3, -2, ..., 2, 3, 4]) >>> b = a.reshape((3, 3)) >>> b array([[-4, -3, -2], [-1, 0, 1], [ 2, 3, 4]]) >>> LA.norm(a) 7.745966692414834 >>> LA.norm(b) 7.745966692414834 >>> LA.norm(b, 'fro') 7.745966692414834 >>> LA.norm(a, np.inf) 4.0 >>> LA.norm(b, np.inf) 9.0 >>> LA.norm(a, -np.inf) 0.0 >>> LA.norm(b, -np.inf) 2.0 >>> LA.norm(a, 1) 20.0 >>> LA.norm(b, 1) 7.0 >>> LA.norm(a, -1) -4.6566128774142013e-010 >>> LA.norm(b, -1) 6.0 >>> LA.norm(a, 2) 7.745966692414834 >>> LA.norm(b, 2) 7.3484692283495345 >>> LA.norm(a, -2) 0.0 >>> LA.norm(b, -2) 1.8570331885190563e-016 # may vary >>> LA.norm(a, 3) 5.8480354764257312 # may vary >>> LA.norm(a, -3) 0.0 Using the `axis` argument to compute vector norms: >>> c = np.array([[ 1, 2, 3], ... [-1, 1, 4]]) >>> LA.norm(c, axis=0) array([ 1.41421356, 2.23606798, 5. ]) >>> LA.norm(c, axis=1) array([ 3.74165739, 4.24264069]) >>> LA.norm(c, ord=1, axis=1) array([ 6., 6.]) Using the `axis` argument to compute matrix norms: >>> m = np.arange(8).reshape(2,2,2) >>> LA.norm(m, axis=(1,2)) array([ 3.74165739, 11.22497216]) >>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :]) (3.7416573867739413, 11.224972160321824) N)r)frorrK)orderz6'axis' must be None, an integer or a tuple of integersryr"zInvalid norm order 'z ' for vectorsrzDuplicate axes given.rrWr)Nrr)nucz Invalid norm order for matrices.z&Improper number of dimensions to norm.)(r'rrrr0rErfloatrrrr<r;r5r8rtupler isinstancer{ Exceptionrrr4rAr|r1r9r6reduceconjstrrrMrSrr?r>rr)rfrrXrzrx_realx_imagsqnormrndr r_absxrr ret_shapes rerr sSl  A aggllWg$6 7 7 HHUO |vv [ L TQY AX$!)c"AQWW\\**F+fjj.@@qv,Ckk$s(+J B |U2Y e $ $ t9D w 4yA~ #:q6::4:; ; SD[q6::4:; ; AXa %$2  AX::c!f4C C [C1HA##A 1(CD DS ! !3C5 FG Gq6D LD**Tx@C Js))4 4CJ Ta!'5'5  45 5 !8!!x>C BY!!x>C AX"A **SV(377X7FC CZ"A **SV(377X7FC BY"A **SV(377X7FC SD["A **SV(377X7FC & &szz1668a<"5"5DABC E\!!x=C?@ @ QWW I!"I1g !"I1g ++i(C ABBU H  s S S/ S**S/rc#,# UShvN Uv gN 7frr\)rr s re_multidot_dispatcherr s Is  c`[U5nUS:a [S5eUS:Xa[USUSUS9$UVs/sHn[U5PM nnUSRUSRpTUSRS:Xa[ US5US'USRS:Xa[ US5R US'[U6 US:Xa[USUSUSUS9nO[U5n[XSUS- US9nUS:Xa US:XaUS$US:XdUS:XaUR5$U$s snf) ab Compute the dot product of two or more arrays in a single function call, while automatically selecting the fastest evaluation order. `multi_dot` chains `numpy.dot` and uses optimal parenthesization of the matrices [1]_ [2]_. Depending on the shapes of the matrices, this can speed up the multiplication a lot. If the first argument is 1-D it is treated as a row vector. If the last argument is 1-D it is treated as a column vector. The other arguments must be 2-D. Think of `multi_dot` as:: def multi_dot(arrays): return functools.reduce(np.dot, arrays) Parameters ---------- arrays : sequence of array_like If the first argument is 1-D it is treated as row vector. If the last argument is 1-D it is treated as column vector. The other arguments must be 2-D. out : ndarray, optional Output argument. This must have the exact kind that would be returned if it was not used. In particular, it must have the right type, must be C-contiguous, and its dtype must be the dtype that would be returned for `dot(a, b)`. This is a performance feature. Therefore, if these conditions are not met, an exception is raised, instead of attempting to be flexible. Returns ------- output : ndarray Returns the dot product of the supplied arrays. See Also -------- numpy.dot : dot multiplication with two arguments. References ---------- .. [1] Cormen, "Introduction to Algorithms", Chapter 15.2, p. 370-378 .. [2] https://en.wikipedia.org/wiki/Matrix_chain_multiplication Examples -------- `multi_dot` allows you to write:: >>> import numpy as np >>> from numpy.linalg import multi_dot >>> # Prepare some data >>> A = np.random.random((10000, 100)) >>> B = np.random.random((100, 1000)) >>> C = np.random.random((1000, 5)) >>> D = np.random.random((5, 333)) >>> # the actual dot multiplication >>> _ = multi_dot([A, B, C, D]) instead of:: >>> _ = np.dot(np.dot(np.dot(A, B), C), D) >>> # or >>> _ = A.dot(B).dot(C).dot(D) Notes ----- The cost for a matrix multiplication can be calculated with the following function:: def cost(A, B): return A.shape[0] * A.shape[1] * B.shape[1] Assume we have three matrices :math:`A_{10x100}, B_{100x5}, C_{5x50}`. The costs for the two different parenthesizations are as follows:: cost((AB)C) = 10*100*5 + 10*5*50 = 5000 + 2500 = 7500 cost(A(BC)) = 10*100*50 + 100*5*50 = 50000 + 25000 = 75000 rzExpecting at least two arrays.r"rrrr)r"r") rrr5rDrrBrIr_multi_dot_three_multi_dot_matrix_chain_order _multi_dotr)rr rr ndim_first ndim_lastrrs rerr sCj F A1u9:: a6!9fQiS11%+ ,VjmVF ,#1INNF2JOO ay~~vay)q  bz!r +--r  Av!&)VAYq sK-f5F1a!e=Q9>d| qIN||~ 3-sD+cURupEURupgXF-XW--nXW-XF--n X:a[[X5X#S9$[U[X5US9$)z Find the best order for three arrays and do the multiplication. For three arguments `_multi_dot_three` is approximately 15 times faster than `_multi_dot_matrix_chain_order` r)rr5) ruBCr a0a1b0b1c0c1cost1cost2s rerr s_wwHBwwHD I #E I #E }3q9a))1c!iS))rdc[U5nUVs/sHo3RSPM snUSRS/-n[X"4[S9n[ X"4[ S9n[ SU5Hqn[ X'- 5H]nX-n [XXU 4'[ X5H=n XXU 4XZS-U 4-XHXJS--XIS---n XX4:dM3XX4'XX4'M? M_ Ms U(aXe4$U$s snf)a Return a np.array that encodes the optimal order of multiplications. The optimal order array is then used by `_multi_dot()` to do the multiplication. Also return the cost matrix if `return_costs` is `True` The implementation CLOSELY follows Cormen, "Introduction to Algorithms", Chapter 15.2, p. 370-378. Note that Cormen uses 1-based indices. cost[i, j] = min([ cost[prefix] + cost[suffix] + cost_mult(prefix, suffix) for k in range(i, j)]) r"rrr)rrr(r-r)rCrr4) r return_costsrrrkrr_lijrr8s rerr s " F A$$VV$r (8(8(;'< 0: off-diagonal above the main diagonal. * offset < 0: off-diagonal below the main diagonal. Returns ------- out : (...,min(N,M)) ndarray An array containing the diagonals and whose shape is determined by removing the last two dimensions and appending a dimension equal to the size of the resulting diagonals. The returned array must have the same data type as ``x``. See Also -------- numpy.diagonal Examples -------- >>> a = np.arange(4).reshape(2, 2); a array([[0, 1], [2, 3]]) >>> np.linalg.diagonal(a) array([0, 3]) A 3-D example: >>> a = np.arange(8).reshape(2, 2, 2); a array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]]) >>> np.linalg.diagonal(a) array([[0, 3], [4, 7]]) Diagonals adjacent to the main diagonal can be obtained by using the `offset` argument: >>> a = np.arange(9).reshape(3, 3) >>> a array([[0, 1, 2], [3, 4, 5], [6, 7, 8]]) >>> np.linalg.diagonal(a, offset=1) # First superdiagonal array([1, 5]) >>> np.linalg.diagonal(a, offset=2) # Second superdiagonal array([2]) >>> np.linalg.diagonal(a, offset=-1) # First subdiagonal array([3, 7]) >>> np.linalg.diagonal(a, offset=-2) # Second subdiagonal array([6]) The anti-diagonal can be obtained by reversing the order of elements using either `numpy.flipud` or `numpy.fliplr`. >>> a = np.arange(9).reshape(3, 3) >>> a array([[0, 1, 2], [3, 4, 5], [6, 7, 8]]) >>> np.linalg.diagonal(np.fliplr(a)) # Horizontal flip array([2, 4, 6]) >>> np.linalg.diagonal(np.flipud(a)) # Vertical flip array([6, 4, 2]) Note that the order in which the diagonal is retrieved varies depending on the flip function. rr)axis1axis2)_core_diagonalrs rerr sn !2R 88rd)rrcU4$rr\rfrrs re_trace_dispatcherr> rrdc[XSSUS9$)a Returns the sum along the specified diagonals of a matrix (or a stack of matrices) ``x``. This function is Array API compatible, contrary to :py:func:`numpy.trace`. Parameters ---------- x : (...,M,N) array_like Input array having shape (..., M, N) and whose innermost two dimensions form MxN matrices. offset : int, optional Offset specifying the off-diagonal relative to the main diagonal, where:: * offset = 0: the main diagonal. * offset > 0: off-diagonal above the main diagonal. * offset < 0: off-diagonal below the main diagonal. dtype : dtype, optional Data type of the returned array. Returns ------- out : ndarray An array containing the traces and whose shape is determined by removing the last two dimensions and storing the traces in the last array dimension. For example, if x has rank k and shape: (I, J, K, ..., L, M, N), then an output array has rank k-2 and shape: (I, J, K, ..., L) where:: out[i, j, k, ..., l] = trace(a[i, j, k, ..., l, :, :]) The returned array must have a data type as described by the dtype parameter above. See Also -------- numpy.trace Examples -------- >>> np.linalg.trace(np.eye(3)) 3.0 >>> a = np.arange(8).reshape((2, 2, 2)) >>> np.linalg.trace(a) array([3, 11]) Trace is computed with the last two axes as the 2-d sub-arrays. This behavior differs from :py:func:`numpy.trace` which uses the first two axes by default. >>> a = np.arange(24).reshape((3, 2, 2, 2)) >>> np.linalg.trace(a).shape (3, 2) Traces adjacent to the main diagonal can be obtained by using the `offset` argument: >>> a = np.arange(9).reshape((3, 3)); a array([[0, 1, 2], [3, 4, 5], [6, 7, 8]]) >>> np.linalg.trace(a, offset=1) # First superdiagonal 6 >>> np.linalg.trace(a, offset=2) # Second superdiagonal 2 >>> np.linalg.trace(a, offset=-1) # First subdiagonal 10 >>> np.linalg.trace(a, offset=-2) # Second subdiagonal 6 rr)rrr) _core_tracers rerrB sX q"E BBrdrWcX4$rr\rrrXs re_cross_dispatcherr s 9rdrc[U5n[U5nURUS:wdURUS:wa,[SURUSURUS35e[XUS9$)a Returns the cross product of 3-element vectors. If ``x1`` and/or ``x2`` are multi-dimensional arrays, then the cross-product of each pair of corresponding 3-element vectors is independently computed. This function is Array API compatible, contrary to :func:`numpy.cross`. Parameters ---------- x1 : array_like The first input array. x2 : array_like The second input array. Must be compatible with ``x1`` for all non-compute axes. The size of the axis over which to compute the cross-product must be the same size as the respective axis in ``x1``. axis : int, optional The axis (dimension) of ``x1`` and ``x2`` containing the vectors for which to compute the cross-product. Default: ``-1``. Returns ------- out : ndarray An array containing the cross products. See Also -------- numpy.cross Examples -------- Vector cross-product. >>> x = np.array([1, 2, 3]) >>> y = np.array([4, 5, 6]) >>> np.linalg.cross(x, y) array([-3, 6, -3]) Multiple vector cross-products. Note that the direction of the cross product vector is defined by the *right-hand rule*. >>> x = np.array([[1,2,3], [4,5,6]]) >>> y = np.array([[4,5,6], [1,2,3]]) >>> np.linalg.cross(x, y) array([[-3, 6, -3], [ 3, -6, 3]]) >>> x = np.array([[1, 2], [3, 4], [5, 6]]) >>> y = np.array([[4, 5], [6, 1], [2, 3]]) >>> np.linalg.cross(x, y, axis=0) array([[-24, 6], [ 18, 24], [-6, -18]]) rzJBoth input arrays must be (arrays of) 3-dimensional vectors, but they are z and z dimensional instead.rW)rDrr _core_crossrs rerr sx BB BB xx~bhhtn1 HHTN+5$0@A# #  rD ))rdcX4$rr\rs re_matmul_dispatcherr rrdc[X5$)a. Computes the matrix product. This function is Array API compatible, contrary to :func:`numpy.matmul`. Parameters ---------- x1 : array_like The first input array. x2 : array_like The second input array. Returns ------- out : ndarray The matrix product of the inputs. This is a scalar only when both ``x1``, ``x2`` are 1-d vectors. Raises ------ ValueError If the last dimension of ``x1`` is not the same size as the second-to-last dimension of ``x2``. If a scalar value is passed in. See Also -------- numpy.matmul Examples -------- For 2-D arrays it is the matrix product: >>> a = np.array([[1, 0], ... [0, 1]]) >>> b = np.array([[4, 1], ... [2, 2]]) >>> np.linalg.matmul(a, b) array([[4, 1], [2, 2]]) For 2-D mixed with 1-D, the result is the usual. >>> a = np.array([[1, 0], ... [0, 1]]) >>> b = np.array([1, 2]) >>> np.linalg.matmul(a, b) array([1, 2]) >>> np.linalg.matmul(b, a) array([1, 2]) Broadcasting is conventional for stacks of arrays >>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4)) >>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2)) >>> np.linalg.matmul(a,b).shape (2, 2, 2) >>> np.linalg.matmul(a, b)[0, 1, 1] 98 >>> sum(a[0, 1, :] * b[0 , :, 1]) 98 Vector, vector returns the scalar inner product, but neither argument is complex-conjugated: >>> np.linalg.matmul([2j, 3j], [2j, 3j]) (-13+0j) Scalar multiplication raises an error. >>> np.linalg.matmul([1,2], 3) Traceback (most recent call last): ... ValueError: matmul: Input operand 1 does not have enough dimensions ... ) _core_matmulrs rerr sb  rdrcX4$rr\rrrs re_tensordot_dispatcherr< rrdc[XUS9$)Nr)_core_tensordotrs rerr@ s 2 --rdcU4$rr\res re_matrix_transpose_dispatcherrJ rrdc[U5$r)_core_matrix_transposeres rerrM s !! $$rd)rzrcU4$rr\rfrzrs re_matrix_norm_dispatcherrW rrdrc.[U5n[USXS9$)a Computes the matrix norm of a matrix (or a stack of matrices) ``x``. This function is Array API compatible. Parameters ---------- x : array_like Input array having shape (..., M, N) and whose two innermost dimensions form ``MxN`` matrices. keepdims : bool, optional If this is set to True, the axes which are normed over are left in the result as dimensions with size one. Default: False. ord : {1, -1, 2, -2, inf, -inf, 'fro', 'nuc'}, optional The order of the norm. For details see the table under ``Notes`` in `numpy.linalg.norm`. See Also -------- numpy.linalg.norm : Generic norm function Examples -------- >>> from numpy import linalg as LA >>> a = np.arange(9) - 4 >>> a array([-4, -3, -2, ..., 2, 3, 4]) >>> b = a.reshape((3, 3)) >>> b array([[-4, -3, -2], [-1, 0, 1], [ 2, 3, 4]]) >>> LA.matrix_norm(b) 7.745966692414834 >>> LA.matrix_norm(b, ord='fro') 7.745966692414834 >>> LA.matrix_norm(b, ord=np.inf) 9.0 >>> LA.matrix_norm(b, ord=-np.inf) 2.0 >>> LA.matrix_norm(b, ord=1) 7.0 >>> LA.matrix_norm(b, ord=-1) 6.0 >>> LA.matrix_norm(b, ord=2) 7.3484692283495345 >>> LA.matrix_norm(b, ord=-2) 1.8570331885190563e-016 # may vary rorXrzr)rDrrs rerrZ sl 1 A 8 ==rdrcU4$rr\)rfrXrzrs re_vector_norm_dispatcherr rrdc ^ [U5n[UR5nUcUR5nSnO[ U[ 5(a[ XR5m [ U 4Sj[UR555nX-n[X5R[UVs/sHoRUPM sn[S9/UVs/sHoRUPM snQ75nSnOUn[XUS9n U(aS[ Uc[[U55OU[U55nUHnSXH'M U R[ U55n U $s snfs snf)a Computes the vector norm of a vector (or batch of vectors) ``x``. This function is Array API compatible. Parameters ---------- x : array_like Input array. axis : {None, int, 2-tuple of ints}, optional If an integer, ``axis`` specifies the axis (dimension) along which to compute vector norms. If an n-tuple, ``axis`` specifies the axes (dimensions) along which to compute batched vector norms. If ``None``, the vector norm must be computed over all array values (i.e., equivalent to computing the vector norm of a flattened array). Default: ``None``. keepdims : bool, optional If this is set to True, the axes which are normed over are left in the result as dimensions with size one. Default: False. ord : {int, float, inf, -inf}, optional The order of the norm. For details see the table under ``Notes`` in `numpy.linalg.norm`. See Also -------- numpy.linalg.norm : Generic norm function Examples -------- >>> from numpy import linalg as LA >>> a = np.arange(9) + 1 >>> a array([1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> b = a.reshape((3, 3)) >>> b array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> LA.vector_norm(b) 16.881943016134134 >>> LA.vector_norm(b, ord=np.inf) 9.0 >>> LA.vector_norm(b, ord=-np.inf) 1.0 >>> LA.vector_norm(b, ord=0) 9.0 >>> LA.vector_norm(b, ord=1) 45.0 >>> LA.vector_norm(b, ord=-1) 0.3534857623790153 >>> LA.vector_norm(b, ord=2) 16.881943016134134 >>> LA.vector_norm(b, ord=-2) 0.8058837395885292 r"c36># UHoT;dM Uv M g7frr\).0rnormalized_axiss re vector_norm.. sJ 1/1IQQ s  r)rXrr)rDrrrrrrTrr_core_transposerr@r{rr) rfrXrzrr_axisrestnewshaperrrs @rer r s4x 1 A ME | GGI D% /tVV<Jaff JJ; A ( 0 0$/$Qggaj$/s; &*+d''!*d+    q# &C%!%E#e* 4U AEHkk%,' J)0+s +E E" cX4$rr\rs re_vecdot_dispatcherr rrdc[XUS9$)a Computes the vector dot product. This function is restricted to arguments compatible with the Array API, contrary to :func:`numpy.vecdot`. Let :math:`\mathbf{a}` be a vector in ``x1`` and :math:`\mathbf{b}` be a corresponding vector in ``x2``. The dot product is defined as: .. math:: \mathbf{a} \cdot \mathbf{b} = \sum_{i=0}^{n-1} \overline{a_i}b_i over the dimension specified by ``axis`` and where :math:`\overline{a_i}` denotes the complex conjugate if :math:`a_i` is complex and the identity otherwise. Parameters ---------- x1 : array_like First input array. x2 : array_like Second input array. axis : int, optional Axis over which to compute the dot product. Default: ``-1``. Returns ------- output : ndarray The vector dot product of the input. See Also -------- numpy.vecdot Examples -------- Get the projected size along a given normal for an array of vectors. >>> v = np.array([[0., 5., 0.], [0., 0., 10.], [0., 6., 8.]]) >>> n = np.array([0., 0.6, 0.8]) >>> np.linalg.vecdot(v, n) array([ 3., 8., 10.]) rW) _core_vecdotrs rer!r! s\ T **rdr)r)r&)rC)NNN)TTF)NN)NF)NNF)F)r|__all__ functoolsrr.typingr#r$ numpy._utilsr% numpy._corer&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrrrrrrrr!rrrrrrrOrr!rnumpy._globalsrPnumpy.lib._twodim_base_implrQrRnumpy.lib.array_utilsrSrT numpy.linalgrU numpy._typingrVrXrhrkrprtpartialarray_function_dispatch fortran_intrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr$rrr@r rJrrrUr rgrrlrrwrrr r r rrrrrrrrrrrrrrrrrrrr rr\rdrers@  3"#             $1L&! zJ  $++ %%n   N*:)96.F*  *66FF$ ggww(  +$.#2 0 9 O E 7 &01K2K\*+[0,[0|./C!0C!P*+q3,q3h12q3ql)--.!c0/c0R*+C),C)R(G&)G&X*+X*,X*v-.Z5/Z5x*+V?,V?r-.P#/P#j)x*xv,-.5..5b)*u +u p01l+dl+2l+bD)*oo+oj*+Q',Q'h*+5 ,5 t*+Q*,Q*h8)*C+CH)- -.!t/tn**&)R *.-.V9/V9v'+$*+4KC,KC`*.*+E*,E*T+,P -P j.2./!".0.$++  56%7%299 /301"'U6>26>v+/401"U]2]D+/+, -+--+rd