[hSrSSKJr SSKJr SSjrSrSrSrSS jr \SS j5r \SS j5r \SS j5r \SS j5r SSjrSSjr\SSj5r\SSj5r\SSj5rg)a The symmetric eigenvalue problem. --------------------------------- This file contains routines for the symmetric eigenvalue problem. high level routines: eigsy : real symmetric (ordinary) eigenvalue problem eighe : complex hermitian (ordinary) eigenvalue problem eigh : unified interface for eigsy and eighe svd_r : singular value decomposition for real matrices svd_c : singular value decomposition for complex matrices svd : unified interface for svd_r and svd_c low level routines: r_sy_tridiag : reduction of real symmetric matrix to real symmetric tridiagonal matrix c_he_tridiag_0 : reduction of complex hermitian matrix to real symmetric tridiagonal matrix c_he_tridiag_1 : auxiliary routine to c_he_tridiag_0 c_he_tridiag_2 : auxiliary routine to c_he_tridiag_0 tridiag_eigen : solves the real symmetric tridiagonal matrix eigenvalue problem svd_r_raw : raw singular value decomposition for real matrices svd_c_raw : raw singular value decomposition for complex matrices )xrange)defunc URn[US- SS5GHnSn[SU5HnU[XU45- nM Sn US:waSU- n US:XdUS:XdURU 5(aXS- U4X6'SX&'MkSn [SU5H nXU4==U -ss'XX4XU4-- n M" XS- U4n UR U 5n U S:aU *n X|-X6'XU --n X- XS- U4'Sn [SU5Hwn U(a XU4U - XU 4'Sn [SU S-5HnXX4XU4-- n M [U S-U5HnXX4XU4-- n M X- X='XU XU4-- n My U SU -- n[SU5HHn XU4n X=X-- n XU '[SU S-5HnXU 4==XU-XX4---ss'M! MJ XU'GM [SU5H nX6X6S- 'M SX5S- 'U(aSUS'[SU5HnX&S:wa^[SU5HNn Sn [SU5HnXXh4XU 4-- n M [SU5HnXU 4==XX4--ss'M MP XU4X&'SXU4'[SU5Hn S=XU4'XU 4'M M g[SU5H nXU4X&'M g)a This routine transforms a real symmetric matrix A to a real symmetric tridiagonal matrix T using an orthogonal similarity transformation: Q' * A * Q = T (here ' denotes the matrix transpose). The orthogonal matrix Q is build up from Householder reflectors. parameters: A (input/output) On input, A contains the real symmetric matrix of dimension (n,n). On output, if calc_ev is true, A contains the orthogonal matrix Q, otherwise A is destroyed. D (output) real array of length n, contains the diagonal elements of the tridiagonal matrix E (output) real array of length n, contains the offdiagonal elements of the tridiagonal matrix in E[0:(n-1)] where is the dimension of the matrix A. E[n-1] is undefined. calc_ev (input) If calc_ev is true, this routine explicitly calculates the orthogonal matrix Q which is then returned in A. If calc_ev is false, Q is not explicitly calculated resulting in a shorter run time. This routine is a python translation of the fortran routine tred2.f in the software library EISPACK (see netlib.org) which itself is based on the algol procedure tred2 described in: - Num. Math. 11, p.181-195 (1968) by Martin, Reinsch and Wilkonson - Handbook for auto. comp., Vol II, Linear Algebra, p.212-226 (1971) For a good introduction to Householder reflections, see also Stoer, Bulirsch - Introduction to Numerical Analysis. rrN)rowsrabsisinfsqrt)ctxADEcalc_evniscalek scale_invHFGjHHs W/var/www/auris/envauris/lib/python3.13/site-packages/mpmath/matrices/eigen_symmetric.py r_sy_tridiagr,srH A AE1b !1A SQ3[ E A:%I 6UaZ399Y#7#7qSU8ADAD  1A cFi F 13!aC& A c!eH HHQK q5Ay U 5A#a% 1AQ3!A#AAq1u%qsVa!f_$&AE1%qsVa!f_$&5AD 1A# A!a%[1AA#Arv AaDAq1u%A#!d(Q13Z//& !w"zAq\A# AcF!1Atqy1AA#Aq\qsVa!f_,*#Aq\A#!f*,* &qS6ADAcFAq\"##A#Q3"1AqS6ADc URnSXES- '[US- SS5GHnSn[SU5HCnU[URXU455[UR XU455-- nME Sn US:waSU- n US:XdUR U 5(aSX6'SX&'SXFS- 'MUS:Xa=XS- U4n [U 5n XU'SX&'U S:waXFU -U - XFS- 'O XFXFS- 'MSn [SU5HGnXU4==U -ss'URXU45n UR XU45nXU -X--- n MI XS- U4n [U 5n UR U 5nXU -- n X-X6'U S:waX- n XF*U -nX-nOXF*nXS- U4==U- ss'Sn [SU5HnUUU4U - XU4'Sn[SUS-5H!nXRXU45XU4-- nM# [US-U5HnXUU4XU4-- nM X- UU'XRUU5UUU4-- n M U SU -- n[SU5HjnUUU4n UUUU -- nXU'[SUS-5H>nXU4==URU 5XH-URU5XU4---ss'M@ Ml UXFS- 'XU'GM [SU5H nX6X6S- 'M SX5S- 'SUS'[SU5H$nX&nURXU45X&'UXU4'M& g)a This routine transforms a complex hermitian matrix A to a real symmetric tridiagonal matrix T using an unitary similarity transformation: Q' * A * Q = T (here ' denotes the hermitian matrix transpose, i.e. transposition und conjugation). The unitary matrix Q is build up from Householder reflectors and an unitary diagonal matrix. parameters: A (input/output) On input, A contains the complex hermitian matrix of dimension (n,n). On output, A contains the unitary matrix Q in compressed form. D (output) real array of length n, contains the diagonal elements of the tridiagonal matrix. E (output) real array of length n, contains the offdiagonal elements of the tridiagonal matrix in E[0:(n-1)] where is the dimension of the matrix A. E[n-1] is undefined. T (output) complex array of length n, contains a unitary diagonal matrix. This routine is a python translation (in slightly modified form) of the fortran routine htridi.f in the software library EISPACK (see netlib.org) which itself is a complex version of the algol procedure tred1 described in: - Num. Math. 11, p.181-195 (1968) by Martin, Reinsch and Wilkonson - Handbook for auto. comp., Vol II, Linear Algebra, p.212-226 (1971) For a good introduction to Householder reflections, see also Stoer, Bulirsch - Introduction to Numerical Analysis. rrrrN)r rr reimr r conj)r rrrTrrrrrrfrrriirTZrrzws rc_he_tridiag_0r)sD A AcF AE1b !1A SA#(3svva!f~+>> >E A:E I A:9--ADADAcF  6A#a%AAAaDADAvAA#A#  1A cFi FA#BA#B b27" "A  c!eH F HHQK U y 6A4!B FA$B A#a%A  1AqsVaZAcFAAq1u%XXa!f%A#..&AE1%qsVa!f_$&5AaD !A$!AaC&( (A!a%[1A!A#A!rAv AaDAq1u%A##((1+,sxx{QsV/CCC& A#!c"fAq\A# AcF AaD Aq\ Tvva!f~A#rc URn[SU5HnXU4S:wam[SU5H]nSn[SU5H!nX`RXU45XU4-- nM# [SU5HnXU4==XaXt4--ss'M M_ SXU4'[SU5HnS=XU4'XU4'M M [SU5H&n[SU5HnXU4==X'-ss'M M( g)a This routine forms the unitary matrix Q described in c_he_tridiag_0. parameters: A (input/output) On input, A is the same matrix as delivered by c_he_tridiag_0. On output, A is set to Q. T (input) On input, T is the same array as delivered by c_he_tridiag_0. rrNr rr")r rr#rrrrrs rc_he_tridiag_1r,1s A Aq\ qS6Q;Aq\1A!aC&)AcF22A&1AcFaAC&j(F& "A#1A AcFQsVAq\1A cFadNFrc URn[SU5H&n[SU5HnX6U4==X&-ss'M M( [SU5H|nXU4S:wdM[SU5H]nSn[SU5H!nXRXU45X6U4-- nM# [SU5HnX6U4==XXe4--ss'M M_ M~ g)a This routine applied the unitary matrix Q described in c_he_tridiag_0 onto the the matrix B, i.e. it forms Q*B. parameters: A (input) On input, A is the same matrix as delivered by c_he_tridiag_0. T (input) On input, T is the same array as delivered by c_he_tridiag_0. B (input/output) On input, B is a complex matrix. On output B is replaced by Q*B. This routine is a python translation of the fortran routine htribk.f in the software library EISPACK (see netlib.org). See c_he_tridiag_0 for more references. rNr+) r rr#Brrrrrs rc_he_tridiag_2r/Ts$ A Aq\1A cFadNFAq\ qS6Q;Aq\1A!aC&)AcF22A&1AcFaAC&j(F& "rc [U5nSX$S- 'SUR-n[U5GHnSnUnUS-U:XaOB[X(5UR[X5[XS-5--::aOUS-nMLX:XaM]Xu:a[ SU-5eUS- nXn XS-U - SX&-- n UR U S5n U S:aX- n OX-n XU - X&U - -n Supn [US- US- S5GHnXU-nXU-n[U5[U 5:a)X- n UR U S5n X-X.S-'SU - n X-n O(X- n UR U S5n X-X.S-'SU - n X-n XS-U - n XU - U -SU -U--n X-n X-XS-'X-U- n [U[5(aM[UR5H6nUUUS-4nXUU4-X--UUUS-4'XUU4-X-- UUU4'M8 GM XU - X'XU'SX('GM [SU5HnUS- nUnXn [UU5HnXU :aM UnUUn M UU:XaM:XUU'XU'[U[5(aM\[UR5HnUUU4n UUU4UUU4'XUU4'M M g)a This subroutine find the eigenvalues and the first components of the eigenvectors of a real symmetric tridiagonal matrix using the implicit QL method. parameters: d (input/output) real array of length n. on input, d contains the diagonal elements of the input matrix. on output, d contains the eigenvalues in ascending order. e (input) real array of length n. on input, e contains the offdiagonal elements of the input matrix in e[0:(n-1)]. On output, e has been destroyed. z (input/output) If z is equal to False, no eigenvectors will be computed. Otherwise on input z should have the format z[0:m,0:n] (i.e. a real or complex matrix of dimension (m,n) ). On output this matrix will be multiplied by the matrix of the eigenvectors (i.e. the columns of this matrix are the eigenvectors): z --> z*EV That means if z[i,j]={1 if j==j; 0 otherwise} on input, then on output z will contain the first m components of the eigenvectors. That means if m is equal to n, the i-th eigenvector will be z[:,i]. This routine is a python translation (in slightly modified form) of the fortran routine imtql2.f in the software library EISPACK (see netlib.org) which itself is based on the algol procudure imtql2 desribed in: - num. math. 12, p. 377-383(1968) by matrin and wilkinson - modified in num. math. 15, p. 450(1970) by dubrulle - handbook for auto. comp., vol. II-linear algebra, p. 241-248 (1971) See also the routine gaussq.f in netlog.org or acm algorithm 726. rrrzBtridiag_eigen: no convergence to an eigenvalue after %d iterations)rrrrN) lendpsrr eps RuntimeErrorhypot isinstanceboolr )r dezriterlimlrmpgrscrr$bwr&rs r tridiag_eigenrEys^D AA AcF#''kG AY Aq5A:qt93qt9s1U8}+D EEE v|"#gjq#qrr FAAq5A!ad(+A !QA1uEEq14!8#AGA!AE1q5"-!H!Hq6CF?A !QA uA!eHAAAA !QA uA!eHAAA!eHqLTAXNQUQY.E5a%EAI!!T**#AFF^a!eH#$1v:#5!AaC%#$1v:#5!A#,/.84!8ADaDAD}DQl F  DAAtqyA!A  6 t!!!T""AFF^acF1Q3!A#!A#$!rcU(dUR5nURURS5nURURS5nU(a[XXESS9 [ XUS5 U$[XXESS9 [ XXQ5 XA4$)aO This routine solves the (ordinary) eigenvalue problem for a real symmetric square matrix A. Given A, an orthogonal matrix Q is calculated which diagonalizes A: Q' A Q = diag(E) and Q Q' = Q' Q = 1 Here diag(E) is a diagonal matrix whose diagonal is E. ' denotes the transpose. The columns of Q are the eigenvectors of A and E contains the eigenvalues: A Q[:,i] = E[i] Q[:,i] input: A: real matrix of format (n,n) which is symmetric (i.e. A=A' or A[i,j]=A[j,i]) eigvals_only: if true, calculates only the eigenvalues E. if false, calculates both eigenvectors and eigenvalues. overwrite_a: if true, allows modification of A which may improve performance. if false, A is not modified. output: E: vector of format (n). contains the eigenvalues of A in ascending order. Q: orthogonal matrix of format (n,n). contains the eigenvectors of A as columns. return value: E if eigvals_only is true (E, Q) if eigvals_only is false example: >>> from mpmath import mp >>> A = mp.matrix([[3, 2], [2, 0]]) >>> E = mp.eigsy(A, eigvals_only = True) >>> print(E) [-1.0] [ 4.0] >>> A = mp.matrix([[1, 2], [2, 3]]) >>> E, Q = mp.eigsy(A) >>> print(mp.chop(A * Q[:,0] - E[0] * Q[:,0])) [0.0] [0.0] see also: eighe, eigh, eig rF)rT)copyzerosr rrE)r r eigvals_only overwrite_ar8r9s reigsyrKsxr  FFH !&&!A !&&!ASQU3ca'SQT2ca#v rcU(dUR5nURURS5nURURS5nURURS5nU(a[XXEU5 [ XUS5 U$[XXEU5 UR UR5n[ XXW5 [ XXg5 XG4$)a This routine solves the (ordinary) eigenvalue problem for a complex hermitian square matrix A. Given A, an unitary matrix Q is calculated which diagonalizes A: Q' A Q = diag(E) and Q Q' = Q' Q = 1 Here diag(E) a is diagonal matrix whose diagonal is E. ' denotes the hermitian transpose (i.e. ordinary transposition and complex conjugation). The columns of Q are the eigenvectors of A and E contains the eigenvalues: A Q[:,i] = E[i] Q[:,i] input: A: complex matrix of format (n,n) which is hermitian (i.e. A=A' or A[i,j]=conj(A[j,i])) eigvals_only: if true, calculates only the eigenvalues E. if false, calculates both eigenvectors and eigenvalues. overwrite_a: if true, allows modification of A which may improve performance. if false, A is not modified. output: E: vector of format (n). contains the eigenvalues of A in ascending order. Q: unitary matrix of format (n,n). contains the eigenvectors of A as columns. return value: E if eigvals_only is true (E, Q) if eigvals_only is false example: >>> from mpmath import mp >>> A = mp.matrix([[1, -3 - 1j], [-3 + 1j, -2]]) >>> E = mp.eighe(A, eigvals_only = True) >>> print(E) [-4.0] [ 3.0] >>> A = mp.matrix([[1, 2 + 5j], [2 - 5j, 3]]) >>> E, Q = mp.eighe(A) >>> print(mp.chop(A * Q[:,0] - E[0] * Q[:,0])) [0.0] [0.0] see also: eigsy, eigh, eig rF)rGrHr r)rEeyer/)r rrIrJr8r9tr.s reigherOAst  FFH !&&!A !&&!A !&&!AsqQ'ca'sqQ' GGAFFOca#sq$v rc|^[U4SjU55nU(aTRXUS9$TRXUS9$)a "eigh" is a unified interface for "eigsy" and "eighe". Depending on whether A is real or complex the appropriate function is called. This routine solves the (ordinary) eigenvalue problem for a real symmetric or complex hermitian square matrix A. Given A, an orthogonal (A real) or unitary (A complex) matrix Q is calculated which diagonalizes A: Q' A Q = diag(E) and Q Q' = Q' Q = 1 Here diag(E) a is diagonal matrix whose diagonal is E. ' denotes the hermitian transpose (i.e. ordinary transposition and complex conjugation). The columns of Q are the eigenvectors of A and E contains the eigenvalues: A Q[:,i] = E[i] Q[:,i] input: A: a real or complex square matrix of format (n,n) which is symmetric (i.e. A[i,j]=A[j,i]) or hermitian (i.e. A[i,j]=conj(A[j,i])). eigvals_only: if true, calculates only the eigenvalues E. if false, calculates both eigenvectors and eigenvalues. overwrite_a: if true, allows modification of A which may improve performance. if false, A is not modified. output: E: vector of format (n). contains the eigenvalues of A in ascending order. Q: an orthogonal or unitary matrix of format (n,n). contains the eigenvectors of A as columns. return value: E if eigvals_only is true (E, Q) if eigvals_only is false example: >>> from mpmath import mp >>> A = mp.matrix([[3, 2], [2, 0]]) >>> E = mp.eigh(A, eigvals_only = True) >>> print(E) [-1.0] [ 4.0] >>> A = mp.matrix([[1, 2], [2, 3]]) >>> E, Q = mp.eigh(A) >>> print(mp.chop(A * Q[:,0] - E[0] * Q[:,0])) [0.0] [0.0] >>> A = mp.matrix([[1, 2 + 5j], [2 - 5j, 3]]) >>> E, Q = mp.eigh(A) >>> print(mp.chop(A * Q[:,0] - E[0] * Q[:,0])) [0.0] [0.0] see also: eigsy, eighe, eig c3R># UHn[U5TRLv M g7fNtypempc.0xr s r eigh..21DGsww&$')rIrJ)anyrOrK)r rrIrJ iscomplexs` reighr_s?D222Iyy{ySSyy{ySSrc8URUS5nURUS5nURSU5nSUS'US:XaKSn[U5H8n U S-n URX-SU -U -URS5- - 5Xi'M: GODUS:XaaSn[U5HNn SURS5- XY'U S-n URX-SU -U -URS5- - 5Xi'MP GOUS:XaXURUR5n[U5H,n U S-n URXRS5- 5Xi'M. GOUS :Xa)Sn[U5Hn U S-n SU -S- XY'XU 'M GOPUS :Xa\URn[U5Hn SURS5- Xi'M URSURS5- 5US 'GOUS :Xa9URS- n[U5Hn SURS5- Xi'M GOUS :XaRUR SU-5n[U5H-n U S-n SU -S- U-XY'URXU--5Xi'M/ GOWUS:XGa URU5nURU5nX4-n U S-n SU S--UR US-5-UR US-5-UR U 5- nXC- U - US 'URSSU--SU--U S-X--- 5US 'XD-X3-- n [SU5HOn U S-n SU -U -n XS- U -- XY'URSU -X--X--X--X-S- U -U -- 5Xi'MQ OC[ U[5(a[SU-5e[ U[5(d U"XV5nOe[XXg5 [[U55Hn Xy==Xy-ss'M UR5nXXU-4$)a This routine calulates gaussian quadrature rules for different families of orthogonal polynomials. Let (a, b) be an interval, W(x) a positive weight function and n a positive integer. Then the purpose of this routine is to calculate pairs (x_k, w_k) for k=0, 1, 2, ... (n-1) which give int(W(x) * F(x), x = a..b) = sum(w_k * F(x_k),k = 0..(n-1)) exact for all polynomials F(x) of degree (strictly) less than 2*n. For all integrable functions F(x) the sum is a (more or less) good approximation to the integral. The x_k are called nodes (which are the zeros of the related orthogonal polynomials) and the w_k are called the weights. parameters n (input) The degree of the quadrature rule, i.e. its number of nodes. qtype (input) The family of orthogonal polynmomials for which to compute the quadrature rule. See the list below. alpha (input) real number, used as parameter for some orthogonal polynomials beta (input) real number, used as parameter for some orthogonal polynomials. return value (X, W) a pair of two real arrays where x_k = X[k] and w_k = W[k]. orthogonal polynomials: qtype polynomial ----- ---------- "legendre" Legendre polynomials, W(x)=1 on the interval (-1, +1) "legendre01" shifted Legendre polynomials, W(x)=1 on the interval (0, +1) "hermite" Hermite polynomials, W(x)=exp(-x*x) on (-infinity,+infinity) "laguerre" Laguerre polynomials, W(x)=exp(-x) on (0,+infinity) "glaguerre" generalized Laguerre polynomials, W(x)=exp(-x)*x**alpha on (0, +infinity) "chebyshev1" Chebyshev polynomials of the first kind, W(x)=1/sqrt(1-x*x) on (-1, +1) "chebyshev2" Chebyshev polynomials of the second kind, W(x)=sqrt(1-x*x) on (-1, +1) "jacobi" Jacobi polynomials, W(x)=(1-x)**alpha * (1+x)**beta on (-1, +1) with alpha>-1 and beta>-1 examples: >>> from mpmath import mp >>> f = lambda x: x**8 + 2 * x**6 - 3 * x**4 + 5 * x**2 - 7 >>> X, W = mp.gauss_quadrature(5, "hermite") >>> A = mp.fdot([(f(x), w) for x, w in zip(X, W)]) >>> B = mp.sqrt(mp.pi) * 57 / 16 >>> C = mp.quad(lambda x: mp.exp(- x * x) * f(x), [-mp.inf, +mp.inf]) >>> mp.nprint((mp.chop(A-B, tol = 1e-10), mp.chop(A-C, tol = 1e-10))) (0.0, 0.0) >>> f = lambda x: x**5 - 2 * x**4 + 3 * x**3 - 5 * x**2 + 7 * x - 11 >>> X, W = mp.gauss_quadrature(3, "laguerre") >>> A = mp.fdot([(f(x), w) for x, w in zip(X, W)]) >>> B = 76 >>> C = mp.quad(lambda x: mp.exp(-x) * f(x), [0, +mp.inf]) >>> mp.nprint(mp.chop(A-B, tol = 1e-10), mp.chop(A-C, tol = 1e-10)) .0 # orthogonality of the chebyshev polynomials: >>> f = lambda x: mp.chebyt(3, x) * mp.chebyt(2, x) >>> X, W = mp.gauss_quadrature(3, "chebyshev1") >>> A = mp.fdot([(f(x), w) for x, w in zip(X, W)]) >>> print(mp.chop(A, tol = 1e-10)) 0.0 references: - golub and welsch, "calculations of gaussian quadrature rules", mathematics of computation 23, p. 221-230 (1969) - golub, "some modified matrix eigenvalue problems", siam review 15, p. 318-334 (1973) - stroud and secrest, "gaussian quadrature formulas", prentice-hall (1966) See also the routine gaussq.f in netlog.org or ACM Transactions on Mathematical Software algorithm 726. rrrlegendrer legendre01hermitelaguerre chebyshev1r chebyshev2 glaguerrejacobizunknown quadrature rule "%s") rHrr mpfpigammar6str ValueErrorrEr1 transpose)r rqtypealphabetar8r9r:rDrrababia2b2s rgauss_quadraturerxsn !QA !QA !QA AcF  AAA88AEQUQY%;<=AD ,  Aswwqz>ADAA88AER!VaZ#''!*%<=>AD )  HHSVV AAA88A N+AD *  AAAq519ADaD   FFAswwqz>ADxxCGGAJ'! ,  FFQJAswwqz>AD +  IIa%i AAAq519u$AD88AUO,AD ( wwt} \1f AY#))EAI. .4!81D DsyyQT~ U #!xxQY1t84qSY8OPQ!{U]*1AAAa%"*C!Gs?+AD88AEQY/18<GCIXYM]`K`cfKfghAD  E3  9EABB s # # !Kq#! CF^   A 1u:rc HURURpTURUS5nURUS5nS=n=pSUR-n [ U5GHn X-X|'S=n=pX:Ga[ X5HnXR XU 45- n M U S:wa[ X5H nXU 4==U -ss'XX4XU 4-- n M" XU 4nUR U 5*nUS:aU*nX-U - nX- XU 4'[ U S-U5HQnSn [ X5HnXX4XU4-- n M U U- n[ X5HnXU4==XX4-- ss'M MS [ X5HnXU 4==U -ss'M X-Xl'S=n=pX:GaTXS- :wGaK[ U S-U5HnXR XU45- n M U (Ga[ U S-U5H nXU4==U -ss'XX4XU4-- n M" XU S-4nUR U 5*nUS:aU*nX-U - nX- XU S-4'[ U S-U5HnXU4U- X~'M [ U S-U5HUnSn [ U S-U5HnXUU4XU4-- n M [ U S-U5HnUUU4==XU-- ss'M MW [ U S-U5HnXU4==U -ss'M [XR Xl5UR X|5-5n GM [U[5(d[ US- SS5Hn SX,S-U S-4'X|S-S:wa[ U S-U5HnXU4XU S-4- X|S-- X,U4'M! [ U S-U5HVnSn [ U S-U5HnXX4UUU4-- n M [ U S-U5HnUUU4==XX4-- ss'M MX [ U S-U5HnS=UUU 4'X,U4'M M SUS'XE:aUnOUnU(a[ US- SS5Hn Xln[ U S-U5H nSXU4'M US:waSU- n[ U S-U5H[nSn [ U S-U5HnXX4XU4-- n M XX4- U-n[ X5HnXU4==XX4-- ss'M M] [ X5HnUUU 4==U-ss'M O[ X5H nSUUU 4'M XU 4==S- ss'M [ US- SS5GHxnSnUS- nSn[ USS5HDnUS- nUR UU5U -U :XaSn O!UR UU5U -U :XdMD O U(aSnSn [ WUS-5Hn XU -nX|==U-ss'UR U5U -U :Xa OvXlnURX5nUXl'SU- nUU-nU*U-n U(dMb[ U5H1nUUW4nUUU 4nUU-UU --UUU4'UU-UU -- UUU 4'M3 M XnnWU:Xa@US:a7U*Xn'[U[5(d[ U5HnX.U4*X.U4'M GMmUU :a[S U-5eUUnUS- nUUnUUnX~nUU- UU--UU- UU---SU-U-- nURUS5nUS:aUU- UU--UUX-- U- --U- nOUU- UU--UUX- - U- --U- nS=nn [ UUS-5GHInUUS-nUUS-nX-nUU-nURUU5nUUU'UU- nUU- n UU-X--nUU-UU -- nUU -nUU-n[U[5(dF[ U5H7nUUU4nUUS-U4nUU-UU --UUU4'UU-UU -- UUS-U4'M9 URUU5nUUU'US:waSU- nUU-nUU-n UU-U U--nUU-X-- nU(dGM[ U5H7nUUU4nUUUS-4nUU-UU --UUU4'UU-UU -- UUUS-4'M9 GML SUU'XU'UXn'GMt [ U5Hn U nUR Xl5n [ U S-U5H#nUR UU5nUU :dMUn UnM% UU :wdMVXlnUUXl'UUU'U(a,[ U5HnUUU 4nUUU4UUU 4'UUUU4'M [U[5(aM[ U5HnX,U4nUUU4X,U4'UUUU4'M M U$) a This routine computes the singular value decomposition of a matrix A. Given A, two orthogonal matrices U and V are calculated such that A = U S V where S is a suitable shaped matrix whose off-diagonal elements are zero. The diagonal elements of S are the singular values of A, i.e. the squareroots of the eigenvalues of A' A or A A'. Here ' denotes the transpose. Householder bidiagonalization and a variant of the QR algorithm is used. overview of the matrices : A : m*n A gets replaced by U U : m*n U replaces A. If n>m then only the first m*m block of U is non-zero. column-orthogonal: U' U = B here B is a n*n matrix whose first min(m,n) diagonal elements are 1 and all other elements are zero. S : n*n diagonal matrix, only the diagonal elements are stored in the array S. only the first min(m,n) diagonal elements are non-zero. V : n*n orthogonal: V V' = V' V = 1 parameters: A (input/output) On input, A contains a real matrix of shape m*n. On output, if calc_u is true A contains the column-orthogonal matrix U; otherwise A is simply used as workspace and thus destroyed. V (input/output) if false, the matrix V is not calculated. otherwise V must be a matrix of shape n*n. calc_u (input) If true, the matrix U is calculated and replaces A. if false, U is not calculated and A is simply destroyed return value: S an array of length n containing the singular values of A sorted by decreasing magnitude. only the first min(m,n) elements are non-zero. This routine is a python translation of the fortran routine svd.f in the software library EISPACK (see netlib.org) which itself is based on the algol procedure svd described in: - num. math. 14, 403-420(1970) by golub and reinsch. - wilkinson/reinsch: handbook for auto. comp., vol ii-linear algebra, 134-151(1971). rrrrraTF8svd: no convergence to an eigenvalue after %d iterations) r colsrHr2rfabsr maxr6r7r5r4)r rVcalc_ur=rSworkr?ranormmaxitsrrArr$hrminnmitsflagr<nmrByr:rXjjimaxs r svd_r_rawrso \ 66166q !QA 99Q?DA [F AY'A 5A\!aC&))"zAcFeOF13!aC&(A&cFXXa[Lq5AEAIA#!QAA#A\qsVa!f_,*AA#A\A#!f*,* ( AcFeOF%yA 5Qa%ZAaC^!aC&))$!QAcFeOF13!aC&(A(!eHXXa[Lq5AEAI5AaC%!QA!fqjDG( !QAA#AaC^qsVa!f_,,#AaC^!A#!1g+-, ( !QAcFeOF(E88AD>CHHTW,==>qt a  !R$AAc!A#gJaCyA~!QA!fq1Q3x/4!9m then only the first m*m block of U is non-zero. column-unitary: U' U = B here B is a n*n matrix whose first min(m,n) diagonal elements are 1 and all other elements are zero. S : n*n diagonal matrix, only the diagonal elements are stored in the array S. only the first min(m,n) diagonal elements are non-zero. V : n*n unitary: V V' = V' V = 1 parameters: A (input/output) On input, A contains a complex matrix of shape m*n. On output, if calc_u is true A contains the column-unitary matrix U; otherwise A is simply used as workspace and thus destroyed. V (input/output) if false, the matrix V is not calculated. otherwise V must be a matrix of shape n*n. calc_u (input) If true, the matrix U is calculated and replaces A. if false, U is not calculated and A is simply destroyed return value: S an array of length n containing the singular values of A sorted by decreasing magnitude. only the first min(m,n) elements are non-zero. This routine is a python translation of the fortran routine svd.f in the software library EISPACK (see netlib.org) which itself is based on the algol procedure svd described in: - num. math. 14, 403-420(1970) by golub and reinsch. - wilkinson/reinsch: handbook for auto. comp., vol ii-linear algebra, 134-151(1971). rrrzrrraTFr{)r r|rHr2rr}r r!r r"r~r6r7r5r4)#r rrrr=rrrlbetarbetadworkr?rrrrrArarair$rtrrrrrr<rrBrr:rXrrs# r svd_c_rawrs ^ 66166q !QA IIaOD IIaOE IIaOE IIaOEA [F AY9A 5A\#&&1Q3.1CHHSVVAacF^4LLL"zAacFeOF!A#B!A#Bb27**A & cFXXa[L66!9q=2 +DA2 +D& Q*+QA#  5LE1!QAA#A\SXXa!f-!A#66*qA#A\!A#!a!f*,* ( AacFeOF&yA 5Qa%ZAaC^#&&Q3.1CHHSVVAcF^4LLL$!QAcFeOFA#BA#Bb27**A ( !eHXXa[L66!9q=2 +DA2 +D& Q*+q5AaC%  5LE1!QA1gDG( !QAA#AaC^SXXa!f-!A#66,DA#AaC]!A#!d1g+-+ ( !QAcFeOF(E((14.388EH+==>]` a  !R$AAc!A#gJqSzQHHUX&!QAsVaZAcF(!QAA#AaC^SXXa!f-!A#66,#AaC^!A#!a!f*,, (AaC]"##!A#Q3#%"#uquu aR(AAAaC^A#$AvE!QAA#AaC^SXXa!f-!A#66,CHHUX..A#A\!A#!a!f*,* ( AacFaKF& AAacF& cFaKF%)(AaCR  1HCDAr2&U88E!H%-6 D88AbE?U*e3'1Q3AEH AHMHxx{U*e3A !QAADAAAAQAv!'A !!B$A !!A#A%&UQU]AadG%&UQU]AacF "+(&!AAvq52AaD%a..!'A&'!fWAacF"+f}"#]`c#cdd!A1B"Ab AaAa%AE"a!eA%661q519EA !QA1uQUq1u-Q!a%[A4E0FF!KaUq1u-Q!a%[A4E0FF!KaIAArAv&!A#JacFEEIIaOaEEEAEMEAEMEQ!!T**$Qia"fIac"fI%&UQU]!( %&UQU]!A#b& ( IIaO!6AAAAAAEAEMEAEM6$QibdIb1fI%&UQU]"Q$ %&UQU]"QqS& (9'DE!HE!HAaDC !XAY HHQTNAq!A1A1u " 19AT7ADAdGA!A#AqvYAacF !AafI# a&&AA#AtAvYAcF !Ad1fI#1: Hrc URURpeU(d2U(dUR5n[XSSS9nUS[ XV5nU$U(aPXe:aKUR XU5nUR XU5n XSS2SU24'[X USS9nUSUnUSU2SU24nXU4$U(dUR5nUR Xf5n[XUSS9nXe:a!US:Xa USU2SS24nUSUnUSS2SU24nXU4$)a This routine computes the singular value decomposition of a matrix A. Given A, two orthogonal matrices U and V are calculated such that A = U S V and U' U = 1 and V V' = 1 where S is a suitable shaped matrix whose off-diagonal elements are zero. Here ' denotes the transpose. The diagonal elements of S are the singular values of A, i.e. the squareroots of the eigenvalues of A' A or A A'. input: A : a real matrix of shape (m, n) full_matrices : if true, U and V are of shape (m, m) and (n, n). if false, U and V are of shape (m, min(m, n)) and (min(m, n), n). compute_uv : if true, U and V are calculated. if false, only S is calculated. overwrite_a : if true, allows modification of A which may improve performance. if false, A is not modified. output: U : an orthogonal matrix: U' U = 1. if full_matrices is true, U is of shape (m, m). ortherwise it is of shape (m, min(m, n)). S : an array of length min(m, n) containing the singular values of A sorted by decreasing magnitude. V : an orthogonal matrix: V V' = 1. if full_matrices is true, V is of shape (n, n). ortherwise it is of shape (min(m, n), n). return value: S if compute_uv is false (U, S, V) if compute_uv is true overview of the matrices: full_matrices true: A : m*n U : m*m U' U = 1 S as matrix : m*n V : n*n V V' = 1 full_matrices false: A : m*n U : m*min(n,m) U' U = 1 S as matrix : min(m,n)*min(m,n) V : min(m,n)*n V V' = 1 examples: >>> from mpmath import mp >>> A = mp.matrix([[2, -2, -1], [3, 4, -2], [-2, -2, 0]]) >>> S = mp.svd_r(A, compute_uv = False) >>> print(S) [6.0] [3.0] [1.0] >>> U, S, V = mp.svd_r(A) >>> print(mp.chop(A - U * mp.diag(S) * V)) [0.0 0.0 0.0] [0.0 0.0 0.0] [0.0 0.0 0.0] see also: svd, svd_c FrrNTr)r r|rGrminrH r r full_matrices compute_uvrJr=rrrA0s rsvd_rrsJ 66166q A c%% 8 is1xL IIaO YYq_1RaR4 cq4 0 bqE bqb!eHqzA IIaO ca$ / 5%bqbdG"1A!BQB$Aayrc URURpeU(d2U(dUR5n[XSSS9nUS[ XV5nU$U(aPXe:aKUR XU5nUR XU5n XSS2SU24'[X USS9nUSUnUSU2SU24nXU4$U(dUR5nUR Xf5n[XUSS9nXe:a!US:Xa USU2SS24nUSUnUSS2SU24nXU4$)a[ This routine computes the singular value decomposition of a matrix A. Given A, two unitary matrices U and V are calculated such that A = U S V and U' U = 1 and V V' = 1 where S is a suitable shaped matrix whose off-diagonal elements are zero. Here ' denotes the hermitian transpose (i.e. transposition and complex conjugation). The diagonal elements of S are the singular values of A, i.e. the squareroots of the eigenvalues of A' A or A A'. input: A : a complex matrix of shape (m, n) full_matrices : if true, U and V are of shape (m, m) and (n, n). if false, U and V are of shape (m, min(m, n)) and (min(m, n), n). compute_uv : if true, U and V are calculated. if false, only S is calculated. overwrite_a : if true, allows modification of A which may improve performance. if false, A is not modified. output: U : an unitary matrix: U' U = 1. if full_matrices is true, U is of shape (m, m). ortherwise it is of shape (m, min(m, n)). S : an array of length min(m, n) containing the singular values of A sorted by decreasing magnitude. V : an unitary matrix: V V' = 1. if full_matrices is true, V is of shape (n, n). ortherwise it is of shape (min(m, n), n). return value: S if compute_uv is false (U, S, V) if compute_uv is true overview of the matrices: full_matrices true: A : m*n U : m*m U' U = 1 S as matrix : m*n V : n*n V V' = 1 full_matrices false: A : m*n U : m*min(n,m) U' U = 1 S as matrix : min(m,n)*min(m,n) V : min(m,n)*n V V' = 1 example: >>> from mpmath import mp >>> A = mp.matrix([[-2j, -1-3j, -2+2j], [2-2j, -1-3j, 1], [-3+1j,-2j,0]]) >>> S = mp.svd_c(A, compute_uv = False) >>> print(mp.chop(S - mp.matrix([mp.sqrt(34), mp.sqrt(15), mp.sqrt(6)]))) [0.0] [0.0] [0.0] >>> U, S, V = mp.svd_c(A) >>> print(mp.chop(A - U * mp.diag(S) * V)) [0.0 0.0 0.0] [0.0 0.0 0.0] [0.0 0.0 0.0] see also: svd, svd_r FrNTr)r r|rGrrrHrs rsvd_cr[sH 66166q A c%% 8 is1xL IIaO YYq_1RaR4 cq4 0 bqE bqb!eHqzA IIaO ca$ / 5%bqbdG"1A!BQB$Aayrc|^[U4SjU55nU(aTRXX4S9$TRXX4S9$)a "svd" is a unified interface for "svd_r" and "svd_c". Depending on whether A is real or complex the appropriate function is called. This routine computes the singular value decomposition of a matrix A. Given A, two orthogonal (A real) or unitary (A complex) matrices U and V are calculated such that A = U S V and U' U = 1 and V V' = 1 where S is a suitable shaped matrix whose off-diagonal elements are zero. Here ' denotes the hermitian transpose (i.e. transposition and complex conjugation). The diagonal elements of S are the singular values of A, i.e. the squareroots of the eigenvalues of A' A or A A'. input: A : a real or complex matrix of shape (m, n) full_matrices : if true, U and V are of shape (m, m) and (n, n). if false, U and V are of shape (m, min(m, n)) and (min(m, n), n). compute_uv : if true, U and V are calculated. if false, only S is calculated. overwrite_a : if true, allows modification of A which may improve performance. if false, A is not modified. output: U : an orthogonal or unitary matrix: U' U = 1. if full_matrices is true, U is of shape (m, m). ortherwise it is of shape (m, min(m, n)). S : an array of length min(m, n) containing the singular values of A sorted by decreasing magnitude. V : an orthogonal or unitary matrix: V V' = 1. if full_matrices is true, V is of shape (n, n). ortherwise it is of shape (min(m, n), n). return value: S if compute_uv is false (U, S, V) if compute_uv is true overview of the matrices: full_matrices true: A : m*n U : m*m U' U = 1 S as matrix : m*n V : n*n V V' = 1 full_matrices false: A : m*n U : m*min(n,m) U' U = 1 S as matrix : min(m,n)*min(m,n) V : min(m,n)*n V V' = 1 examples: >>> from mpmath import mp >>> A = mp.matrix([[2, -2, -1], [3, 4, -2], [-2, -2, 0]]) >>> S = mp.svd(A, compute_uv = False) >>> print(S) [6.0] [3.0] [1.0] >>> U, S, V = mp.svd(A) >>> print(mp.chop(A - U * mp.diag(S) * V)) [0.0 0.0 0.0] [0.0 0.0 0.0] [0.0 0.0 0.0] see also: svd_r, svd_c c3R># UHn[U5TRLv M g7frRrSrVs rrYsvd.. r[r\)rrrJ)r]rr)r rrrrJr^s` rsvdrs?R222Iyy ynnyy ynnrN)T)F)FF)rbrr)FTF)__doc__ libmp.backendreigenrrr)r,r/rErKrOr_rxrrrrrrrrs6#x|NF)J{~EEPIIVFTFTRddTg V A J ddPccJMoMor