`iNddlZddlZddlmZddlmZddlmZddlmZddlmZddZdd Z dd Z d Z dd Z dd Z ddZ ddZddZddZddZddZdS)N)_coo)_csc)_csr)_dia)_sputilsdc ||}t|t|}}||kr|dkr|dvrutj|dzd}tj|d}tj||}|dkr tj}n t j}||||f||fS|dkr]tj|d} tj|d} tj||}tj || | ff||fStjdtdt||z|f|} t| ||| |S) aCreates a sparse matrix with ones on diagonal. Args: m (int): Number of rows. n (int or None): Number of columns. If it is ``None``, it makes a square matrix. k (int): Diagonal to place ones on. dtype: Type of a matrix to create. format (str or None): Format of the result, e.g. ``format="csr"``. Returns: cupyx.scipy.sparse.spmatrix: Created sparse matrix. .. seealso:: :func:`scipy.sparse.eye` Nr)csrcscidtyper coo)intcupyarangeonesr csr_matrixr csc_matrixr coo_matrixmaxminspdiagsasformat) mnkrformatindptrindicesdataclsrowcoldiagss q/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupyx/scipy/sparse/_construct.pyeyer( sj" y  q663q66qAAvv!q&& ^ # #[Qc222Fk!3///G9Qe,,,Doo3gv.A77 7 u__+as+++C+as+++C9Qe,,,D?D3*#51v>> > Iq#aQUA//0 > > >E 5!Q " " + +F 3 33c(t||||S)aCreates an identity matrix in sparse format. .. note:: Currently it only supports csr, csc and coo formats. Args: n (int): Number of rows and columns. dtype: Type of a matrix to create. format (str or None): Format of the result, e.g. ``format="csr"``. Returns: cupyx.scipy.sparse.spmatrix: Created identity matrix. .. seealso:: :func:`scipy.sparse.identity` )rr)r()rrrs r'identityr+4s" q!5 0 0 00r)c\tj||f||f|S)aCreates a sparse matrix from diagonals. Args: data (cupy.ndarray): Matrix diagonals stored row-wise. diags (cupy.ndarray): Diagonals to set. m (int): Number of rows. n (int): Number of cols. format (str or None): Sparse format, e.g. ``format="csr"``. Returns: cupyx.scipy.sparse.spmatrix: Created sparse matrix. .. seealso:: :func:`scipy.sparse.spdiags` shape)r dia_matrixr)r"r&rrrs r'rrHs/ ?D%=A 7 7 7 @ @ H HHr)czdkrdnd}tjd|D}|dj|}tjd|Dt |j|}tj|j|}tjtfd|Ddz|}|d}d} d} |D]} | j||krtd|z| j || | | j jz<| | j jz } t| | | jz} | j d d || <|| xx|z cc<| | jz } || j d z }||d <dkrtj|||f| |f Stj|||f|| f S) zYFast path for stacking CSR/CSC matrices (i) vstack for CSR, (ii) hstack for CSC. rr cg|] }|j S)r".0bs r' z,_compressed_sparse_stack..`s444QV444r)cg|] }|j Sr2)r r3s r'r6z,_compressed_sparse_stack..bs0J0J0Ja0J0J0Jr))arraysmaxvalrc32K|]}|jVdSNr-)r4r5axiss r' z+_compressed_sparse_stack..es=-- !GDM------r)z#incompatible dimensions for axis %dNr-)r concatenater.rget_index_dtypersizeemptysum ValueErrorr!slicer rrrr) blocksr< other_axisr" constant_dim idx_dtyper!r last_indptrsum_dim sum_indicesr5idxss ` r'_compressed_sparse_stackrN[s5aiiQJ  44V444 5 5D!9?:.L(0J0J60J0J0J03DI|0L0LNNNIj)444G Z----%+-----/018ACCCF)A,,KGK  $ $ 7: , . .5 BDD D:;) K 667qy~% Wg 566x}t t # 174= qx|# F2J qyygv6&-|%<>>> >gv6&2G%<>>> >r)c(t|g||S)aStacks sparse matrices horizontally (column wise) Args: blocks (sequence of cupyx.scipy.sparse.spmatrix): sparse matrices to stack format (str): sparse format of the result (e.g. "csr") by default an appropriate sparse matrix format is returned. This choice is subject to change. dtype (dtype, optional): The data-type of the output matrix. If not given, the dtype is determined from that of ``blocks``. Returns: cupyx.scipy.sparse.spmatrix: the stacked sparse matrix .. seealso:: :func:`scipy.sparse.hstack` Examples: >>> from cupy import array >>> from cupyx.scipy.sparse import csr_matrix, hstack >>> A = csr_matrix(array([[1., 2.], [3., 4.]])) >>> B = csr_matrix(array([[5.], [6.]])) >>> hstack([A, B]).toarray() array([[1., 2., 5.], [3., 4., 6.]]) rrbmatrFrrs r'hstackrT~s: u 5 5 55r)c:td|D||S)aStacks sparse matrices vertically (row wise) Args: blocks (sequence of cupyx.scipy.sparse.spmatrix) sparse matrices to stack format (str, optional): sparse format of the result (e.g. "csr") by default an appropriate sparse matrix format is returned. This choice is subject to change. dtype (dtype, optional): The data-type of the output matrix. If not given, the dtype is determined from that of `blocks`. Returns: cupyx.scipy.sparse.spmatrix: the stacked sparse matrix .. seealso:: :func:`scipy.sparse.vstack` Examples: >>> from cupy import array >>> from cupyx.scipy.sparse import csr_matrix, vstack >>> A = csr_matrix(array([[1., 2.], [3., 4.]])) >>> B = csr_matrix(array([[5., 6.]])) >>> vstack([A, B]).toarray() array([[1., 2.], [3., 4.], [5., 6.]]) cg|]}|gSr2r2r3s r'r6zvstack..s%%%!%%%r)rPrQrSs r'vstackrWs(: %%f%%%fE B B BBr)c P t|}t|d}g}t|D]C}t|D]1}|||!||||2Dt|dkrtjd|S|dkrF|dvrBt d|Dr)t |d}|||}|S|dkrF|dvrBt d |Dr)t |d}|||}|Stj ||ft} tj |dztj } tj |dztj } t|D]N} t|D]:} || | (tj|| | }||| | <d | | | <| | dzdkr|j d| | dz<nV| | dz|j dkr>> from cupy import array >>> from cupyx.scipy.sparse import csr_matrix, bmat >>> A = csr_matrix(array([[1., 2.], [3., 4.]])) >>> B = csr_matrix(array([[5.], [6.]])) >>> C = csr_matrix(array([[7.]])) >>> bmat([[A, B], [None, C]]).toarray() array([[1., 2., 5.], [3., 4., 6.], [0., 0., 7.]]) >>> bmat([[A, None], [None, C]]).toarray() array([[1., 2., 0.], [3., 4., 0.], [0., 0., 7.]]) rN)rrrr )Nr c3JK|]}t|tjVdSr;) isinstancerrr3s r'r=zbmat..sB&&1do..&&&&&&r))Nr c3JK|]}t|tjVdSr;)rZrrr3s r'r=zbmat..s.FFQ*Q00FFFFFFr)Tzeblocks[{i},:] has incompatible row dimensions. Got blocks[{i},{j}].shape[0] == {got}, expected {exp}.)r jexpgotzeblocks[:,{j}] has incompatible row dimensions. Got blocks[{i},{j}].shape[1] == {got}, expected {exp}.c3$K|] }|jV dSr;)nnz)r4blocks r'r=zbmat..#s$ 1 1Eei 1 1 1 1 1 1r)cg|] }|j Sr2r)r4blks r'r6zbmat..%s777Cci777r)r>)r9r-) lenrangeappendrrallrNastypenumpyzerosboolint64r.rrDrCrupcastcumsumrrBr@rnonzeroziprrEr`r"r$r%r)rFrrMN blocks_flatrrA block_mask brow_lengths bcol_lengthsr r\msgr` all_dtypes row_offsets col_offsetsr.r"rIr$r%iijjBidxs r'rRrRsT F A F1IAK 1XX11q 1 1Aay|'""6!9Q<000 1 ;1vU3333 Q6]** &&$&&& & &+ %[! 4 4  A q&&V},,FF+FFFFF- $[! 4 4  AaV4000J;qs%+666L;qs%+666L1XX**q * *Aay|'OF1IaL11 q ! #' 1 a !$))() L1%%!!A#&!'!*44--3Va18DQqS8I89 .4.D.D %S//)!$))() L1%%!!A#&!'!*44--3Va18DQqS8I89 .4.D.D %S//)1 *4  1 1[ 1 1 1 1 1C }77;777 0:D,,,|,,K,|,,K _k"o .E :c ' ' 'D(E ;;;I *S * * *C *S * * *C C ]: & &FBB 1 3q66N3q66 "Cqu%%FS 5;q>)C5;q>)C qu  ?D3*-U ; ; ; D DV L LLr){Gz?rc^|dks|dkrtdtj|}|jdvrt d|z||z}t ||z|z}| tj}n@t|t tjfrtj |}||j }| ||d} | |z} | | |zz } || |} tj| | | ff||f |S) aGenerates a random sparse matrix. This function generates a random sparse matrix. First it selects non-zero elements with given density ``density`` from ``(m, n)`` elements. So the number of non-zero elements ``k`` is ``k = m * n * density``. Value of each element is selected with ``data_rvs`` function. Args: m (int): Number of rows. n (int): Number of cols. density (float): Ratio of non-zero entries. format (str): Matrix format. dtype (~cupy.dtype): Type of the returned matrix values. random_state (cupy.random.RandomState or int): State of random number generator. If an integer is given, the method makes a new state for random number generator and uses it. If it is not given, the default state is used. This state is used to generate random indexes for nonzero entries. data_rvs (callable): A function to generate data for a random matrix. If it is not given, `random_state.rand` is used. Returns: cupyx.scipy.sparse.spmatrix: Generated matrix. .. seealso:: :func:`scipy.sparse.random` rr z(density expected to be 0 <= density <= 1fdztype %s not supportedNF)rAreplacer-)rDrrcharNotImplementedErrorrrandomrZinteger RandomStaterandchoicerhrrr) rrdensityrr random_statedata_rvsmnrindr\r valss r'rr?s?<{{gkkCDDD Ju  E z!"9E"ABBB QB GaK!OA{ L3 "5 6 6={..|<< $   bq%  8 8C qA a!e A 8A;;  e $ $D ? 1vq!f & & &&.hv&6&67r)c*t||||||S)aNGenerates a random sparse matrix. See :func:`cupyx.scipy.sparse.random` for detail. Args: m (int): Number of rows. n (int): Number of cols. density (float): Ratio of non-zero entries. format (str): Matrix format. dtype (~cupy.dtype): Type of the returned matrix values. random_state (cupy.random.RandomState or int): State of random number generator. If an integer is given, the method makes a new state for random number generator and uses it. If it is not given, the default state is used. This state is used to generate random indexes for nonzero entries. Returns: cupyx.scipy.sparse.spmatrix: Generated matrix. .. seealso:: :func:`scipy.sparse.rand` .. seealso:: :func:`cupyx.scipy.sparse.random` )r)rrrrrrs r'rrws2 !Q = ==r)c ` tj|rRt|dkstj|drtj|g}n6t dt ttj|}t|tj r| }tj|}t|t|krt d| 0 the k-th upper diagonal - k < 0 the k-th lower diagonal shape (tuple of int): Shape of the result. If omitted, a square matrix large enough to contain the diagonals is returned. format ({"dia", "csr", "csc", "lil", ...}): Matrix format of the result. By default (format=None) an appropriate sparse matrix format is returned. This choice is subject to change. dtype (dtype): Data type of the matrix. Returns: cupyx.scipy.sparse.spmatrix: Generated matrix. Notes: This function differs from `spdiags` in the way it handles off-diagonals. The result from `diags` is the sparse equivalent of:: cupy.diag(diagonals[0], offsets[0]) + ... + cupy.diag(diagonals[k], offsets[k]) Repeated diagonal offsets are disallowed. rz*Different number of diagonals and offsets.Nc^g|])}t|z|z td|z*S)r)rr)r4offsetrrs r'r6zdiags..sH $ $ $VQZ ( (3q&>> 9 $ $ $r)rz"Offset %d (index %d) out of bounds.r zUDiagonal length (index %d: %d at offset %d) does not agree with matrix size (%d, %d).r-)r isscalarlikerdr atleast_1drDlistmaprZndarraygetriabsr common_typerrjr enumeraterr/r) diagonalsoffsetsr.rrrqdata_arrKr\diagonalrrlengthrrs @@r'r&r&sJW%%: y>>Q  ("7 ! "E"E 334IIIJJ JT_i8899 '4<(( ++--w''G 9~~W%%EFFF }  !  C OO 4 4 4A } ), DAq  $ $ $ $ $" $ $ $ % %A Aq Az3w<<+5999H Aq A ++ 8 6NNQZVQ// A::4{BDD D &.sGVG|&r-)rrr.r`rrriinforlrr$rhrepeatr%r"reshaperavel)rtr~r out_shaperr$r%r"s r'kronrs& A Aagaj(!'!*qwqz*ABIuzzQUaZZy))226::: 9Q<1&&G)<)<)@@@   %,,u4, ( (171: 5C **QU  C %,,u4, ( (171: 5C **QU  C 6==  D{{2qu%%s{{2qu'='=C15LC15LCyy{{CIIKKC <<AE " "QV +D ::<r)ctj|}tj|}|jd|jdkrtd|jd|jdkrtdt j|j|j}tt|jd|||}t|t|jd||}||z |S)a%Kronecker sum of sparse matrices A and B. Kronecker sum is the sum of two Kronecker products ``kron(I_n, A) + kron(B, I_m)``, where ``I_n`` and ``I_m`` are identity matrices. Args: A (cupyx.scipy.sparse.spmatrix): a sparse matrix. B (cupyx.scipy.sparse.spmatrix): a sparse matrix. format (str): the format of the returned sparse matrix. Returns: cupyx.scipy.sparse.spmatrix: Generated sparse matrix with the specified ``format``. .. seealso:: :func:`scipy.sparse.kronsum` rr zA is not square matrixzB is not square matrixr)r) rrr.rDrrmrrr(r)rtr~rrLRs r'kronsumr%s& A AwqzQWQZ1222wqzQWQZ1222 OAGQW - -E S5 ) ) )1V<<rs ########################'''''''4'4'4'4T1111(IIII& > > >F6666@CCCC@~M~M~M~MB48'+57575757p>>>>8ZOZOZOZOz2>2>2>2>j!$!$!$!$!$!$r)