`iJddlZddlZddlZddlmZddlmZejdd.dZejdd/dZejdd/d Z ejd d0d Z ejd d Z ejdd0dZ d1dZ ejdefdZejdddddZejddZejddZejddZejdd Zejd!d1d"Zejd#d$Zejd%d0d&Zejd'd(Zejd)d*Zejd+d2d-ZdS)3N)_core)_uarraytrictjdt||}nt|tr||}}t j||||tn|S)a Construct (``N``, ``M``) matrix filled with ones at and below the ``k``-th diagonal. The matrix has ``A[i,j] == 1`` for ``i <= j + k``. Args: N (int): The size of the first dimension of the matrix. M (int, optional): The size of the second dimension of the matrix. If ``M`` is None, ``M = N`` is assumed. k (int, optional): Number of subdiagonal below which matrix is filled with ones. ``k = 0`` is the main diagonal, ``k < 0`` subdiagonal and ``k > 0`` superdiagonal. dtype (dtype, optional): Data type of the matrix. Returns: cupy.ndarray: Tri matrix. .. seealso:: :func:`scipy.linalg.tri` !'tri'/'tril/'triu' are deprecated)warningswarnDeprecationWarning isinstancestrcupyrbool)NMkdtypes x/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupyx/scipy/linalg/_special_matrices.pyrr s_& M57IJJJy  As  a5 8Aq!U]TT > >>trilctjdtt|jd|jd||jj}||z}|S)aMake a copy of a matrix with elements above the ``k``-th diagonal zeroed. Args: m (cupy.ndarray): Matrix whose elements to return k (int, optional): Diagonal above which to zero elements. ``k == 0`` is the main diagonal, ``k < 0`` subdiagonal and ``k > 0`` superdiagonal. Returns: (cupy.ndarray): Return is the same shape and type as ``m``. .. seealso:: :func:`scipy.linalg.tril` rr)rr)rr r rshapercharmrts rrr)sN  M57IJJJ AGAJ aqw|<< 0`` superdiagonal. Returns: (cupy.ndarray): Return matrix with zeroed elements below the kth diagonal and has same shape and type as ``m``. .. seealso:: :func:`scipy.linalg.triu` rrrout) rr r rrrrr subtractrs rrrAsf" M57IJJJ AGAJ AE17<88AM!QAFA Hrtoeplitzc|}||n|}t|ddd|ddS)aLConstruct a Toeplitz matrix. The Toeplitz matrix has constant diagonals, with ``c`` as its first column and ``r`` as its first row. If ``r`` is not given, ``r == conjugate(c)`` is assumed. Args: c (cupy.ndarray): First column of the matrix. Whatever the actual shape of ``c``, it will be converted to a 1-D array. r (cupy.ndarray, optional): First row of the matrix. If None, ``r = conjugate(c)`` is assumed; in this case, if ``c[0]`` is real, the result is a Hermitian matrix. r[0] is ignored; the first row of the returned matrix is ``[c[0], r[1:]]``. Whatever the actual shape of ``r``, it will be converted to a 1-D array. Returns: cupy.ndarray: The Toeplitz matrix. Dtype is the same as ``(c[0] + r[0]).dtype``. .. seealso:: :func:`cupyx.scipy.linalg.circulant` .. seealso:: :func:`cupyx.scipy.linalg.hankel` .. seealso:: :func:`cupyx.scipy.linalg.solve_toeplitz` .. seealso:: :func:`cupyx.scipy.linalg.fiedler` .. seealso:: :func:`scipy.linalg.toeplitz` Nr)ravel conjugate_create_toeplitz_matrixcrs rr"r"[sP6  A  A "1TTrT7AabbE 2 22r circulantcn|}t|ddd|dddS)aConstruct a circulant matrix. Args: c (cupy.ndarray): 1-D array, the first column of the matrix. Returns: cupy.ndarray: A circulant matrix whose first column is ``c``. .. seealso:: :func:`cupyx.scipy.linalg.toeplitz` .. seealso:: :func:`cupyx.scipy.linalg.hankel` .. seealso:: :func:`cupyx.scipy.linalg.solve_circulant` .. seealso:: :func:`cupyx.scipy.linalg.fiedler` .. seealso:: :func:`scipy.linalg.circulant` Nr$r)r%r')r)s rr+r+{s5  A "1TTrT7AeqeH 5 55rhankelc|}|tj|n|}t||dddS)aConstruct a Hankel matrix. The Hankel matrix has constant anti-diagonals, with ``c`` as its first column and ``r`` as its last row. If ``r`` is not given, then ``r = zeros_like(c)`` is assumed. Args: c (cupy.ndarray): First column of the matrix. Whatever the actual shape of ``c``, it will be converted to a 1-D array. r (cupy.ndarray, optional): Last row of the matrix. If None, ``r = zeros_like(c)`` is assumed. ``r[0]`` is ignored; the last row of the returned matrix is ``[c[-1], r[1:]]``. Whatever the actual shape of ``r``, it will be converted to a 1-D array. Returns: cupy.ndarray: The Hankel matrix. Dtype is the same as ``(c[0] + r[0]).dtype``. .. seealso:: :func:`cupyx.scipy.linalg.toeplitz` .. seealso:: :func:`cupyx.scipy.linalg.circulant` .. seealso:: :func:`scipy.linalg.hankel` NrT)r%r zeros_liker'r(s rr-r-sK0  AiQWWYYA "1aeT 2 22rFctj||f}|jd}tjj|r|n||jdz d|j|jdzf|r|n| |fS)Nrr)rstrides)r concatenater1lib stride_tricks as_stridedsizecopy)r)r*r-valsns rr'r's  QF # #D QA 8 ! , ,+DOvqvax $1"a( - * *+/$&&1rhadamardc|dkrdn#t|dz }d|z|krtdtj||f|}t ||S)aConstruct an Hadamard matrix. Constructs an n-by-n Hadamard matrix, using Sylvester's construction. ``n`` must be a power of 2. Args: n (int): The order of the matrix. ``n`` must be a power of 2. dtype (dtype, optional): The data type of the array to be constructed. Returns: (cupy.ndarray): The Hadamard matrix. .. seealso:: :func:`scipy.linalg.hadamard` rrz*n must be an positive a power of 2 integer)int bit_length ValueErrorr empty_hadamard_kernel)r9rlg2Hs rr:r:sm 1uu!!3q66,,..2CCx1}}EFFF Aq65!!A Aq ! !!rzT inzT outz;out = (__popc(_ind.get()[0] & _ind.get()[1]) & 1) ? -1 : 1;cupyx_scipy_linalg_hadamard) reduce_dimslesliec|jdkrtd|jdkrtd|j}||jdzkrtd|jdkrtdtj||ftj||}||d<tj|dd||S) aCreate a Leslie matrix. Given the length n array of fecundity coefficients ``f`` and the length n-1 array of survival coefficients ``s``, return the associated Leslie matrix. Args: f (cupy.ndarray): The "fecundity" coefficients. s (cupy.ndarray): The "survival" coefficients, has to be 1-D. The length of ``s`` must be one less than the length of ``f``, and it must be at least 1. Returns: cupy.ndarray: The array is zero except for the first row, which is ``f``, and the first sub-diagonal, which is ``s``. The data-type of the array will be the data-type of ``f[0]+s[0]``. .. seealso:: :func:`scipy.linalg.leslie` rz#Incorrect shape for f. f must be 1Dz#Incorrect shape for s. s must be 1Dz-Length of s must be one less than length of frz#The length of s must be at least 1.rN)ndimr?r6r zeros result_type fill_diagonal)fsr9as rrFrFs( v{{>???v{{>??? AAFQJHIIIv{{>??? Aq6!1!Q!7!7888A AaDqua   Hrkronctj||}||j|jz}tjtj|ddS)aKronecker product. The result is the block matrix:: a[0,0]*b a[0,1]*b ... a[0,-1]*b a[1,0]*b a[1,1]*b ... a[1,-1]*b ... a[-1,0]*b a[-1,1]*b ... a[-1,-1]*b Args: a (cupy.ndarray): Input array b (cupy.ndarray): Input array Returns: cupy.ndarray: Kronecker product of ``a`` and ``b``. .. seealso:: :func:`scipy.linalg.kron` r)axis)r outerreshaperr2)rObos rrPrPsU& 1aA !'AG#$$A  D,QQ777a @ @ @@r block_diagcpstjdStdkrtjfntjt dDrJfdt tD}t d|tdD}tdt|D}tj |tj }d \}}D]'}|j \}} |||||z||| zf<||z }|| z }(|S) a/Create a block diagonal matrix from provided arrays. Given the inputs ``A``, ``B``, and ``C``, the output will have these arrays arranged on the diagonal:: [A, 0, 0] [0, B, 0] [0, 0, C] Args: A, B, C, ... (cupy.ndarray): Input arrays. A 1-D array of length ``n`` is treated as a 2-D array with shape ``(1,n)``. Returns: (cupy.ndarray): Array with ``A``, ``B``, ``C``, ... on the diagonal. Output has the same dtype as ``A``. .. seealso:: :func:`scipy.linalg.block_diag` rrrc3,K|]}|jdkVdS)r<NrI.0rOs r zblock_diag..*s( % %116Q; % % % % % %rc6g|]}|jdk|S)r<r[)r]rarrss r zblock_diag..+s)@@@Qd1gla.?.?q.?.?.?rzFarguments in the following positions have dimension greater than 2: {}c3$K|] }|jV dSN)rr\s rr^zblock_diag../s$))q17))))))rc34K|]}t|VdSrc)sum)r]xs rr^zblock_diag..0s(//Q#a&&//////rrHrr) r r@len atleast_2danyranger?formattupleziprJrKr) r`badshapesrr r*r)arrrrccs ` rrWrW sh* "z&!!! 4yyA~~&(% % % % % %%%;@@@@%D **@@@..4fSkk;; ;))D))) ) )F //#v,/// / /E *U$"2D"9 : : :C DAqB"%Aa"fHaBh  R R Jr companionc$|j}|jdkrtd|dkrtd|dd |dz }tj|dz |dz f|j}||d<tj|ddd|S)asCreate a companion matrix. Create the companion matrix associated with the polynomial whose coefficients are given in ``a``. Args: a (cupy.ndarray): 1-D array of polynomial coefficients. The length of ``a`` must be at least two, and ``a[0]`` must not be zero. Returns: (cupy.ndarray): The first row of the output is ``-a[1:]/a[0]``, and the first sub-diagonal is all ones. The data-type of the array is the same as the data-type of ``-a[1:]/a[0]``. .. seealso:: :func:`cupyx.scipy.linalg.fiedler_companion` .. seealso:: :func:`scipy.linalg.companion` rz`a` must be one-dimensional.r<z%The length of `a` must be at least 2.NrrH)r6rIr?r rJrrL)rOr9 first_rowr)s rrtrt;s& Av{{78881uu@AAA 1221 I AE1q5>999A AaDqua   HrhelmertcFtj|}tj||d}|ddxx|zcc<|tjd|dzz}d|d<||d<|tj|dddfz}|r|n |ddS)aLCreate an Helmert matrix of order ``n``. This has applications in statistics, compositional or simplicial analysis, and in Aitchison geometry. Args: n (int): The size of the array to create. full (bool, optional): If True the (n, n) ndarray will be returned. Otherwise, the default, the submatrix that does not include the first row will be returned. Returns: cupy.ndarray: The Helmert matrix. The shape is (n, n) or (n-1, n) depending on the ``full`` argument. .. seealso:: :func:`scipy.linalg.helmert` r$Nrr)r arangerdiagonalsqrt)r9fulldrCs rrwrw^s& AA ArAJJLLOOOqOOOQ!  A AaD AaD1aaag A 11!ABB%rhilbertctjdd|ztj}tj||t |d|||dz dS)a!Create a Hilbert matrix of order ``n``. Returns the ``n`` by ``n`` array with entries ``h[i,j] = 1 / (i + j + 1)``. Args: n (int): The size of the array to create. Returns: cupy.ndarray: The Hilbert matrix. .. seealso:: :func:`scipy.linalg.hilbert` rr<rHN)r*)r ryfloat64 reciprocalr-)r9valuess rr~r~{sY[AaCt| 4 4 4FOFF### &!*qstt - - --rdftcF|dvrtd|dtj|d}|dtjz|z z}tj||dddf}|tj|z}|%||d krd t j|z nd |z z}|S) aDiscrete Fourier transform matrix. Create the matrix that computes the discrete Fourier transform of a sequence. The nth primitive root of unity used to generate the matrix is exp(-2*pi*i/n), where i = sqrt(-1). Args: n (int): Size the matrix to create. scale (str, optional): Must be None, 'sqrtn', or 'n'. If ``scale`` is 'sqrtn', the matrix is divided by ``sqrt(n)``. If ``scale`` is 'n', the matrix is divided by ``n``. If ``scale`` is None (default), the matrix is not normalized, and the return value is simply the Vandermonde matrix of the roots of unity. Returns: (cupy.ndarray): The DFT matrix. Notes: When ``scale`` is None, multiplying a vector by the matrix returned by ``dft`` is mathematically equivalent to (but much less efficient than) the calculation performed by ``scipy.fft.fft``. .. seealso:: :func:`scipy.linalg.dft` )Nsqrtnr9z%scale must be None, 'sqrtn', or 'n'; z is not valid. complex128rHyrNrr)r?r rypiexpmathr{)r9scaler*omegasrs rrrs6 (((j/4uu788 8 A\***ATWQA XaQ   4 (F$+a.. A  '!1!1a ! nn!< Hrfiedlerc|jdkrtd|jdkrtjdS|jdkrtjdS|dddf|z }tj||S)aReturns a symmetric Fiedler matrix Given an sequence of numbers ``a``, Fiedler matrices have the structure ``F[i, j] = np.abs(a[i] - a[j])``, and hence zero diagonals and nonnegative entries. A Fiedler matrix has a dominant positive eigenvalue and other eigenvalues are negative. Although not valid generally, for certain inputs, the inverse and the determinant can be derived explicitly. Args: a (cupy.ndarray): coefficient array Returns: cupy.ndarray: the symmetric Fiedler matrix .. seealso:: :func:`cupyx.scipy.linalg.circulant` .. seealso:: :func:`cupyx.scipy.linalg.toeplitz` .. seealso:: :func:`scipy.linalg.fiedler` rzInput `a` must be a 1D array.r)rrNr)rIr?r6r rJabs)rOs rrrs|( v{{8999v{{z!}}v{{z&!!! !!!T' QA 8A1   rfiedler_companionc|jdkrtd|jdkrtjd|jS|jdkr|d |dz dS||dz }|jdz }tj||f|j}tj|dd ddd dfdtj|dd ddd df|dd d tj|d d ddd dfdtj|d d ddd df|dd d |d |d <d|d <|S) alReturns a Fiedler companion matrix Given a polynomial coefficient array ``a``, this function forms a pentadiagonal matrix with a special structure whose eigenvalues coincides with the roots of ``a``. Args: a (cupy.ndarray): 1-D array of polynomial coefficients in descending order with a nonzero leading coefficient. For ``N < 2``, an empty array is returned. Returns: cupy.ndarray: Resulting companion matrix Notes: Similar to ``companion`` the leading coefficient should be nonzero. In the case the leading coefficient is not 1, other coefficients are rescaled before the array generation. To avoid numerical issues, it is best to provide a monic polynomial. .. seealso:: :func:`cupyx.scipy.linalg.companion` .. seealso:: :func:`scipy.linalg.fiedler_companion` rzInput `a` must be a 1-D array.r<rr)NNrHNrgrY)rIr?r6r rJrrL)rOr9r)s rrrsf2 v{{9:::vzzz$(((v{{1ad J'' !A$A  A Aq6)))AqAqt!t}a(((qAqt!t}qAwh///q1add|Q'''q1add|a1gX...teAdGAdG Hrconvolution_matrixr|c|dkrtd|jdkrtd|jdkrtd|dvrtdtj|d|dz fd}tj|d d d d|dz fd}|d krKt ||jdz }|d z}||z }|||j|z }|| |z |j|z } nV|d krCt ||jdz }|}|||j|z }|| |z |j|z } n |}|| d } t || S)a Construct a convolution matrix. Constructs the Toeplitz matrix representing one-dimensional convolution. Args: a (cupy.ndarray): The 1-D array to convolve. n (int): The number of columns in the resulting matrix. It gives the length of the input to be convolved with ``a``. This is analogous to the length of ``v`` in ``numpy.convolve(a, v)``. mode (str): This must be one of (``'full'``, ``'valid'``, ``'same'``). This is analogous to ``mode`` in ``numpy.convolve(v, a, mode)``. Returns: cupy.ndarray: The convolution matrix whose row count k depends on ``mode``: =========== ========================= ``mode`` k =========== ========================= ``'full'`` m + n - 1 ``'same'`` max(m, n) ``'valid'`` max(m, n) - min(m, n) + 1 =========== ========================= .. seealso:: :func:`cupyx.scipy.linalg.toeplitz` .. seealso:: :func:`scipy.linalg.convolution_matrix` rzn must be a positive integer.rz;convolution_matrix expects a one-dimensional array as inputzlen(a) must be at least 1.)r|validsamez8`mode` argument must be one of ('full', 'valid', 'same')constantNr$rr<r)r?rIr6r padminr") rOr9modeazraztrimtbtecol0row0s rrr s: Avv8999v{{*++ +v{{5666 ,,, LNN N !a1Xz * *B (1TTrT7Q!Hj 1 1C v~~1af~~! 1W BY"RWRZ- A2b5"$%  AF^^a  "RWRZ- A2b5"$%A233x D$  r)NrNrrc)F)r|)rrr rcupyx.scipy.linalgr implementsrrrr"r+r-r'r=r:ElementwiseKernelrArFrPrWrtrwr~rrrrrrrs~  &&&&&&E????>F    .F    2J333 3>K  66! 6&H333381111J""" ",+5* GA!u666 H   DFAAA.L!!**"!*ZK    !  DI    8I....E# # # # LI:'((- - )(- `())8 8 8 *)8 8 8 r