(phYbSSKrSSKJr SSKrSSKJrJrJrJrJ r J r J r J r J r JrJrJr SSKJrJr SSKJr SSKJrJr SSKJr SS KJrJr SS KJrJ r SS K!J"r" SS K#J$r$J%r% SS K&J'r' /SQr(\RR"S5RTr*\RR"S5RTr+SSSSSSS.r,Sr-S!Sjr.Sr/S"Sjr0Sr1Sr2Sr3Sr4Sr5Sr6Sr7Sr8S"Sjr9S"Sjr:S r;g)#N)product) dotdiagprod logical_notravel transpose conjugateabsoluteamaxsignisfinitetriu) LinAlgError bandwidth)norm)solveinv)svd)schurrsf2csf) expm_frechet expm_cond)sqrtm)pick_pade_structure pade_UV_calc) _funm_loops)expmcosmsinmtanmcoshmsinhmtanhmlogmfunmsignmrfractional_matrix_powerrr khatri_raodf)ilr,r+FDc[R"U5n[UR5S:wd URSURS:wa [ S5eU$)aS Wraps asarray with the extra requirement that the input be a square matrix. The motivation is that the matfuncs module has real functions that have been lifted to square matrix functions. Parameters ---------- A : array_like A square matrix. Returns ------- out : ndarray An ndarray copy or view or other representation of A. rrz expected square array_like input)npasarraylenshape ValueErrorAs I/var/www/html/venv/lib/python3.13/site-packages/scipy/linalg/_matfuncs.py_asarray_squarer;$sI$ 1 A 177|qAGGAJ!''!*4;<< Hc<[R"U5(a[R"U5(aeUc1[S-[S-S.[ UR Rn[R"URSUS9(a URnU$)a Return either B or the real part of B, depending on properties of A and B. The motivation is that B has been computed as a complicated function of A, and B may be perturbed by negligible imaginary components. If A is real and B is complex with small imaginary components, then return a real copy of B. The assumption in that case would be that the imaginary components of B are numerical artifacts. Parameters ---------- A : ndarray Input array whose type is to be checked as real vs. complex. B : ndarray Array to be returned, possibly without its imaginary part. tol : float Absolute tolerance. Returns ------- out : real or complex array Either the input array B or only the real part of the input array B. @@g.Arr)atol) r3 isrealobj iscomplexobjfepseps_array_precisiondtypecharallcloseimagreal)r9Btols r: _maybe_realrN<sk4 ||A2??1-- ;3h3s7+,>> import numpy as np >>> from scipy.linalg import fractional_matrix_power >>> a = np.array([[1.0, 3.0], [1.0, 4.0]]) >>> b = fractional_matrix_power(a, 0.5) >>> b array([[ 0.75592895, 1.13389342], [ 0.37796447, 1.88982237]]) >>> np.dot(b, b) # Verify square root array([[ 1., 3.], [ 1., 4.]]) rN)r;scipy.linalg._matfuncs_inv_ssqlinalg_matfuncs_inv_ssq_fractional_matrix_power)r9tscipys r:r)r)bs-R A) << ) ) B B1 HHr<c&[R"U5nSSKnURRR U5n[ X5nS[-n[R"SSS9 [[U5U- S5[R"[US5URS9RS- nSSS5 U(a6[W5(aXT:aS U3n[R"U[ S S 9 U$UW4$!,(df  NO=f) ae Compute matrix logarithm. The matrix logarithm is the inverse of expm: expm(logm(`A`)) == `A` Parameters ---------- A : (N, N) array_like Matrix whose logarithm to evaluate disp : bool, optional Emit warning if error in the result is estimated large instead of returning estimated error. (Default: True) Returns ------- logm : (N, N) ndarray Matrix logarithm of `A` errest : float (if disp == False) 1-norm of the estimated error, ||err||_1 / ||A||_1 References ---------- .. [1] Awad H. Al-Mohy and Nicholas J. Higham (2012) "Improved Inverse Scaling and Squaring Algorithms for the Matrix Logarithm." SIAM Journal on Scientific Computing, 34 (4). C152-C169. ISSN 1095-7197 .. [2] Nicholas J. Higham (2008) "Functions of Matrices: Theory and Computation" ISBN 978-0-898716-46-7 .. [3] Nicholas J. Higham and Lijing lin (2011) "A Schur-Pade Algorithm for Fractional Powers of a Matrix." SIAM Journal on Matrix Analysis and Applications, 32 (3). pp. 1056-1078. ISSN 0895-4798 Examples -------- >>> import numpy as np >>> from scipy.linalg import logm, expm >>> a = np.array([[1.0, 3.0], [1.0, 4.0]]) >>> b = logm(a) >>> b array([[-1.02571087, 2.05142174], [ 0.68380725, 1.02571087]]) >>> expm(b) # Verify expm(logm(a)) returns a array([[ 1., 3.], [ 1., 4.]]) rNignore)divideinvalidrrGz1logm result may be inaccurate, approximate err = r2) stacklevel)r3r4rPrQrR_logmrNrEerrstaterrrGrKrwarningswarnRuntimeWarning)r9disprUr/errtolerrestmessages r:r&r&sn 1 A) &&,,Q/AAA #XF Hh 7d1gai#bjja177&K&P&PQS&TT 8 6#3I&RG MM'>a @&y 8 7s )AD Dc  [R"U5nURS:XaJURS:a:[R"[R "UR 55//5$URS:a [S5eURSURS:wa [S5e[UR6S:XaF[[R"SURS95Rn[R"XS9$URSS S :Xa[R "U5$[R"UR[R5(d UR![R"5nO=UR[R$:XaUR![R&5nURSn[R("URURS9n[R("S X34URS9n[+URS SVs/sHn[-U5PM sn6GHtnXn[/U5n [1U 5(dB[R2"[R "[R2"U555XG'MeXSS S 2S S 24'[5U5upU S:a[7S U S 35e[9XZ5n U S:wa$U S::a[7SU S 35e[;SU S35eUSn U S:wGaQU SS:Xd U SS:XGa([R2"U5n[R "USU *--5[R<"SU 5S S &[R2"XSS:XaSOSS9n[-U S- SS5HnX-n [R "USU*--5[R<"SU 5S S &[?USU*--5USU*---nU SS:Xa%U[R<"SU SS 2S S245S S &MU[R<"SU S S2SS 245S S &M O[-U 5HnX-n M U SS:Xd U SS:Xa:U SS:Xa[R@"U 5O[RB"U 5XG'GMpXU'GMw U$s snf)aCompute the matrix exponential of an array. Parameters ---------- A : ndarray Input with last two dimensions are square ``(..., n, n)``. Returns ------- eA : ndarray The resulting matrix exponential with the same shape of ``A`` Notes ----- Implements the algorithm given in [1], which is essentially a Pade approximation with a variable order that is decided based on the array data. For input with size ``n``, the memory usage is in the worst case in the order of ``8*(n**2)``. If the input data is not of single and double precision of real and complex dtypes, it is copied to a new array. For cases ``n >= 400``, the exact 1-norm computation cost, breaks even with 1-norm estimation and from that point on the estimation scheme given in [2] is used to decide on the approximation order. References ---------- .. [1] Awad H. Al-Mohy and Nicholas J. Higham, (2009), "A New Scaling and Squaring Algorithm for the Matrix Exponential", SIAM J. Matrix Anal. Appl. 31(3):970-989, :doi:`10.1137/09074721X` .. [2] Nicholas J. Higham and Francoise Tisseur (2000), "A Block Algorithm for Matrix 1-Norm Estimation, with an Application to 1-Norm Pseudospectra." SIAM J. Matrix Anal. Appl. 21(4):1185-1201, :doi:`10.1137/S0895479899356080` Examples -------- >>> import numpy as np >>> from scipy.linalg import expm, sinm, cosm Matrix version of the formula exp(0) = 1: >>> expm(np.zeros((3, 2, 2))) array([[[1., 0.], [0., 1.]], [[1., 0.], [0., 1.]], [[1., 0.], [0., 1.]]]) Euler's identity (exp(i*theta) = cos(theta) + i*sin(theta)) applied to a matrix: >>> a = np.array([[1.0, 2.0], [-1.0, 3.0]]) >>> expm(1j*a) array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j], [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]]) >>> cosm(a) + 1j*sinm(a) array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j], [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]]) rr2z0The input array must be at least two-dimensionalz-Last 2 dimensions of the array must be squarerr[N)rrznscipy.linalg.expm could not allocate sufficient memory while trying to compute the Pade structure (error code z).izkscipy.linalg.expm could not allocate sufficient memory while trying to compute the exponential (error code z^scipy.linalg.expm got an internal LAPACK error during the exponential computation (error code )zii->i)kg@)"r3r4sizendimarrayexpitemrr6minreyerG empty_like issubdtypeinexactastypefloat64float16float32emptyrrangeranyrr MemoryErrorr RuntimeErroreinsum _exp_sinchrtril)r9arGneAAmxindawlumsinfoeAwdiag_awsdr-exp_sd_s r:rrsF 1 Avv{qvvzxx"&&*+,--vvzLMMwwr{aggbk!IJJ AGG}RVVAQWW-.44}}Q,, wwrs|vvvay =="** - - HHRZZ  BJJ  HHRZZ   A !'' )B 1a)177 +B1773B<8 >B" 19s{!#99=b#BCC #$226q$:;;e 61 1 ''"+-/VVGa1"g4E-F '3'*WWRA!2;qsB+A)C24"r(8J1KBIIgs+A.'28(<=a1"gNF!uz>D '3qr3B3w<8;>D '3ssABw<8;,qA)C" qEQJBqEQJ&(eqjbggclbggclBGsG}:@ IA9s<Sc[R"[R"U55n[R"U5nUS:HnX)==X#)-ss'[R"USSU5X'U$)Nr@rh)r3diffrp)r lexp_diffl_diffmask_zs r:rrscq "I WWQZF r\F g&/)q"vf~.I r<c[U5n[R"U5(a S[SU-5[SU-5--$[SU-5R$)a Compute the matrix cosine. This routine uses expm to compute the matrix exponentials. Parameters ---------- A : (N, N) array_like Input array Returns ------- cosm : (N, N) ndarray Matrix cosine of A Examples -------- >>> import numpy as np >>> from scipy.linalg import expm, sinm, cosm Euler's identity (exp(i*theta) = cos(theta) + i*sin(theta)) applied to a matrix: >>> a = np.array([[1.0, 2.0], [-1.0, 3.0]]) >>> expm(1j*a) array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j], [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]]) >>> cosm(a) + 1j*sinm(a) array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j], [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]]) ??)r;r3rCrrKr8s r:r r sPB A qDAJc!e,--BqDzr<c[U5n[R"U5(a S[SU-5[SU-5- -$[SU-5R$)a Compute the matrix sine. This routine uses expm to compute the matrix exponentials. Parameters ---------- A : (N, N) array_like Input array. Returns ------- sinm : (N, N) ndarray Matrix sine of `A` Examples -------- >>> import numpy as np >>> from scipy.linalg import expm, sinm, cosm Euler's identity (exp(i*theta) = cos(theta) + i*sin(theta)) applied to a matrix: >>> a = np.array([[1.0, 2.0], [-1.0, 3.0]]) >>> expm(1j*a) array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j], [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]]) >>> cosm(a) + 1j*sinm(a) array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j], [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]]) yrr)r;r3rCrrJr8s r:r!r!sPB A qd2a4j4A;.//BqDzr<c h[U5n[U[[U5[ U555$)aq Compute the matrix tangent. This routine uses expm to compute the matrix exponentials. Parameters ---------- A : (N, N) array_like Input array. Returns ------- tanm : (N, N) ndarray Matrix tangent of `A` Examples -------- >>> import numpy as np >>> from scipy.linalg import tanm, sinm, cosm >>> a = np.array([[1.0, 3.0], [1.0, 4.0]]) >>> t = tanm(a) >>> t array([[ -2.00876993, -8.41880636], [ -2.80626879, -10.42757629]]) Verify tanm(a) = sinm(a).dot(inv(cosm(a))) >>> s = sinm(a) >>> c = cosm(a) >>> s.dot(np.linalg.inv(c)) array([[ -2.00876993, -8.41880636], [ -2.80626879, -10.42757629]]) )r;rNrr r!r8s r:r"r"s+F A q%Qa1 22r<cb[U5n[US[U5[U*5--5$)a Compute the hyperbolic matrix cosine. This routine uses expm to compute the matrix exponentials. Parameters ---------- A : (N, N) array_like Input array. Returns ------- coshm : (N, N) ndarray Hyperbolic matrix cosine of `A` Examples -------- >>> import numpy as np >>> from scipy.linalg import tanhm, sinhm, coshm >>> a = np.array([[1.0, 3.0], [1.0, 4.0]]) >>> c = coshm(a) >>> c array([[ 11.24592233, 38.76236492], [ 12.92078831, 50.00828725]]) Verify tanhm(a) = sinhm(a).dot(inv(coshm(a))) >>> t = tanhm(a) >>> s = sinhm(a) >>> t - s.dot(np.linalg.inv(c)) array([[ 2.72004641e-15, 4.55191440e-15], [ 0.00000000e+00, -5.55111512e-16]]) rr;rNrr8s r:r#r#0F A q#a48!34 55r<cb[U5n[US[U5[U*5- -5$)a Compute the hyperbolic matrix sine. This routine uses expm to compute the matrix exponentials. Parameters ---------- A : (N, N) array_like Input array. Returns ------- sinhm : (N, N) ndarray Hyperbolic matrix sine of `A` Examples -------- >>> import numpy as np >>> from scipy.linalg import tanhm, sinhm, coshm >>> a = np.array([[1.0, 3.0], [1.0, 4.0]]) >>> s = sinhm(a) >>> s array([[ 10.57300653, 39.28826594], [ 13.09608865, 49.86127247]]) Verify tanhm(a) = sinhm(a).dot(inv(coshm(a))) >>> t = tanhm(a) >>> c = coshm(a) >>> t - s.dot(np.linalg.inv(c)) array([[ 2.72004641e-15, 4.55191440e-15], [ 0.00000000e+00, -5.55111512e-16]]) rrr8s r:r$r$(rr<c h[U5n[U[[U5[ U555$)a Compute the hyperbolic matrix tangent. This routine uses expm to compute the matrix exponentials. Parameters ---------- A : (N, N) array_like Input array Returns ------- tanhm : (N, N) ndarray Hyperbolic matrix tangent of `A` Examples -------- >>> import numpy as np >>> from scipy.linalg import tanhm, sinhm, coshm >>> a = np.array([[1.0, 3.0], [1.0, 4.0]]) >>> t = tanhm(a) >>> t array([[ 0.3428582 , 0.51987926], [ 0.17329309, 0.86273746]]) Verify tanhm(a) = sinhm(a).dot(inv(coshm(a))) >>> s = sinhm(a) >>> c = coshm(a) >>> t - s.dot(np.linalg.inv(c)) array([[ 2.72004641e-15, 4.55191440e-15], [ 0.00000000e+00, -5.55111512e-16]]) )r;rNrr#r$r8s r:r%r%Os+F A q%a%(3 44r<c [U5n[U5up4[X45up4URu n[ U"[ U555nUR UR R5n[US5n[XcXW5upg[[XF5[[U555n[X5n[[S.[ UR RnUS:XaUn[#S[%XU- ['[)US5S5-55n [+[-[/[1U555SS9(a[2R4n U(aU SU-:a [7SU 5 U$Xi4$) a Evaluate a matrix function specified by a callable. Returns the value of matrix-valued function ``f`` at `A`. The function ``f`` is an extension of the scalar-valued function `func` to matrices. Parameters ---------- A : (N, N) array_like Matrix at which to evaluate the function func : callable Callable object that evaluates a scalar function f. Must be vectorized (eg. using vectorize). disp : bool, optional Print warning if error in the result is estimated large instead of returning estimated error. (Default: True) Returns ------- funm : (N, N) ndarray Value of the matrix function specified by func evaluated at `A` errest : float (if disp == False) 1-norm of the estimated error, ||err||_1 / ||A||_1 Notes ----- This function implements the general algorithm based on Schur decomposition (Algorithm 9.1.1. in [1]_). If the input matrix is known to be diagonalizable, then relying on the eigendecomposition is likely to be faster. For example, if your matrix is Hermitian, you can do >>> from scipy.linalg import eigh >>> def funm_herm(a, func, check_finite=False): ... w, v = eigh(a, check_finite=check_finite) ... ## if you further know that your matrix is positive semidefinite, ... ## you can optionally guard against precision errors by doing ... # w = np.maximum(w, 0) ... w = func(w) ... return (v * w).dot(v.conj().T) References ---------- .. [1] Gene H. Golub, Charles F. van Loan, Matrix Computations 4th ed. Examples -------- >>> import numpy as np >>> from scipy.linalg import funm >>> a = np.array([[1.0, 3.0], [1.0, 4.0]]) >>> funm(a, lambda x: x*x) array([[ 4., 15.], [ 5., 19.]]) >>> a.dot(a) array([[ 4., 15.], [ 5., 19.]]) )rrr?r@rr)axisrWz0funm result may be inaccurate, approximate err =)r;rrr6rrwrGrHabsrrr r rNrDrErFrrmaxrrrrrrr3infprint) r9funcrcTZrr/mindenrMerrs r:r'r'vs0~ A 8DA 1=DA 77DAq T$q']A A 4\FA!,IA CIy1./AAAs ,QWW\\: ;C } aSv:tDAJ'::; Dc Jv r<cT[U5nSn[XSS9up4S[-S[-S.[UR R nXE:aU$[USS9n[R"U5nSU- nX[R"URS5--n Un [S 5HLn [U 5n SX--n S[X5U --n [[X5U - S 5nXE:dX:Xa OUn MN U(a#[!U5(aXE:a [#S U5 U $X4$) a Matrix sign function. Extension of the scalar sign(x) to matrices. Parameters ---------- A : (N, N) array_like Matrix at which to evaluate the sign function disp : bool, optional Print warning if error in the result is estimated large instead of returning estimated error. (Default: True) Returns ------- signm : (N, N) ndarray Value of the sign function at `A` errest : float (if disp == False) 1-norm of the estimated error, ||err||_1 / ||A||_1 Examples -------- >>> from scipy.linalg import signm, eigvals >>> a = [[1,2,3], [1,2,1], [1,1,1]] >>> eigvals(a) array([ 4.12488542+0.j, -0.76155718+0.j, 0.63667176+0.j]) >>> eigvals(signm(a)) array([-1.+0.j, 1.+0.j, 1.+0.j]) c[R"U5nURRS:XaS[-[ U5-nOS[ -[ U5-n[[U5U:U-5$)Nr,r>) r3rKrGrHrDr rEr r )rrxcs r: rounded_signsignm..rounded_signs[ WWQZ 88==C Da ACQAXb\A%+,,r<r)rcr>r?F) compute_uvrdrz1signm result may be inaccurate, approximate err =)r;r'rDrErFrGrHrr3r identityr6r|rrrrr)r9rcrresultrerdvalsmax_svrS0 prev_errestr-iS0Pps r:r(r(s%B A-!2NFTc#g &'7 8I8I'J KF   qU #D WWT]F F A r{{1771:& & &BK 3Z"g "(^ #b+b. !c"k"na( ?k3   6#3 Ev N zr<c~[R"U5n[R"U5nURS:XaURS:Xd [S5eURSURS:Xd [S5eUR S:XdUR S:XaDURSURS-nURSn[R "XU4S9$USSS2[RSS24US[RSS2SS24-nURS URSS-5$) a= Khatri-rao product A column-wise Kronecker product of two matrices Parameters ---------- a : (n, k) array_like Input array b : (m, k) array_like Input array Returns ------- c: (n*m, k) ndarray Khatri-rao product of `a` and `b`. Notes ----- The mathematical definition of the Khatri-Rao product is: .. math:: (A_{ij} \bigotimes B_{ij})_{ij} which is the Kronecker product of every column of A and B, e.g.:: c = np.vstack([np.kron(a[:, k], b[:, k]) for k in range(b.shape[1])]).T Examples -------- >>> import numpy as np >>> from scipy import linalg >>> a = np.array([[1, 2, 3], [4, 5, 6]]) >>> b = np.array([[3, 4, 5], [6, 7, 8], [2, 3, 9]]) >>> linalg.khatri_rao(a, b) array([[ 3, 8, 15], [ 6, 14, 24], [ 2, 6, 27], [12, 20, 30], [24, 35, 48], [ 8, 15, 54]]) r2z(The both arrays should be 2-dimensional.rz6The number of columns for both arrays should be equal.r)r6.N)rh) r3r4rnr7r6rmrtnewaxisreshape)rbrrrs r:r*r*$s Z 1 A 1 A FFaKAFFaKCDD 771: #,- - vv{affk GGAJ # GGAJ}}Q!f-- #q"**a  1S"**a%:#;;A 99UQWWQR[( ))r<)N)T)rsDDDD0)2"=( & hhsm xx}C 0 L+I\FRdN%P%P$3N$6N$6N$5N[|M`?*r<