\ci TdZdZgdZddlZddlZddlZddlZddlZddlZ ddl m Z m Z m Z ddlmZddlmZmZmZmZdd lmZdd lmZmZdd lmZmZdd lmZmZdd l m!Z!m"Z"ddl#m$Z$m%Z%ddl&m'Z'm(Z(dddZ)dZ*d5dZ+d6dZ,dddeddZ-dddefdZ.d7dZ/d8de0dddZ1d9dZ2dde0dfdZ3d8d Z4d8d!Z5d"Z6d#Z7d:d$Z8d:d%Z9d:d&Z:ddd'd(Z;d;d)Z dd4ZAdS)?z2Functions to construct sparse matrices and arrays zrestructuredtext en)spdiagseyeidentitykronkronsumhstackvstackbmatrandrandomdiags block_diag diags_array block_array eye_array random_array expand_dims permute_dimsswapaxesN)check_random_state rng_integers_transition_to_rng)_NoValue)upcastget_index_dtype isscalarlike isintlike) csr_hstack) bsr_matrix bsr_array) coo_matrix coo_array) csc_matrix csc_array) csr_matrix csr_array) dia_matrix dia_array)issparsesparray)axisct|std|d|dkr|n ||jzdz}|dks ||jkrtd|d|jd|d}t j|jd}|jd ||fz|j|d z|_|jd |d z|j|d z|_|j d kr |j |_ |S) a  Add trivial axes to an array. Shape gets a ``1`` inserted at position `axis`. Parameters ---------- A : sparse array axis : int Position in the expanded axes where the new axis (or axes) is placed. For a dimension ``N`` array, a valid axis is an integer on the closed-interval ``[-N-1, N]``. Negative values work from the end of the shape. ``0`` prepends an axis, as does ``-N-1``. ``-1`` appends an axis, as does ``N``. The new axis has shape ``1`` and indices are created with the value ``0``. Returns ------- out : sparse array A expanded copy output in COO format with the same dtype as `A`. Raises ------ ValueError If provided a non-integer or out of range ``[-N-1, N]`` axis, where ``N`` is ``A.ndim``. Examples -------- >>> from scipy.sparse import csr_array, expand_dims >>> A = csr_array([[1, 2], [2, 0]]) >>> A.shape (2, 2) >>> expand_dims(A, axis=1).shape (2, 1, 2) z Invalid axis z. Must be an integer.rrz for N=z. Must be in [-N-1, N].TcopyNrcoo) r ValueErrorndimtocoonp zeros_likecoordsshape_shapeformathas_canonical_format)Ar,idxnewA new_coords g/var/www/html/mdtn/previsions/meteo_cartes/venv/lib/python3.11/site-packages/scipy/sparse/_construct.pyrr sJ T??FDDDDEEE!))$$!2C Qww#,,UUUafUUUVVV 777  D dk!n--I+dsd#yl2T[5FFDK*TcT"T)DJstt,<>> from scipy.sparse import coo_array, swapaxes >>> A = coo_array([[[1, 2, 3], [2, 0, 0]]]) >>> A.shape (1, 2, 3) >>> swapaxes(A, 1, 2).shape (1, 3, 2) zindex z axis rrzInvalid axis: z ndim=NT)axesr/) r5aranger3 IndexErrorstr removeprefixsplitr2tupler)r<axis1axis2rCerrmsgs r@rrUs@ 9QV  D?#UEN3eU^ ???#hhx((..x;;A>=#==QV==>>> ? ;;D 4 0 0 00s+ BAB  BFc&j}|&tt|ddd}n-t||krt d|djt |tt fs`tjtj t|tj stdt||f}g}|D]_}t|std|d|dkr||z }|dks||krt d ||`t|tt|krt d |}|t t|kr|snS| tfd |D_tfd |D_d_S)aPermute the axes of the sparse array `A` to the order `axes`. Parameters ---------- A : sparse array axes : tuple or list of ints, optional If specified, it must be a tuple or list which contains a permutation of ``[0, 1, ..., N-1]`` where ``N`` is ``A.ndim``. The ith axis of the returned array will correspond to the axis numbered ``axes[i]`` of the input. If not specified, defaults to ``range(A.ndim)[::-1]``, which reverses the order of the axes. copy : bool, optional (default: False) Whether to return the permutation as a copy. If False, an in-place permutation is provided if possible depending on format. Returns ------- out : sparse array in COO format A copy of `A` with permuted axes. Raises ------ ValueError If provided a non-integer or out of range ``[-N, N-1]`` axis, where ``N`` is ``A.ndim``. Examples -------- >>> from scipy.sparse import coo_array, permute_dims >>> A = coo_array([[[1, 2, 3], [2, 0, 0]]]) >>> A.shape (1, 2, 3) >>> permute_dims(A, axes=(1, 2, 0)).shape (2, 3, 1) NzIncorrect number of axes: z instead of z+axis must be an integer/tuple of ints, not z axis must be an integer. (given )rzaxis out of range for ndimzduplicate value in axisr.c32K|]}j|VdSNr8.0r=r<s r@ zpermute_dims..s)22cQWS\222222rAc32K|]}j|VdSrRr7rTs r@rVzpermute_dims..s)33sQXc]333333rAF)r3rIrangelenr2 isinstancelistr5 issubdtypedtypetypeinteger TypeErrorrappendsetr/r4r9r7r;)r<rCr/r3 canon_axesaxs` r@rrsJ 6D |U4[[2&'' Td  PdPPPPQQQ dUDM * *}RXd4jj112:>> XV$t**VVWW WwJ}} FDrDDDEE E 66 $JB 66R4ZZ9:: :" :#c*oo....2333 D tE$KK    *qq!&&((* TA2222T22222AH3333d33333AH"A HrAc||t|dx}}n||\}}t||f||f|S)a Return a sparse matrix from diagonals. .. warning:: This function returns a sparse matrix -- not a sparse array. You are encouraged to use `dia_array` to take advantage of the sparse array functionality. (See Notes below.) 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. Returns ------- new_matrix : sparse matrix `dia_matrix` format with values in ``data`` on diagonals from ``diags``. Notes ----- This function can be replaced by an equivalent call to `dia_matrix` as:: dia_matrix((data, diags), shape=(m, n)).asformat(format) 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]]) NrrS)rZr(asformat)datar mnr:s r@rrs[v yQYDG AA 1 tUmAq6 2 2 2 ; ;F C CCrA)offsetsr8r:r^cDt|rMt|dkst|drtj|g}n6t dt t tj|}tj|}t|t|krt d| 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. If `dtype` is None, the output data type is determined by the data type of the input diagonals. Up until SciPy 1.19, the default behavior will be to return an array with an inexact (floating point) data type. In particular, integer input will be converted to double precision floating point. This behavior is deprecated, and in SciPy 1.19, the default behavior will be changed to return an array with the same data type as the input diagonals. To adopt this behavior before version 1.19, use `dtype=None`. Returns ------- new_array : dia_array `dia_array` holding the values in `diagonals` offset from the main diagonal as indicated in `offsets`. Notes ----- Repeated diagonal offsets are disallowed. The result from ``diags_array`` is the sparse equivalent of:: np.diag(diagonals[0], offsets[0]) + ... + np.diag(diagonals[k], offsets[k]) ``diags_array`` differs from `dia_array` in the way it handles off-diagonals. Specifically, `dia_array` assumes the data input includes padding (ignored values) at the start/end of the rows for positive/negative offset, while ``diags_array`` assumes the input data has no padding. Each value in the input `diagonals` is used. .. versionadded:: 1.11 See Also -------- dia_array : constructor for the sparse DIAgonal format. Examples -------- >>> from scipy.sparse import diags_array >>> diagonals = [[1.0, 2.0, 3.0, 4.0], [1.0, 2.0, 3.0], [1.0, 2.0]] >>> 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.0, -2.0, 1.0], 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.0, 2.0, 3.0], 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.N) stacklevelz Note: In Python 3.11, this warning can be generated by a call of scipy.sparse.diags(), but the code indicated in the warning message will refer to an internal call of scipy.sparse.diags_array(). If that happens, check your code for the use of diags().skip_file_prefixeszInput has data type z", but the output has been cast to z. In the future, the output data type will match the input. To avoid this warning, set the `dtype` parameter to `None` to have the output dtype match the input, or set it to the desired output data type.c^g|])}t|z|z td|z*Sr)minmax)rUoffsetrirjs r@ zdiags_array..sH $ $ $VQZ ( (3q&>> 9 $ $ $rAr^zOffset z (index z) out of bounds.rzDiagonal length (index : z at offset z") does not agree with array size (z, z).rS)rrZr5 atleast_1dr2r\mapabsint result_typerr^ common_typesys version_infoospathdirname__file__warningswarn FutureWarningrvzerosru enumerater)rg) diagonalsrkr8r:r^ future_dtype warn_kwargs extra_msgMdata_arrKjdiagonalrwklengtherirjs @@r@rrsxG8 y>>Q  ,y|"<"< y112IIIJJ JR]I6677 mG$$G 9~~W%%EFFF }  !  C OO 4 4 4A } * (  344~y1  g % %'+K8II 0"'//(2K2K1MNKI \ ! ! M,|,,,,,         DAq  $ $ $ $ $" $ $ $ % %A Aq AxWq)777H Aq A ++ 8 6NNQZVQ// A::IvIIqIIIJJ J &.s7F7{&;HQ!F( ] # #   8}}&&3x==A+=+= TaTT3x==TT%TTIJTTNOTTT    h(A 7 7 7 @ @ H HHs=J K7AK22K7clt||||}t||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 (repeated offsets are not allowed): - 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. If `dtype` is None, the output data type is determined by the data type of the input diagonals. Up until SciPy 1.19, the default behavior will be to return a matrix with an inexact (floating point) data type. In particular, integer input will be converted to double precision floating point. This behavior is deprecated, and in SciPy 1.19, the default behavior will be changed to return a matrix with the same data type as the input diagonals. To adopt this behavior before version 1.19, use `dtype=None`. Returns ------- new_matrix : dia_matrix `dia_matrix` holding the values in `diagonals` offset from the main diagonal as indicated in `offsets`. Notes ----- Repeated diagonal offsets are disallowed. The result from ``diags`` is the sparse equivalent of:: np.diag(diagonals[0], offsets[0]) + ... + np.diag(diagonals[k], offsets[k]) ``diags`` differs from `dia_matrix` in the way it handles off-diagonals. Specifically, `dia_matrix` assumes the data input includes padding (ignored values) at the start/end of the rows for positive/negative offset, while ``diags`` assumes the input data has no padding. Each value in the input `diagonals` is used. .. versionadded:: 0.11 See Also -------- spdiags : construct matrix from diagonals diags_array : construct sparse array instead of sparse matrix Examples -------- >>> from scipy.sparse import diags >>> diagonals = [[1.0, 2.0, 3.0, 4.0], [1.0, 2.0, 3.0], [1.0, 2.0]] >>> 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.0, -2.0, 1.0], [-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.0, 2.0, 3.0], 1).toarray() array([[ 0., 1., 0., 0.], [ 0., 0., 2., 0.], [ 0., 0., 0., 3.], [ 0., 0., 0., 0.]]) rkr8r^)rr(rg)rrkr8r:r^r<s r@r r s5D Iwe5IIIA a== ! !& ) ))rAdc(t||||S)a[Identity 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. Returns ------- new_matrix : sparse matrix A square sparse matrix with ones on the main diagonal and zeros elsewhere. See Also -------- eye_array : Sparse array of chosen shape with ones on a specified diagonal. eye : Sparse matrix of chosen shape with ones on a specified diagonal. 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') )r^r:)r)rjr^r:s r@rr#sb q!5 0 0 00rA)rr^r:c(t|||||S)aoSparse array of chosen shape with ones on the kth diagonal and zeros elsewhere. 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 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. Returns ------- new_array : sparse array Sparse array of chosen shape with ones on the kth diagonal and zeros elsewhere. 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) _eyerirjrr^r:s r@rrWsN 1a ' ''rATc J|rt}t}t}t} nt}t }t }t} ||}t|t|}}||kr|dkr|dvrqt|} tj |dz| } tj || } tj ||} ||d|}|| | | f||fS|dkrdt|} tj || }tj || }tj ||} || ||ff||fStj dtdt||z|f|} | | |g||f||S)Nr)csrcscmaxvalrryr1r)r'r%r#rr&r$r"r r~rr5rDonesrvrurg)rirjrr^r: as_sparray csr_sparse csc_sparse coo_sparse diags_sparse idx_dtypeindptrindicesrhclsrowcols r@rrs    "     y  q663q66qAAvv!q&& ^ # #'q111IYqs)444Fi333G71E***D$Z88@C3gv.A77 7 u__'q111I)AY///C)AY///C71E***D:tc3Z01a&99 9 7As1c!a%mm,,-U ; ; ;D <qc!Qu E E E N Nv V VVrAc*t|||||dS)aUSparse matrix of chosen shape with ones on the kth diagonal and zeros elsewhere. Returns a sparse matrix (m x n) where the kth diagonal is all ones and everything else is zeros. .. 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 ---------- 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. Returns ------- new_matrix : sparse matrix Sparse matrix of chosen shape with ones on the kth diagonaland zeros elsewhere. See Also -------- eye_array : Sparse array of chosen shape with ones on a specified diagonal. 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) Frrs r@rrs^ 1a . ..rAc2t|tsttrt}t}t}nt }t }t}|||dkrXjdkrLdj ztj j kr&t|dr |jdkr ||}|jdkr||d}|j dj dz|j dj dzf}|j dks j dkr|||S|jjd j dj d}|z}|||j|jf| Sn ||}|tur9|j dj dz|j dj dzf}d}nk|jjz }|dkr|j n d | z|j z} |dkrj n d |zj z} t-d t/| | D}|j dks j dkr|||S|jj }t1|jt5| fd|jD} |dkr@t7j| dgfdt;| dz Dz| z} t/| j dj D] \} } | | z} fdt/| j djD| j d<|d j jz}||t-| f| |S)a)Sparse representation of the Kronecker product of `A` and `B` Computes the Kronecker product, a composite sparse array made of blocks consisting of the second input array multiplied by each element of the first input array. Parameters ---------- A : sparse or dense array first array of the product B : sparse or dense array second array of the product format : str, optional (default: 'bsr' or 'coo') format of the result (e.g. "csr") If None, choose 'bsr' for relatively dense 2D arrays and 'coo' for others Returns ------- sparse matrix or array 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]]) Nbsrrpr3Tr.rrrOrSr0c3&K|] \}}||zV dSrR)rUabs r@rVzkron../s*EEtq!QUEEEEEErArclg|]0}tj|j1S)ry)r5asarrayrepeatnnz)rUcoBrs r@rxzkron..8s8 O O Obj9---44QU;; O O OrAc8g|]}Srr.)rU_new_cos r@rxzkron..;s!JJJqV[[]]JJJrAcvg|]5\}}|dj|z6S)rO)reshaperravel)rUrBcors r@rxzkron..CsTHHH#BB..4;;==HHHrA)r[r+r!r'r#r r&r"r3rmathprodr8hasattrrgtoarrayrhrsizerrrrIziprr7rvr5r6rYr)r<rr: bsr_sparserr output_shaperh ndim_diffA_shapeB_shaper7r B_shape_irrs ` @@r@rrsV!W Aw!7!7        1 A 6U?? ! !%49QW#5#555q&!! QVq[[ 1 A 6Q;; 14(((AGAJqwqz1171:agaj3HILuzzQUaZZ!z,//88@@@ A6==((00QWQZLLD!8D:tQY9NNN N  JqMMZ QWQZ/agaj1HI  FQVO &!^^!'')1Dqw1N&!^^!'' 1AAG1KEEs7G/D/DEEEEE uzzQUaZZz,''00888 6==  D\1B1BCCCI O O O O Oah O O OF1}}vay))JJJJE9*q.4I4IJJJJVSVQVGHH-qw77 I iHHHH'*616'((+;QX'F'FHHHFAF788 LLQU # #af , 3 3 5 5D :tU6]]+< @ @ @ I I& Q QQrAct|tst|trt}t}nt}t }||}||}|jdkrtd|jd|jdkrtd|jd|jd|jdkrtd|jd|jdkrtdt|j |j }||jd| }||jd| }t||d }t||d } || z |S) aKronecker sum of square sparse matrices `A` and `B` Kronecker sum of two sparse matrices is a sum of two Kronecker products ``kron(I_n,A) + kron(B,I_m)`` where `A` has shape ``(m, m)`` and `B` has shape ``(n, n)`` and ``I_m`` and ``I_n`` are identity matrices of shape ``(m, m)`` and ``(n, n)``, respectively. Parameters ---------- A : sparse matrix or array Square matrix B : sparse array or array Square matrix format : str format of the result (e.g. "csr") Returns ------- sparse matrix or array kronecker sum 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 -------- `kronsum` can be used to construct a finite difference discretization of the 2D Laplacian from a 1D discretization. >>> from scipy.sparse import diags_array, kronsum >>> from matplotlib import pyplot as plt >>> import numpy as np >>> ex = np.ones(10) >>> D_x = diags_array([ex, -ex[1:]], offsets=[0, -1]) # 1D first derivative >>> D_xx = D_x.T @ D_x # 1D second derivative >>> L = kronsum(D_xx, D_xx) # 2D Laplacian >>> plt.spy(L.toarray()) >>> plt.show() rpz#kronsum requires 2D inputs. `A` is zD.z#kronsum requires 2D inputs. `B` is rrzA is not squarezB is not squareryr1)r:) r[r+r#rr"rr3r2r8rr^rrg) r<rr:ridentity_sparser^I_nI_mLRs r@rrKsyP!W#Aw!7!7# # " 1 A 1 Av{{IqvIIIJJJv{{IqvIIIJJJwqzQWQZ*+++wqzQWQZ*+++ 17AG $ $E /!'!*E 2 2 2C /!'!*E 2 2 2C S!E"""A QE"""A E  F # ##rAcdkrdnd}tjd|D}|dj|}td|Dt |j|}tj|j|}tjtfd|Ddz|}|d} d} d} |D]} | j||krtd|| j || | | j jz<| | j jz } t| | | jz} | j d d || <|| xx| z cc<| | jz } | | j d z } | |d <|r2dkrt|||f| |f St|||f|| f Sdkrt|||f| |f St|||f|| f S) zh Stacking fast path for CSR/CSC matrices or arrays (i) vstack for CSR, (ii) hstack for CSC. rrcg|] }|j SrrhrUrs r@rxz,_compressed_sparse_stack..s222a16222rAcg|] }|j Srrrs r@rxz,_compressed_sparse_stack..s'A'A'AQ'A'A'ArA)arraysrryc32K|]}|jVdSrR _shape_as_2drUrr,s r@rVz+_compressed_sparse_stack..s*??1!..??????rAz!incompatible dimensions for axis NrOrS)r5 concatenaterrrvremptysumr2rslicerr&r$r'r%)blocksr,return_spmatrix other_axisrh constant_dimrrr last_indptrsum_dim sum_indicesridxss ` r@_compressed_sparse_stackrso aiiQJ >226222 3 3D!9)*5L'A'A&'A'A'A'*49l'C'CEEEIhty 222G Xc?????????!C9 U U UF)A,,KGK  $ $ >* % 5 5MMMNN N:;) K 667qy~% Wgt(<<==x}t t # 1>$''qx|# F2J= 199tWf5%,l$;=== =tWf5%17$;=== = qyy$0!(, 7999 9$0!-w 7999 9rAc t|}|dkrtd|dkr|dSdkrdndfd|D}t|dkrtdd||\}d|D}tjd|D}t fd |D}t d |D}t |t |dz | } tjfd |D| } |jdkrtj|| } tjd|D| } tj |dz| } tj | }tj |}t||| | | || || nJtj |dz| } tj d| }tj d|j }dkr"|d||| f||fS|d||| f||fS)zs Stacking fast path for CSR/CSC matrices along the minor axis (i) hstack for CSR, (ii) vstack for CSC. rzMissing block matricesrc*h|]}|jSrr)rUrrs r@ z*_stack_along_minor_axis..s BBBaq~j1BBBrAz"Mismatching dimensions along axis rzcg|] }|j Srrrs r@rxz+_stack_along_minor_axis..s,,,18,,,rAcg|] }|j Srrrs r@rxz+_stack_along_minor_axis..s666!qv666rAc32K|]}|jVdSrRrrs r@rVz*_stack_along_minor_axis..s*771!.&777777rAc3>K|]}t|jVdSrR)rZrrs r@rVz*_stack_along_minor_axis..s* - -c!)nn - - - - - -rArc*g|]}|jSrrrs r@rxz+_stack_along_minor_axis..s CCCqanT2CCCrArycg|] }|j Sr)rrs r@rxz+_stack_along_minor_axis..s%@%@%@Aai%@%@%@rArS)rZr2r5rrrrvarrayrr empty_likerrr^_csc_container_csr_container)rr,n_blocksother_axis_dimsr indptr_listdata_catrrr stack_dim_cat indptr_cat indices_catrrrhrs ` @r@_stack_along_minor_axisrs 6{{H1}}12221}}ayaiiQJBBBB6BBBO ?a.j..+..// /#ML-,V,,,K~66v66677H777777777G - -f - - - - -C C! S4I4IJJJIHCCCCFCCC9UUUM}q^KyAAA n%@%@%@%@%@ RRR ,*)<<<- ,,}X&&8\={H7D * * * *,*)<<<(1I...x000 qyyay''w(?!(, 7(99 9ay''w(?!-w 7(99 9rActj|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]]) objectryc3@K|]}t|tVdSrRr[r+rs r@rVzhstack.., 7 7a:a ! ! 7 7 7 7 7 7rATrr5ranyflat_blockrr:r^s r@rrshPZh / / /F 7 76; 7 7 777Evh...vhtDDDDrActj|d}td|jDrt d|D||St d|D||dS)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]]) rryc3@K|]}t|tVdSrRrrs r@rVzvstack..MrrAcg|]}|gSrrrs r@rxzvstack..N+++qs+++rAcg|]}|gSrrrs r@rxzvstack..PrrATr r rs r@rr#sRZh / / /F 7 76; 7 7 777R++F+++VU;;;++F+++VUDQQQQrActj|d}td|jDrt |||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`` returns a deprecated sparse matrix when none of the inputs are sparse arrays. .. warning:: This function returns a sparse matrix when no inputs are sparse arrays. 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]]) rryc3@K|]}t|tVdSrRrrs r@rVzbmat..rrATr r rs r@r r SsdrZh / / /F 7 76; 7 7 777Cffe,,,ffeTBBBBrA)r:r^c$t|||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]]) )r rs r@rrsV &&% ( ((rAc  tjdjdkrtdj\}}|dvrt djDrm|dkr1fdt|Dtjdtddd fd |}|| |d }|S|d vrt d jDrn|dkr2fdt|Dgtjdtd ddfd|}|| |d }|Stj jt}tj |tj }tj |tj } t|D]} t|D]} | | ft| | f}|| | f<d|| | f<|| d kr|jd || <nI|| |jd kr2d| d| d| d|jd d|| d } t| | | d kr|jd| | <| | |jdkr2d| d| d| d|jdd| | d } t| td|D} |d|D}|r t!|nd}tjd tj|}tjd tj| }|d|df}tj| |}t)d|Dt+|}tj| |}tj| |}d } tj|\}}t/||D]\} } | | f}t1| | |jz}|j||<tj|j|| |||tj|j|| |||| |jz } |r(t=|||ff||St|||ff||S) Nrryrpzblocks must be 2-D)Nrc3JK|]}t|o |jdkVdS)rNr*r:rs r@rVz_block..s4 C C!HQKK -AH- C C C C C CrArcFg|]}t|ddfdgS)NrrrUrrs r@rxz_block..s3SSSQ.vad|Q??@SSSrArFr.)Nrc3JK|]}t|o |jdkVdS)rNrrs r@rVz_block..s4 E EAhqkk/ah%/ E E E E E ErAcDg|]}tdd|fdS)Nrrrs r@rxz_block..s0RRRA.vaaad|Q??RRRrATzblocks[z0,:] has incompatible row dimensions. Got blocks[,z].shape[0] == z , expected .z blocks[:,z1] has incompatible column dimensions. Got blocks[z].shape[1] == c3$K|] }|jV dSrR)r)rUblocks r@rVz_block..s$ 8 8Eei 8 8 8 8 8 8rAcg|] }|j Srry)rUblks r@rxz_block..s>>>Cci>>>rArOc(g|]}|jdSrtrXrs r@rxz_block.. s I I I! I I IrAr)outr^rS) r5rr3r2r8allr rYrastyperboolint64r#rrrrbcumsumrrrvnonzerorrrrhaddrrr"rg)rr:r^rrNr< block_mask brow_lengths bcol_lengthsirrMr all_dtypes row_offsets col_offsetsr8rhrrriijjrr=s` r@r r s Zh / / /F {a-... ,CAa - C Cv{ C C CCC  q55SSSS%PQ((SSSFZh777F %VAAAqD\1o F F  U++A M ! ! E E E E E E E " q55RRRRqRRRSFZh777F %VAqqqD\1o F F  U++A&,d333J8ARX...L8ARX...L1XX**q * *Aac{&fQqSk**qs "& 1Q3?a''&'nQ&7LOO!!_q(999:Q::)*::-.::>?nQ>O::'3A:::C%S//)?a''&'nQ&7LOO!!_q(999:q::)*::-.::>?nQ>O::(4A:::C%S//)+ *.  8 8VJ%7 8 8 8 8 8C }>>6*+=>>> '1; ##t)Ary6677K)Ary6677K _k"o .E 8Cu % % %D I IfZ6H I I I'*5zz333I (3i ( ( (C (3i ( ( (C C Z # #FBB 1 1a4LCqu%%FS  quk!n#c()DDDD quk!n#c()DDDD qu L4#s,E:::CCFKKK dS#J'u 5 5 5 > >v F FFrActd|Drt}nt}g}g}g}g}d}d} |D]} t| tt jzr!ttj| } t| r| } |s@| j dj tj kr || j d| j\} } || j|z|| j| z|| jn| j\} } tjtj| | z| \} }|| |z||| z|| || z }| | z } t/|t1|| }tj||}tj||}tj|}|| f}||||ff|||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|tVdSrRr)rUrs r@rVzblock_diag..Ns, 0 0a:a ! ! 0 0 0 0 0 0rArrry)r8r^)r r#r"r[r\numbersNumberr5 atleast_2dr*r4r7r^r*rbrrrrhr8divmodrDrrrvrrg)matsr:r^ containerrrrh idx_arraysr_idxc_idxrnrowsncolsa_rowa_colr new_shapes r@r r !sDZ 0 04 0 0 000  C C DJ E E  a$/ 1 1 ,"-**++A A;; # A /!(1+"3rx"?"?!!!(1+...>LE5 JJquu} % % % JJquu} % % % KK    7LE59RYuU{%;%;UCCLE5 JJuu} % % % JJuu} % % % KK " " "   3ue3D3DEEEI .I . . .C .I . . .C >$  DI 9dS#J'y F F F O OPV W WWrA random_state{Gz?r1)densityr:r^rng data_samplerct||||||\}}tt|tfd|D}t ||f||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). Parameters ---------- shape : tuple of int 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. rng : `numpy.random.Generator`, optional Pseudorandom number generator state. When `rng` is None, a new `numpy.random.Generator` is created using entropy from the operating system. Types other than `numpy.random.Generator` are passed to `numpy.random.default_rng` to instantiate a ``Generator``. 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 `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, rng=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, ... rng=rng, data_sampler=rvs) >>> S.toarray() array([[ 36., 0., 33., 0.], # random [ 0., 0., 0., 0.], [ 0., 0., 36., 0.]]) Providing a sampler for uint values: >>> def random_uint32_to_100(size=None): ... return rng.integers(100, size=size, dtype=np.uint32) >>> S = sp.sparse.random_array((3, 4), density=0.25, rng=rng, ... data_sampler=random_uint32_to_100) Building a custom distribution. This example builds a squared normal from np.random: >>> def np_normal_squared(size=None, rng=rng): ... return rng.standard_normal(size) ** 2 >>> S = sp.sparse.random_array((3, 4), density=0.25, rng=rng, ... data_sampler=np_normal_squared) Or we can build it from sp.stats style rvs functions: >>> def sp_stats_normal_squared(size=None, rng=rng): ... std_normal = sp.stats.distributions.norm_gen().rvs ... return std_normal(size=size, random_state=rng) ** 2 >>> S = sp.sparse.random_array((3, 4), density=0.25, rng=rng, ... data_sampler=sp_stats_normal_squared) Or we can subclass sp.stats rv_continuous or rv_discrete: >>> class NormalSquared(sp.stats.rv_continuous): ... def _rvs(self, size=None, random_state=rng): ... return rng.standard_normal(size) ** 2 >>> X = NormalSquared() >>> Y = X().rvs >>> S = sp.sparse.random_array((3, 4), density=0.25, ... rng=rng, data_sampler=Y) rc3DK|]}tj|VdS)ryNr5rrUrrs r@rVzrandom_array..s2>>B 2Y///>>>>>>rArS)_randomrrvrIr#rg) r8rJr:r^rKrLrhindrs @r@rrusBwsLIIID# s5zz222I >>>>#>>> > >C dC[ . . . 7 7 ? ??rAc Z|dks|dkrtdtj|}tt ||z}t |Rt jt jrfd}n,t jt j rfd}nj }tt||t j t jj krK||d}t j||d } t#fd | D} nt%|} t'} t%| |kr_|t%| z } | t+t"t-|| | f t%| |k_t#t jt1|  j} || d} | | fS)Nrrz(density expected to be 0 <= density <= 1cttjjtjj|S)Nry)rr5iinforurv)rr^rKs r@rLz_random..data_samplers>#C$&HUOO$7$&HUOO$7$(*/ 1111rAcd||dzzS)Nry?)uniform)rrKs r@rLz_random..data_samplers4  ..  ..345rArF)rreplaceF)r8orderc3BK|]}tj|VdSrRrOrPs r@rVz_random..s/<<"BJr9--<<<<<>> import scipy as sp >>> import numpy as np >>> rng = np.random.default_rng() >>> S = sp.sparse.random(3, 4, density=0.25, rng=rng) Providing a sampler for the values: >>> rvs = sp.stats.poisson(25, loc=10).rvs >>> S = sp.sparse.random(3, 4, density=0.25, rng=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, rng=rng): ... return rng.standard_normal(size) ** 2 >>> S = sp.sparse.random(3, 4, density=0.25, rng=rng, ... data_rvs=np_normal_squared) Or we can build it from sp.stats style rvs functions: >>> def sp_stats_normal_squared(size=None, rng=rng): ... std_normal = sp.stats.distributions.norm_gen().rvs ... return std_normal(size=size, random_state=rng) ** 2 >>> S = sp.sparse.random(3, 4, density=0.25, rng=rng, ... data_rvs=sp_stats_normal_squared) Or we can subclass sp.stats rv_continuous or rv_discrete: >>> class NormalSquared(sp.stats.rv_continuous): ... def _rvs(self, size=None, random_state=rng): ... return rng.standard_normal(size) ** 2 >>> X = NormalSquared() >>> Y = X() # get a frozen version of the distribution >>> S = sp.sparse.random(3, 4, density=0.25, rng=rng, data_rvs=Y.rvs) Nc|SrRr)rdata_rvss r@ data_rvs_kwzrandom..data_rvs_kwos8D>> !rArS)r~rQr"rg) rirjrJr:r^rKrlrmrgrRs ` r@r r sz y  q663q66qA " " " " " " A[IIID# tSk!Q 0 0 0 9 9& A AArAc*t||||||S)aGenerate 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. rng : `numpy.random.Generator`, optional Pseudorandom number generator state. When `rng` is None, a new `numpy.random.Generator` is created using entropy from the operating system. Types other than `numpy.random.Generator` are passed to `numpy.random.default_rng` to instantiate a ``Generator``. 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", rng=42) >>> matrix >>> matrix.toarray() array([[0.05641158, 0. , 0. , 0.65088847], # random [0. , 0. , 0. , 0.14286682], [0. , 0. , 0. , 0. ]]) )r )rirjrJr:r^rKs r@r r wsl !Q 4 44rA)NF)NNN)rNrR)T)NN)F)rINNNN)rIr1NNN)rIr1NN)B__doc__ __docformat____all__r:rrrrnumpyr5scipy._lib._utilrrrscipy._lib.deprecationr_sputilsrrrr _sparsetoolsr_bsrr r!_coor"r#_cscr$r%_csrr&r'_diar(r)_baser*r+rrrrrr rfloatrrrrrrrrrr rr r rrQr r rrAr@r~s[&  6 6 6  QQQQQQQQQQ++++++FFFFFFFFFFFF$$$$$$''''''''''''''''''''''''''''''''''''''''$$$$$$$$ 22222j+1+1+1\I I I I X?D?D?D?DD*+$t8iIiIiIiIiIXd4xc*c*c*c*L11111111h'(auT'('('('('(T"W"W"W"WJQeD////////dpRpRpRpRfC$C$C$C$L(9(9(9V595959p,E,E,E,E^-R-R-R-R`=C=C=C=C@#'d+)+)+)+)+)\]G]G]G]G@QXQXQXQXhN###'Te@e@e@e@$#e@P59#',,,,^N33337"fBfBfB43fBRN33355555543555555rA