4[gYdZdZgdZddlZddlZddlZddlmZm Z ddl m Z m Z m Z ddlmZdd lmZmZdd lmZmZdd lmZmZdd lmZmZdd lmZmZddlm Z m!Z!d*dZ"ddddddZ#d+dZ$d,dZ%d-de&dddZ'd.dZ(dde&dfdZ)d-dZ*d-dZ+dZ,dZ-d/dZ.d/dZ/d/dZ0dddd Z1d0d!Z2d/d"Z3d#d$dddd%d&Z4 d1d'Z5 d2d(Z6d3d)Z7y)4z2Functions to construct sparse matrices and arrays zrestructuredtext en)spdiagseyeidentitykronkronsumhstackvstackbmatrandrandomdiags block_diag diags_array block_array eye_array random_arrayN)check_random_state rng_integers)upcastget_index_dtype isscalarlike) csr_hstack) bsr_matrix bsr_array) coo_matrix coo_array) csc_matrix csc_array) csr_matrix csr_array) dia_matrix dia_array)issparsesparraycz||t|dx}}n||\}}t||f||fj|S)a Return a sparse matrix from diagonals. Parameters ---------- data : array_like Matrix diagonals stored row-wise diags : sequence of int or an int Diagonals to set: * k = 0 the main diagonal * k > 0 the kth upper diagonal * k < 0 the kth lower diagonal m, n : int, tuple, optional Shape of the result. If `n` is None and `m` is a given tuple, the shape is this tuple. If omitted, the matrix is square and its shape is len(data[0]). format : str, optional Format of the result. By default (format=None) an appropriate sparse matrix format is returned. This choice is subject to change. .. warning:: This function returns a sparse matrix -- not a sparse array. You are encouraged to use ``diags_array`` to take advantage of the sparse array functionality. See Also -------- diags_array : more convenient form of this function diags : matrix version of diags_array dia_matrix : the sparse DIAgonal format. Examples -------- >>> import numpy as np >>> from scipy.sparse import spdiags >>> data = np.array([[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]) >>> diags = np.array([0, -1, 2]) >>> spdiags(data, diags, 4, 4).toarray() array([[1, 0, 3, 0], [1, 2, 0, 4], [0, 2, 3, 0], [0, 0, 3, 4]]) rshape)lenr"asformat)datar mnformats R/var/www/html/bid-api/venv/lib/python3.12/site-packages/scipy/sparse/_construct.pyrrsN^ yQYDG A 1 tUmAq6 2 ; ;F CC)offsetsr(r.dtypec Rt|r>t|dk(st|drtj|g}n.t dt t tj|}tj|}t|t|k7r t d|*t|dtt|dz}||f}|tj|}|\}}t|Dcgc]!}t||z||z td|z#c}}td|}tjt||f|} t||} t|D]R\} } || }td|} t||z||z | }|dkrt d|| fz | dd|f| | | | |zf<Tt| |f||f j|Scc}w#t$r?}t| |k7r+t| dk7rt d| t| |||fz|d}~wwxYw) a Construct a sparse array from diagonals. Parameters ---------- diagonals : sequence of array_like Sequence of arrays containing the array diagonals, corresponding to `offsets`. offsets : sequence of int or an int, optional Diagonals to set: - k = 0 the main diagonal (default) - k > 0 the kth upper diagonal - k < 0 the kth lower diagonal shape : tuple of int, optional Shape of the result. If omitted, a square array large enough to contain the diagonals is returned. format : {"dia", "csr", "csc", "lil", ...}, optional Matrix format of the result. By default (format=None) an appropriate sparse array format is returned. This choice is subject to change. dtype : dtype, optional Data type of the array. Notes ----- The result from `diags_array` is the sparse equivalent of:: np.diag(diagonals[0], offsets[0]) + ... + np.diag(diagonals[k], offsets[k]) Repeated diagonal offsets are disallowed. .. versionadded:: 1.11 Examples -------- >>> from scipy.sparse import diags_array >>> diagonals = [[1, 2, 3, 4], [1, 2, 3], [1, 2]] >>> diags_array(diagonals, offsets=[0, -1, 2]).toarray() array([[1, 0, 1, 0], [1, 2, 0, 2], [0, 2, 3, 0], [0, 0, 3, 4]]) Broadcasting of scalars is supported (but shape needs to be specified): >>> diags_array([1, -2, 1], offsets=[-1, 0, 1], shape=(4, 4)).toarray() array([[-2., 1., 0., 0.], [ 1., -2., 1., 0.], [ 0., 1., -2., 1.], [ 0., 0., 1., -2.]]) If only one diagonal is wanted (as in `numpy.diag`), the following works as well: >>> diags_array([1, 2, 3], offsets=1).toarray() array([[ 0., 1., 0., 0.], [ 0., 0., 2., 0.], [ 0., 0., 0., 3.], [ 0., 0., 0., 0.]]) rz*Different number of diagonals and offsets.Nr2z"Offset %d (index %d) out of bounds.rzTDiagonal length (index %d: %d at offset %d) does not agree with array size (%d, %d).r')rr)np atleast_1d ValueErrorlistmapabsint common_typemaxminzeros enumerater#r*) diagonalsr1r(r.r2r,r-offsetMdata_arrKjdiagonalklengthes r/rrQsGDG y>Q ,y|"<y12IIJ JR]]I67 mmG$G 9~W%EFF }  ! C O 4 4A } * DAq " $"VQZ (3q&> 9" $ %A Aq AxxWq)7H Aq A + 8 6NQZVQ/ A:AVQKOP P &.s7F7{&;HQ!F( ] #, h(A 7 @ @ HH/ $ 8}&3x=A+= 6s8}fa9445;<<   s2&G$G H&':H!!H&cTt||||}t|j|S)a# Construct a sparse matrix from diagonals. .. warning:: This function returns a sparse matrix -- not a sparse array. You are encouraged to use ``diags_array`` to take advantage of the sparse array functionality. Parameters ---------- diagonals : sequence of array_like Sequence of arrays containing the matrix diagonals, corresponding to `offsets`. offsets : sequence of int or an int, optional Diagonals to set: - k = 0 the main diagonal (default) - k > 0 the kth upper diagonal - k < 0 the kth lower diagonal shape : tuple of int, optional Shape of the result. If omitted, a square matrix large enough to contain the diagonals is returned. format : {"dia", "csr", "csc", "lil", ...}, optional Matrix format of the result. By default (format=None) an appropriate sparse matrix format is returned. This choice is subject to change. dtype : dtype, optional Data type of the matrix. See Also -------- spdiags : construct matrix from diagonals diags_array : construct sparse array instead of sparse matrix Notes ----- This function differs from `spdiags` in the way it handles off-diagonals. The result from `diags` is the sparse equivalent of:: np.diag(diagonals[0], offsets[0]) + ... + np.diag(diagonals[k], offsets[k]) Repeated diagonal offsets are disallowed. .. versionadded:: 0.11 Examples -------- >>> from scipy.sparse import diags >>> diagonals = [[1, 2, 3, 4], [1, 2, 3], [1, 2]] >>> diags(diagonals, [0, -1, 2]).toarray() array([[1, 0, 1, 0], [1, 2, 0, 2], [0, 2, 3, 0], [0, 0, 3, 4]]) Broadcasting of scalars is supported (but shape needs to be specified): >>> diags([1, -2, 1], [-1, 0, 1], shape=(4, 4)).toarray() array([[-2., 1., 0., 0.], [ 1., -2., 1., 0.], [ 0., 1., -2., 1.], [ 0., 0., 1., -2.]]) If only one diagonal is wanted (as in `numpy.diag`), the following works as well: >>> diags([1, 2, 3], 1).toarray() array([[ 0., 1., 0., 0.], [ 0., 0., 2., 0.], [ 0., 0., 0., 3.], [ 0., 0., 0., 0.]]) r1r(r2)rr"r*)rAr1r(r.r2As r/r r s*^ Iwe5IA a= ! !& ))r0c t||||S)aIdentity matrix in sparse format Returns an identity matrix with shape (n,n) using a given sparse format and dtype. This differs from `eye_array` in that it has a square shape with ones only on the main diagonal. It is thus the multiplicative identity. `eye_array` allows rectangular shapes and the diagonal can be offset from the main one. .. warning:: This function returns a sparse matrix -- not a sparse array. You are encouraged to use ``eye_array`` to take advantage of the sparse array functionality. Parameters ---------- n : int Shape of the identity matrix. dtype : dtype, optional Data type of the matrix format : str, optional Sparse format of the result, e.g., format="csr", etc. Examples -------- >>> import scipy as sp >>> sp.sparse.identity(3).toarray() array([[ 1., 0., 0.], [ 0., 1., 0.], [ 0., 0., 1.]]) >>> sp.sparse.identity(3, dtype='int8', format='dia') >>> sp.sparse.eye_array(3, dtype='int8', format='dia') )r2r.)r)r-r2r.s r/rrsN q!5 00r0)rHr2r.c t|||||S)aIdentity matrix in sparse array format Return a sparse array with ones on diagonal. Specifically a sparse array (m x n) where the kth diagonal is all ones and everything else is zeros. Parameters ---------- m : int or tuple of ints Number of rows requested. n : int, optional Number of columns. Default: `m`. k : int, optional Diagonal to place ones on. Default: 0 (main diagonal). dtype : dtype, optional Data type of the array format : str, optional (default: "dia") Sparse format of the result, e.g., format="csr", etc. Examples -------- >>> import numpy as np >>> import scipy as sp >>> sp.sparse.eye_array(3).toarray() array([[ 1., 0., 0.], [ 0., 1., 0.], [ 0., 0., 1.]]) >>> sp.sparse.eye_array(3, dtype=np.int8) _eyer,r-rHr2r.s r/rrEsD 1a ''r0c |rt}t}t}t} nt}t }t }t} ||}t|t|}}||k(r|dk(r|dvrjt|} tj|dz| } tj|| } tj||} ||d|}|| | | f||fS|dk(r`t|} tj|| }tj|| }tj||} || ||ff||fStjdtdt||z|f|} | | |g||f|j|S)Nr)csrcscmaxvalrr4coorL)r!rrrr rrr r;rr5arangeonesr=r>r*)r,r-rHr2r. as_sparray csr_sparse csc_sparse coo_sparse diags_sparse idx_dtypeindptrindicesr+clsrowcols r/rQrQjse   "     y  q63q6qAAv!q& ^ #'q1IYYqs)4Fii3G771E*D$Z8@Cgv.A7 7 u_'q1I))AY/C))AY/C771E*Dtc3Z01a&9 9 77As1c!a%m,-U ;D qc!Qu E N Nv VVr0c"t|||||dS)a/Sparse matrix with ones on diagonal Returns a sparse matrix (m x n) where the kth diagonal is all ones and everything else is zeros. Parameters ---------- m : int Number of rows in the matrix. n : int, optional Number of columns. Default: `m`. k : int, optional Diagonal to place ones on. Default: 0 (main diagonal). dtype : dtype, optional Data type of the matrix. format : str, optional Sparse format of the result, e.g., format="csr", etc. .. warning:: This function returns a sparse matrix -- not a sparse array. You are encouraged to use ``eye_array`` to take advantage of the sparse array functionality. Examples -------- >>> import numpy as np >>> import scipy as sp >>> sp.sparse.eye(3).toarray() array([[ 1., 0., 0.], [ 0., 1., 0.], [ 0., 0., 1.]]) >>> sp.sparse.eye(3, dtype=np.int8) FrPrRs r/rrsL 1a ..r0c t|tst|trt}t}t}nt }t }t}||}|jdk7rtd|jd||dk(r[d|jz|jd|jdzk\r+||d}|jdk7rtd |jd|jd|jdz|jd|jdzf}|jdk(s|jdk(r||j|S|j}|jj|j j#d |jd|jd}||z}|||j$|j&f| S||}|jdk7rtd |jd|jd|jdz|jd|jdzf}|jdk(s|jdk(r||j|S|j(j|j}|j*j|j} |jj|j}t-|jd|jdz|jd|jdzt/j0d j,kDr>|j3t.j4}| j3t.j4} ||jdz}| |jdz} |j#d |j| j#d |j} }||j(z }| |j*z } |j#d | j#d } }|j#d |j|jz}|j#d }|||| ff| j|S) aFkronecker product of sparse matrices A and B Parameters ---------- A : sparse or dense matrix first matrix of the product B : sparse or dense matrix second matrix of the product format : str, optional (default: 'bsr' or 'coo') format of the result (e.g. "csr") If None, choose 'bsr' for relatively dense array and 'coo' for others Returns ------- kronecker product in a sparse format. Returns a sparse matrix unless either A or B is a sparse array in which case returns a sparse array. Examples -------- >>> import numpy as np >>> import scipy as sp >>> A = sp.sparse.csr_array(np.array([[0, 2], [5, 0]])) >>> B = sp.sparse.csr_array(np.array([[1, 2], [3, 4]])) >>> sp.sparse.kron(A, B).toarray() array([[ 0, 0, 2, 4], [ 0, 0, 6, 8], [ 5, 10, 0, 0], [15, 20, 0, 0]]) >>> sp.sparse.kron(A, [[1, 2], [3, 4]]).toarray() array([[ 0, 0, 2, 4], [ 0, 0, 6, 8], [ 5, 10, 0, 0], [15, 20, 0, 0]]) z&kron requires 2D input arrays. `B` is D.bsrrrTcopyz&kron requires 2D input arrays. `A` is r'int32) isinstancer%rr!rrr rndimr7nnzr(r*toarrayr+repeatsizereshaperbrardrer=r5iinfoastypeint64) rMBr. bsr_sparser\r^ output_shaper+rdres r/rrsN!WAw!7      1 Avv{A!&&LMM &E/qw!''!*qwwqz:Q/Q qd # 66Q;EaffXRPQ Q 1771:-qwwqz!''!*/DE 55A:!l+44V< < IIKvv}}QVV$,,R 1771:Fax4 !((3<HH qM 66Q;EaffXRPQ Q 1771:-qwwqz!''!*/DE 55A:!l+44V< <eell155!eell155!vv}}QUU# qwwqz!''!*$aggaj&; qvvhbIJJvv{>qvvhbIJJwwqzQWWQZ*++wwqzQWWQZ*++ 177AGG $E !''!*E 2C !''!*E 2C S!E"A QE"A E  F ##r0cdk(rdnd}tj|Dcgc]}|jc}}|dj|}t |Dcgc]}|j c}t |j|}tj|j|}tjtfd|Ddz|} |d} d} d} |D]}|j||k7rtd||j|| | |jjz| |jjz } t| | |jz} |j dd| | <| | xx| z cc<| |jz } | |j dz } | | d<|r)dk(rt||| f| |f St||| f|| f Sdk(rt||| f| |f St!||| f|| f Scc}wcc}w) zh Stacking fast path for CSR/CSC matrices or arrays (i) vstack for CSR, (ii) hstack for CSC. rr)arraysrWr4c3<K|]}|jywN _shape_as_2d.0baxiss r/ z+_compressed_sparse_stack..as?1!...z!incompatible dimensions for axis Nrmr')r5 concatenater+rrrar=rtemptysumr7rbslicer rr!r)blocksrreturn_spmatrix other_axisrr+ constant_dimr`rbra last_indptrsum_dim sum_indicesidxss ` r/_compressed_sparse_stackrVs aiQJ >>626a16662 3D!9))*5L&'A&Q&'A'*499l'CEIhhtyy 2G XXc???!C9 UFA,KGK  >>* % 5@ MN N:;)) K 67qyy~~% Wgt(<<=xx}t t # 1>>$''qxx|# F2J 19tWf5%,l$;= =tWf5%17$;= = qy$0!(, 79 9$0!-w 79 9C3'As G:G?c &t|}|dk(r td|dk(r|dSdk(rdnd}|Dchc]}|j|}}t|dkDrtd|d||\}|Dcgc]}|j}}t j |Dcgc]}|j c}}tfd|D} td|D} tt| dz | } t j|Dcgc]}|jc}| } |jdkDrt j |j| } t j |Dcgc]}|jc}j| }t j|dz| }t j|}t j|}t!||| | ||||| nRt j"|dz| }t jd| }t jd|j$ }dk(r|dj'|||f| |f S|dj)|||f|| f Scc}wcc}wcc}wcc}wcc}w) zs Stacking fast path for CSR/CSC matrices along the minor axis (i) hstack for CSR, (ii) vstack for CSC. rzMissing block matricesrz"Mismatching dimensions along axis z: c3<K|]}|jywrrrs r/rz*_stack_along_minor_axis..s71!..&rc3FK|]}t|jywr)r)rbrrs r/rz*_stack_along_minor_axis..s -fc!))nfs!rVr4r')r)r7rrar5rr+rrr=arrayrtrwrbr empty_likerr?r2_csc_container_csr_container)rrn_blocksrrother_axis_dimsr indptr_listdata_catrrqr` stack_dim_cat indptr_cat indices_catrarbr+s ` r/_stack_along_minor_axisrs 6{H1}1221}ayaiQJ;AB6aq~~j16OB ?a=j\+,./ /#ML&,,V188VK,~~v6v!qvvv67H777G -f - -Cs7Q;'<=IHHFCFqannT2FC9UM}}q^^K077 B ~~&&A&Qqyy&&ABy) ,*)<-- ,}}X&8\={H7D *,*)<((1I.xx0 qyay''w(?!(, 7(9 9ay''w(?!-w 7(9 9OC-6D'BsI:3I?JJ ,Jctj|d}td|jDrt |g||St |g||dS)a Stack sparse matrices horizontally (column wise) Parameters ---------- blocks sequence of sparse matrices with compatible shapes 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 ------- new_array : sparse matrix or array If any block in blocks is a sparse array, return a sparse array. Otherwise return a sparse matrix. If you want a sparse array built from blocks that are not sparse arrays, use `block(hstack(blocks))` or convert one block e.g. `blocks[0] = csr_array(blocks[0])`. See Also -------- vstack : stack sparse matrices vertically (row wise) Examples -------- >>> from scipy.sparse import coo_matrix, hstack >>> A = coo_matrix([[1, 2], [3, 4]]) >>> B = coo_matrix([[5], [6]]) >>> hstack([A,B]).toarray() array([[1, 2, 5], [3, 4, 6]]) objectr4c3<K|]}t|tywrror%rs r/rzhstack.. 7;a:a !;Trr5asarrayanyflat_blockrr.r2s r/rrsKPZZh /F 76;; 77vh..vhtDDr0ctj|d}td|jDrt |Dcgc]}|gc}||St |Dcgc]}|gc}||dScc}wcc}w)a Stack sparse arrays vertically (row wise) Parameters ---------- blocks sequence of sparse arrays with compatible shapes format : str, optional sparse format of the result (e.g., "csr") by default an appropriate sparse array format is returned. This choice is subject to change. dtype : dtype, optional The data-type of the output array. If not given, the dtype is determined from that of `blocks`. Returns ------- new_array : sparse matrix or array If any block in blocks is a sparse array, return a sparse array. Otherwise return a sparse matrix. If you want a sparse array built from blocks that are not sparse arrays, use `block(vstack(blocks))` or convert one block e.g. `blocks[0] = csr_array(blocks[0])`. See Also -------- hstack : stack sparse matrices horizontally (column wise) Examples -------- >>> from scipy.sparse import coo_array, vstack >>> A = coo_array([[1, 2], [3, 4]]) >>> B = coo_array([[5, 6]]) >>> vstack([A, B]).toarray() array([[1, 2], [3, 4], [5, 6]]) rr4c3<K|]}t|tywrrrs r/rzvstack..rrTrr)rr.r2rs r/rrsqRZZh /F 76;; 77F+FqsF+VU;;F+FqsF+VUDQQ,+s A. A3ctj|d}td|jDr t |||St |||dS)a Build a sparse array or matrix from sparse sub-blocks Note: `block_array` is preferred over `bmat`. They are the same function except that `bmat` can return a deprecated sparse matrix. `bmat` returns a coo_matrix if none of the inputs are a sparse array. .. warning:: This function returns a sparse matrix -- not a sparse array. You are encouraged to use ``block_array`` to take advantage of the sparse array functionality. Parameters ---------- blocks : array_like Grid of sparse matrices with compatible shapes. An entry of None implies an all-zero matrix. format : {'bsr', 'coo', 'csc', 'csr', 'dia', 'dok', 'lil'}, optional The 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 ------- bmat : sparse matrix or array If any block in blocks is a sparse array, return a sparse array. Otherwise return a sparse matrix. If you want a sparse array built from blocks that are not sparse arrays, use `block_array()`. See Also -------- block_array Examples -------- >>> from scipy.sparse import coo_array, bmat >>> A = coo_array([[1, 2], [3, 4]]) >>> B = coo_array([[5], [6]]) >>> C = coo_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]]) rr4c3<K|]}t|tywrrrs r/rzbmat..SrrTrrrs r/r r sGrZZh /F 76;; 77ffe,,ffeTBBr0)r.r2ct|||S)a Build a sparse array from sparse sub-blocks Parameters ---------- blocks : array_like Grid of sparse arrays with compatible shapes. An entry of None implies an all-zero array. format : {'bsr', 'coo', 'csc', 'csr', 'dia', 'dok', 'lil'}, optional The sparse format of the result (e.g. "csr"). By default an appropriate sparse array format is returned. This choice is subject to change. dtype : dtype, optional The data-type of the output array. If not given, the dtype is determined from that of `blocks`. Returns ------- block : sparse array See Also -------- block_diag : specify blocks along the main diagonals diags : specify (possibly offset) diagonals Examples -------- >>> from scipy.sparse import coo_array, block_array >>> A = coo_array([[1, 2], [3, 4]]) >>> B = coo_array([[5], [6]]) >>> C = coo_array([[7]]) >>> block_array([[A, B], [None, C]]).toarray() array([[1, 2, 5], [3, 4, 6], [0, 0, 7]]) >>> block_array([[A, None], [None, C]]).toarray() array([[1, 2, 0], [3, 4, 0], [0, 0, 7]]) )rrs r/rrYsV &&% ((r0c  tj|d}|jdk7r td|j\}}|dvrt d|j Dro|dkDrAt|Dcgc]}t||ddfdg}}tj|d}t|dddfd|}||j|}|S|d vrt d |j Drp|dkDrBt|Dcgc]}t|dd|fdc}g}tj|d}t|dddfd|}||j|}|Stj|jt}tj|tj} tj|tj} t|D]} t|D]} || | f t|| | f}||| | f<d || | f<| | dk(r|jd| | <nB| | |jdk7r-d | d | d| d|jdd| | d } t| | | dk(r|jd| | <| | |jdk7sd| d| d| d|jdd| | d } t| t!d||D}|(||Dcgc]}|j"}}|rt%|nd}tj&dtj(| }tj&dtj(| }|d|df}tj*||}t-t/|}tj*||}tj*||}d}tj0|\}}t3||D]\} } || | f}t5|||j6z}|j8||<tj:|j<|| |||tj:|j>|| |||||j6z }|r tA|||ff|jC|St|||ff|jC|Scc}wcc}wcc}w)Nrr4rhzblocks must be 2-D)NrTc3TK|] }t|xr|jdk("yw)rTNr$r.rs r/rz_block..s& C{!HQK -AHH- -{&(rr)NrUc3TK|] }t|xr|jdk("yw)rUNrrs r/rz_block..s& EAhqk/ahh%//rTzblocks[z0,:] has incompatible row dimensions. Got blocks[,z].shape[0] == z , expected .z blocks[:,z1] has incompatible column dimensions. Got blocks[z].shape[1] == c34K|]}|jywr)rq)rblocks r/rz_block..s 8%7Eeii%7srmrV)outr2r')"r5rrpr7r(allrrangerrrwr?boolrxrrrr2rappendcumsumrrr=nonzeroziprrqr+addrdrerr*)rr.r2rrCNrrM block_mask brow_lengths bcol_lengthsirFmsgrqblk all_dtypes row_offsets col_offsetsr(r+r`rdreiijjryidxs r/rrs ZZh /F {{a-.. ,,CAa - Cv{{ CC q5JOPQ(S(Q.vad|Q?@(FSZZh7F %VAqD\1o F  A M ! E E E q5INqRA.vad|Q?RSFZZh7F %VAqD\1o F  A&,,d3J88ARXX.L88ARXX.L1XqAac{&fQqSk*qs "& 1Q3?a'&'nnQ&7LO!!_q(99$QC())*1QC~annQ>O=PQ''3A&7q:C%S/)?a'&'nnQ&7LO!!_q(99&qc*))*1QC~annQ>O=PQ''3A&7q:C%S/)+0  8VJ%7 8 8C }+1*+=>+=Ccii+= >'1 #t))Aryy67K))Aryy67K _k"o .E 88Cu %Ds5z2I ((3i (C ((3i (C C ZZ #FBB 1 1a4LCquu%FFS  quuk!n#c()D quuk!n#c()D quu  4#s,E:CCFKK dS#J'u 5 > >v FF]TSP?s3SS -Sctd|Drt}nt}g}g}g}d}d}|D]R} t| tt j frttj| } t| rw| j} | j\} } |j| j|z|j| j|z|j| jn| j \} } tj"tj$| | z| \} } |j| |z|j| |z|j| j'|| z }|| z }Utj(|}tj(|}tj(|}||||ff||f|j+|S)ab Build a block diagonal sparse matrix or array from provided matrices. Parameters ---------- mats : sequence of matrices or arrays Input matrices or arrays. format : str, optional The sparse format of the result (e.g., "csr"). If not given, the result is returned in "coo" format. dtype : dtype specifier, optional The data-type of the output. If not given, the dtype is determined from that of `blocks`. Returns ------- res : sparse matrix or array If at least one input is a sparse array, the output is a sparse array. Otherwise the output is a sparse matrix. Notes ----- .. versionadded:: 0.11.0 See Also -------- block_array diags_array Examples -------- >>> from scipy.sparse import coo_array, block_diag >>> A = coo_array([[1, 2], [3, 4]]) >>> B = coo_array([[5], [6]]) >>> C = coo_array([[7]]) >>> block_diag((A, B, C)).toarray() array([[1, 2, 0, 0], [3, 4, 0, 0], [0, 0, 5, 0], [0, 0, 6, 0], [0, 0, 0, 7]]) c3<K|]}t|tywrr)ras r/rzblock_diag..s 04a:a !4rr)r(r2)rrrror8numbersNumberr5 atleast_2dr$tocoorrrdrer+r(divmodrYravelrr*)matsr.r2 containerrdrer+r_idxc_idxrnrowsncolsa_rowa_cols r/r r sZ 04 00  C C D E E  a$/ 0"--*+A A; A>>LE5 JJquuu} % JJquuu} % KK 77LE599RYYuU{%;UCLE5 JJuu} % JJuu} % KK "  !" .. C .. C >>$ D dS#J'"EN! ##+8F#34r0{Gz?rX)densityr.r2 random_state data_samplerc|tjj}t||||||\}}t ||f|j |S)a[Return a sparse array of uniformly random numbers in [0, 1) Returns a sparse array with the given shape and density where values are generated uniformly randomly in the range [0, 1). .. warning:: Since numpy 1.17, passing a ``np.random.Generator`` (e.g. ``np.random.default_rng``) for ``random_state`` will lead to much faster execution times. A much slower implementation is used by default for backwards compatibility. Parameters ---------- shape : int or tuple of ints shape of the array density : real, optional (default: 0.01) density of the generated matrix: density equal to one means a full matrix, density of 0 means a matrix with no non-zero items. format : str, optional (default: 'coo') sparse matrix format. dtype : dtype, optional (default: np.float64) type of the returned matrix values. random_state : {None, int, `Generator`, `RandomState`}, optional A random number generator to determine nonzero structure. We recommend using a `numpy.random.Generator` manually provided for every call as it is much faster than RandomState. - If `None` (or `np.random`), the `numpy.random.RandomState` singleton is used. - If an int, a new ``Generator`` instance is used, seeded with the int. - If a ``Generator`` or ``RandomState`` instance then that instance is used. This random state will be used for sampling `indices` (the sparsity structure), and by default for the data values too (see `data_sampler`). data_sampler : callable, optional (default depends on dtype) Sampler of random data values with keyword arg `size`. This function should take a single keyword argument `size` specifying the length of its returned ndarray. It is used to generate the nonzero values in the matrix after the locations of those values are chosen. By default, uniform [0, 1) random values are used unless `dtype` is an integer (default uniform integers from that dtype) or complex (default uniform over the unit square in the complex plane). For these, the `random_state` rng is used e.g. `rng.uniform(size=size)`. Returns ------- res : sparse array Examples -------- Passing a ``np.random.Generator`` instance for better performance: >>> import numpy as np >>> import scipy as sp >>> rng = np.random.default_rng() Default sampling uniformly from [0, 1): >>> S = sp.sparse.random_array((3, 4), density=0.25, random_state=rng) Providing a sampler for the values: >>> rvs = sp.stats.poisson(25, loc=10).rvs >>> S = sp.sparse.random_array((3, 4), density=0.25, ... random_state=rng, data_sampler=rvs) >>> S.toarray() array([[ 36., 0., 33., 0.], # random [ 0., 0., 0., 0.], [ 0., 0., 36., 0.]]) Building a custom distribution. This example builds a squared normal from np.random: >>> def np_normal_squared(size=None, random_state=rng): ... return random_state.standard_normal(size) ** 2 >>> S = sp.sparse.random_array((3, 4), density=0.25, random_state=rng, ... data_sampler=np_normal_squared) Or we can build it from sp.stats style rvs functions: >>> def sp_stats_normal_squared(size=None, random_state=rng): ... std_normal = sp.stats.distributions.norm_gen().rvs ... return std_normal(size=size, random_state=random_state) ** 2 >>> S = sp.sparse.random_array((3, 4), density=0.25, random_state=rng, ... data_sampler=sp_stats_normal_squared) Or we can subclass sp.stats rv_continous or rv_discrete: >>> class NormalSquared(sp.stats.rv_continuous): ... def _rvs(self, size=None, random_state=rng): ... return random_state.standard_normal(size) ** 2 >>> X = NormalSquared() >>> Y = X().rvs >>> S = sp.sparse.random_array((3, 4), density=0.25, ... random_state=rng, data_sampler=Y) r')r5r default_rng_randomrr*)r(rr.r2rrr+inds r/rr6sQTyy,,. w|\RID# dC[ . 7 7 ??r0c |dks|dkDr tdtj|}tt ||z}t ||at jt jrfd}n6t jt jrfd}n j}|t jt jjkr-j||d}t j||d } nt!|} t#} t!| |krJ|t!| z } | j%t't(t+|| | f t!| |krJt)t j,t/| j0} || j3d } | | fS) Nrrz(density expected to be 0 <= density <= 1cttjjtjj|S)Nr4)rr5rvr>r=)rtr2rngs r/rz_random..data_samplers:#C$&HHUO$7$7$&HHUO$7$7$(*/ 11r0cTj|j|dzzS)Nrty?)uniform)rtrs r/rz_random..data_samplers.  .  .345r0F)rtreplaceF)r(orderrrk)r7mathprodr;roundrr5 issubdtypeintegercomplexfloatingrrvrxr=choice unravel_indexr)setupdater9tuplerrr8Trw)r(rr.r2rrtot_prodrt raveled_indrrpseendsizevalsrs ` @r/rrsq{gkCDDyyH uWx'( )D \ *C == + 1 ]]5""4"4 5 5;;L"((288$(((jjejD {%sC5zu$i$3t9$E KKE<U%#OP Q$i$BHHT$Z(**+ T " ) )%e ) >> import scipy as sp >>> import numpy as np >>> rng = np.random.default_rng() >>> S = sp.sparse.random(3, 4, density=0.25, random_state=rng) Providing a sampler for the values: >>> rvs = sp.stats.poisson(25, loc=10).rvs >>> S = sp.sparse.random(3, 4, density=0.25, random_state=rng, data_rvs=rvs) >>> S.toarray() array([[ 36., 0., 33., 0.], # random [ 0., 0., 0., 0.], [ 0., 0., 36., 0.]]) Building a custom distribution. This example builds a squared normal from np.random: >>> def np_normal_squared(size=None, random_state=rng): ... return random_state.standard_normal(size) ** 2 >>> S = sp.sparse.random(3, 4, density=0.25, random_state=rng, ... data_rvs=np_normal_squared) Or we can build it from sp.stats style rvs functions: >>> def sp_stats_normal_squared(size=None, random_state=rng): ... std_normal = sp.stats.distributions.norm_gen().rvs ... return std_normal(size=size, random_state=random_state) ** 2 >>> S = sp.sparse.random(3, 4, density=0.25, random_state=rng, ... data_rvs=sp_stats_normal_squared) Or we can subclass sp.stats rv_continous or rv_discrete: >>> class NormalSquared(sp.stats.rv_continuous): ... def _rvs(self, size=None, random_state=rng): ... return random_state.standard_normal(size) ** 2 >>> X = NormalSquared() >>> Y = X() # get a frozen version of the distribution >>> S = sp.sparse.random(3, 4, density=0.25, random_state=rng, data_rvs=Y.rvs) Nc|Sr)rtdata_rvss r/ data_rvs_kwzrandom..data_rvs_kwAs D> !r0r')r;rrr*) r,r-rr.r2rrrrrs ` r/r r soR y  q63q6qA " A kRID# tSk!Q 0 9 9& AAr0c"t||||||S)a?Generate a sparse matrix of the given shape and density with uniformly distributed values. .. warning:: This function returns a sparse matrix -- not a sparse array. You are encouraged to use ``random_array`` to take advantage of the sparse array functionality. Parameters ---------- m, n : int shape of the matrix density : real, optional density of the generated matrix: density equal to one means a full matrix, density of 0 means a matrix with no non-zero items. format : str, optional sparse matrix format. dtype : dtype, optional type of the returned matrix values. random_state : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional If `seed` is None (or `np.random`), the `numpy.random.RandomState` singleton is used. If `seed` is an int, a new ``RandomState`` instance is used, seeded with `seed`. If `seed` is already a ``Generator`` or ``RandomState`` instance then that instance is used. Returns ------- res : sparse matrix Notes ----- Only float types are supported for now. See Also -------- random : Similar function allowing a custom random data sampler random_array : Similar to random() but returns a sparse array Examples -------- >>> from scipy.sparse import rand >>> matrix = rand(3, 4, density=0.25, format="csr", random_state=42) >>> matrix >>> matrix.toarray() array([[0.05641158, 0. , 0. , 0.65088847], # random [0. , 0. , 0. , 0.14286682], [0. , 0. , 0. , 0. ]]) )r )r,r-rr.r2rs r/r r Isr !Q ==r0)NNN)rNNN)dNr)T)NN)F)rNNNN)rrXNNN)rrXNN)8__doc__ __docformat____all__rrnumpyr5scipy._lib._utilrr_sputilsrrr _sparsetoolsr_bsrrr_coorr_cscrr_csrr r!_diar"r#_baser$r%rrr rfloatrrQrrrrrrrr rrr rrr r rr0r/r$s&  F =;;$'''''$3Dl*+$t4tInP*f'1T"(auT"(J"WJQeD&/RfQR2$j(9V69r,E^-R`=C@#'d+)\\G~M4`$(T"m@`59,0*Z48'+sBl9>r0