\ci.~NddlZddlmZddlZddlmZmZmZmZm Z m Z m Z m Z m Z mZmZmZddlmZddlmZddlmZmZmZddlmZdd lmZmZdd lmZdd l m!Z!m"Z"dd l#m$Z$m%Z%dd l&m'Z'ddl(m)Z)m*Z*ddl+m,Z,gdZ-ej.dj/Z/ej.dj/Z0dddddddZ1dZ2d(dZ3eddZ4edefdZ5dZ6dZ7eefdZ8eddZ9eddZ:eddZ;eddZ<edd Z=edd!Z>edd)d#Z?edefd$Z@ed%d&d'ZAdS)*N)product) dotdiagprod logical_notravel transpose conjugateabsoluteamaxsignisfinitetriu)_apply_over_batch)_NoValue) LinAlgError bandwidth LinAlgWarning)norm)solveinv)svd)schurrsf2csf) expm_frechet expm_cond)recursive_schur_sqrtm)pick_pade_structure pade_UV_calc) _funm_loops)expmcosmsinmtanmcoshmsinhmtanhmlogmfunmsignmsqrtmfractional_matrix_powerrr khatri_raodf)ilr0r/FDctj|}t|jdks|jd|jdkrt d|S)a 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 f/var/www/html/mdtn/previsions/meteo_cartes/venv/lib/python3.11/site-packages/scipy/linalg/_matfuncs.py_asarray_squarer?'sN$ 1 A 17||qAGAJ!'!*44;<<< Hctj|ritj|rU|0tdztdzdt |jj}tj|j d|r|j }|S)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. N@@g.Arr)atol) r7 isrealobj iscomplexobjfepseps_array_precisiondtypecharallcloseimagreal)r=Btols r> _maybe_realrR?su4 |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)r=tscipys r>r-r-es9V A)))) < ) B B1a H HHr@cv|turd}ntjdtdt j|}ddl}|jj |}t||}dtz}t j dd 5tt||z d t jt|d |j jd z }dddn #1swxYwY|r8t#|r||kr!d |}tj|t$d|S||fS)a 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) .. deprecated:: 1.16.0 The `disp` argument is deprecated and will be removed in SciPy 1.18.0. The previously returned error estimate can be computed as ``norm(expm(logm(A)) - A, 1) / norm(A, 1)``. 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.]]) TFThe `disp` argument is deprecated and will be removed in SciPy 1.18.0.r6 stacklevelrNignore)divideinvalidrrKz1logm result may be inaccurate, approximate err = )rwarningswarnDeprecationWarningr7r8rTrUrV_logmrRrIerrstaterr"rKrOrRuntimeWarning)r=disprYr3errtolerrestmessages r>r)r)sz x =(Q 8 8 8 8 1 A)))) &,,Q//AAqA #XF Hh 7 7 7UUd1ggai##bja17&K&K&K&PQS&TTUUUUUUUUUUUUUUU  A6V#3#3R&RRG M'>a @ @ @ @&ysAC22C69C6c h tj|}|jdkrE|jdkr:tjtj|ggS|jdkrtd|jd|jdkrtdt|jdkrCttj d|j j }tj ||S|jdd d krtj|Stj|j tjs |tj}n4|j tjkr|tj}|jd}tj|j|j }tjd ||f|j }t+d |jd dDD]}||}t-|}t/|s= 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]]) rr60The input array must be at least two-dimensional-Last 2 dimensions of the array must be squarerrbNrrc,g|]}t|Src)range).0xs r> zexpm..Rs888aq888r@znscipy.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@)"r7r8sizendimarrayexpitemrr:minr"eyerK empty_like issubdtypeinexactastypefloat64float16float32emptyrranyrr MemoryErrorr RuntimeErroreinsumrv _exp_sinchrtril)r=arKneAAmindawlumsinfoeAwdiag_awsdr1exp_sd_s r>r"r"sN 1 Av{{qvzzx"&**+,---vzzLMMMwr{agbk!!IJJJ AG}RVAQW---..4}Qe,,,, wrss|vvayy ="* - -! HHRZ  BJ   HHRZ   A !' ) ) )B 1a)17 + + +B88173B3<8889>> sV r]]2ww gbfRWR[[1122BsG  1aaa7 "2&&1 EE=78===>> >B"" 199s{{!#B9=#B#B#BCCC #$:26$:$:$:;;;e 661 1 '"++-/VGa1"g4E-F-F '3''*WRA!22;;;qsB++ E EA)C24"r(8J1K1KBIgs++AAA.'28(<==a1"gNF!uzz>D '3qrr3B3w<88;;>D '3ssABBw<88;; Eq$$A)CC qEQJJBqEQJJ&(eqjjbgclllbgcllBsGGBsGG Ir@ctjtj|}tj|}|dk}||xx||zcc<tj|dd|||<|S)NrDrp)r7diffr)rx lexp_diffl_diffmask_zs r>rrsyq ""I WQZZF r\F vg&&/)q"vf~..If r@c8|turd}ntjdtd|turtjdtdt j|}|jdkrE|jdkr:t jt j | ggS|jdkrtd|j d|j d krtd t|j d krCtt jd|j j}t j|| S|j d d dkrtj|St j|jtjs |tj}n|jtjkr |tj}n[|jjdvr |tj}n-|jjdvr|tj}|jjdvrt9d|jt;|\}}}}|d krtd||s|r#|rd} nd} tj| t<d|durL t?||z|z ddzt?|dz } n#t@$rtj!} YnwxYw|| fS|S)a@ Compute, if exists, the matrix square root. The matrix square root of ``A`` is a matrix ``X`` such that ``X @ X = A``. Every square matrix is not guaranteed to have a matrix square root, for example, the array ``[[0, 1], [0, 0]]`` does not have a square root. Moreover, not every real matrix has a real square root. Hence, for real-valued matrices the return type can be complex if, numerically, there is an eigenvalue on the negative real axis. Array argument(s) of this function may have additional "batch" dimensions prepended to the core shape. In this case, the array is treated as a batch of lower-dimensional slices; see :ref:`linalg_batch` for details. Parameters ---------- A : ndarray Input with last two dimensions are square ``(..., n, n)``. disp : bool, optional Print warning if error in the result is estimated large instead of returning estimated error. (Default: True) .. deprecated:: 1.16.0 The `disp` argument is deprecated and will be removed in SciPy 1.18.0. The previously returned error estimate can be computed as ``norm(X @ X - A, 'fro')**2 / norm(A, 'fro')`` blocksize : integer, optional .. deprecated:: 1.16.0 The `blocksize` argument is deprecated as it is unused by the algorithm and will be removed in SciPy 1.18.0. Returns ------- sqrtm : ndarray Computed matrix squareroot of `A` with same size ``(..., n, n)``. errest : float Frobenius norm of the estimated error, ||err||_F / ||A||_F. Only returned, if ``disp`` is set to ``False``. This return argument will be removed in version 1.20.0 and only the sqrtm result will be returned. .. deprecated:: 1.16.0 Notes ----- This function uses the Schur decomposition method to compute the matrix square root following [1]_ and for real matrices [2]_. Moreover, note that, there exist matrices that have square roots that are not polynomials in ``A``. For a classical example from [2]_, the matrix satisfies:: [ a, a**2 + 1]**2 [-1, 0] [-1, -a] = [ 0, -1] for any scalar ``a`` but it is not a polynomial in ``-I``. Thus, they will not be found by this function. References ---------- .. [1] Edvin Deadman, Nicholas J. Higham, Rui Ralha (2013) "Blocked Schur Algorithms for Computing the Matrix Square Root, Lecture Notes in Computer Science, 7782. pp. 171-182. :doi:`10.1016/0024-3795(87)90118-2` .. [2] Nicholas J. Higham (1987) "Computing real square roots of a real matrix", Linear Algebra and its Applications, 88/89:405-430. :doi:`10.1016/0024-3795(87)90118-2` Examples -------- >>> import numpy as np >>> from scipy.linalg import sqrtm >>> a = np.array([[1.0, 3.0], [1.0, 4.0]]) >>> r = sqrtm(a) >>> r array([[ 0.75592895, 1.13389342], [ 0.37796447, 1.88982237]]) >>> r.dot(r) array([[ 1., 3.], [ 1., 4.]]) Tr[r6r\zKThe `blocksize` argument is deprecated and will be removed in SciPy 1.18.0.rrorprqrrrrbNrsGgfdFDz6scipy.linalg.sqrtm is not supported for the data type z&Internal error in scipy.linalg.sqrtm: z]Matrix is singular. The result might be inaccurate or the array might not have a square root.zdMatrix is ill-conditioned. The result might be inaccurate or the array might not have a square root.Ffro)"rrdrerfr7r8r|r}r~rrrr:rr,rrKremathsqrtrrrrrrrL complex128 TypeErrorrrrr;inf) r=rj blocksizerrKresisIllconditioned isSingularrmsgarg2s r>r,r,s!h x  (Q 8 8 8 8   &(Q 8 8 8 8 1 Av{{qvzzx"&**+,---vzzLMMMwr{agbk!!IJJJ AG}bfQag...//5}Qe,,,, wrss|vx}}Q ="* - -! HHRZ  BJ   HHRZ     HHR] # #    HHRZ w|6!!&G&&'' '/DA.F.F+C :t axxI4IIJJJ8%8  B:CCAC c=Q7777 u}} c A u--q045>>ADD   6DDD Dy s*K::LLct|}tj|r(dtd|ztd|zzzStd|zjS)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?r7rGr"rOr<s r>r#r#5sZD A qDAJJc!e,--BqDzzr@ct|}tj|r(dtd|ztd|zz zStd|zjS)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?r7rGr"rNr<s r>r$r$^sZD A qd2a4jj4A;;.//BqDzzr@c t|}t|tt|t |S)a 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?rRrr#r$r<s r>r%r%s8H A q%Qa11 2 22r@ct|}t|dt|t| zzS)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?rRr"r<s r>r&r&:H A q#a488!34 5 55r@ct|}t|dt|t| z zS)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]]) rrr<s r>r'r'rr@c t|}t|tt|t |S)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?rRrr&r'r<s r>r(r(s8H A q%a%((33 4 44r@Tc t|}t|\}}t||\}}|j\}}t |t |}||jj}t|d}t||||\}}tt||tt|}t||}ttdt |jj}|dkr|}t#dt%|||z t't)|ddz} t+t-t/t1|dr t2j} |r| d|zkrt7d| |S|| fS) 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.]]) )rrrCrDrr)axisr^z0funm result may be inaccurate, approximate err =)r?rrr:rrrKrLabsr!rr r rRrHrIrJrmaxrrrrrrr7rprint) r=funcrjTZrr3mindenrQerrs r>r*r*'s@ A 88DAq 1a==DAq 7DAq TT$q'']]A A 4\\FAq!V,,IAv C1IIy1..//AAqAs  ,QW\: ;C }} aS3v:tDAJJ':'::;; < > Dc J J J#v r@c|turd}ntjdtdt |}d}t ||d\}}dt zdtzd t|j j }||kr|St|d }tj |}d |z }||tj|jdzz} |} t!d D]`} t#| } d | | zz} d t%| | | zz} t't%| | | z d}||ks| |krn|} a|r't)|r||krt+d|| S| |fS)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) .. deprecated:: 1.16.0 The `disp` argument is deprecated and will be removed in SciPy 1.18.0. The previously returned error estimate can be computed as ``norm(signm @ signm - signm, 1)``. 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]) Tr[r6r\ctj|}|jjdkrdtzt |z}ndt zt |z}tt||k|zS)Nr0rB) r7rOrKrLrHr rIr r )rxrxcs r> rounded_signzsignm..rounded_signse WQZZ 8=C  Da AACQAXb\\A%+,,,r@r)rjrBrCF) compute_uvrdrz1signm result may be inaccurate, approximate err =)rrdrerfr?r*rHrIrJrKrLrr7r identityr:rvrrrrr)r=rjrresultrlrkvalsmax_svrS0 prev_errestr1iS0Pps r>r+r+sN x =(Q 8 8 8 8 A---!\222NFFTc#g & &'7 8I'J KF   qU # # #D WT]]F F A Qr{171:&& & &BK 3ZZ"gg "s(^ #b"++b. !c"bkk"na(( F??kV33 E   O6V#3#3 Ev N N N 6zr@)rr6)br6cRtj|}tj|}|jdkr |jdkstd|jd|jdkstd|jdks |jdkr@|jd|jdz}|jd}tj|||fS|dddtjddf|dtjddddfz}|d |jddzS) a Khatri-Rao product of two matrices. 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]]) r6z(The both arrays should be 2-dimensional.rz6The number of columns for both arrays should be equal.r)r:.N)rp) r7r8r}r;r:r|rnewaxisreshape)rrrrrs r>r.r.s\ 1 A 1 A FaKKAFaKKCDDD 71: # #,-- - v{{afkk GAJ # GAJ}Qq!f---- #qqq"*aaa  1S"*aaa%:#;;A 99UQWQRR[( ) ))r@)N)T)Brd itertoolsrnumpyr7rrrrrr r r r r rrscipy._lib._utilrscipy._lib.deprecationr scipy.linalgrrr_miscr_basicrr _decomp_svdr _decomp_schurrr _expm_frechetrr_matfuncs_schur_sqrtmr_matfuncs_expmrr _linalg_pythranr!__all__finforIrHrJr?rRr-r)r"rr,r#r$r%r&r'r(r*r+r.rcr@r>rs^DDDDDDDDDDDDDDDDDDDDDDDDDDDD/.....++++++?>>>>>>>>>))))))))22222222888888========(((((( & & &bhsmmrx}}CC   0    L8,I,I,I^8QQQQhhhhVhSSSSl8%%%P8%%%P8$3$3$3N8$6$6$6N8$6$6$6N8$5$5$5N8[[[[|8YYYYx8X&&?*?*'&?*?*?*r@