a CCCfu@sdZdZgdZddlmZddlZddlmZddl m Z dd l m Z m Z dd lmZdd lmZmZmZmZdd lmZmZmZmZmZmZdd lmZddlmZmZm Z m!Z!m"Z"m#Z#m$Z$Gdddee Z%ddZ&Gddde%eZ'Gddde e%Z(dS)z"Compressed Block Sparse Row formatzrestructuredtext en) bsr_array bsr_matrixisspmatrix_bsr)warnN)copy_if_needed)spmatrix) _data_matrix _minmax_mixin) _cs_matrix)issparse_formats_spbasesparray)isshapegetdtypegetdata to_nativeupcast check_shape) _sparsetools) bsr_matvec bsr_matvecscsr_matmat_maxnnz bsr_matmat bsr_transposebsr_sort_indices bsr_tocsrc@s.eZdZdZd7ddZd8ddZeed d d Zd9d d Z e j j e _ ddZ d:ddZ e j j e _ ddZddZddZddZddZddZd;dd Zdd%d&Zd?d'd(Ze jj e_ d@d)d*Ze jj e_ d+d,Zd-d.Zd/d0Zd1d2ZdAd3d4ZdBd5d6ZdS)C _bsr_basebsrNFc Cst|t|r`|j|jkr,|r,|}n |j|d}|j|j|j|j f\|_|_|_|_ nt |t rt |r@t ||_ |j\}}|durd}nt |std|t |}td|t|td|_|\}} ||dks|| dkrtd|jt|||| || d} tjd| d |_tj||d | d |_q.t|d kr|j|||d } | j|d} | j| j| j| j f\|_|_|_|_ q.t|d kr|\} }}d }|durt|}|durt|t|}|j||f|dd} |st}tj||| d|_tj||| d|_t| ||d|_|jjd krJtd|jj|durt |sltd|t ||jjd dkrtd||jjd dntdnzt|}Wn6ty}ztd|j|WYd}~n d}~00|j||d j|d}|j|j|j|j f\|_|_|_|_ |durDt ||_ n~|jdurz t|jd }|jd }Wn0ty}ztd|WYd}~n*d}~00|j\}} t |||| f|_ |jdur|durtdn t ||_ |dur|jj|dd|_|j dddS)N blocksize)rrzinvalid blocksize=%s)r)defaultrz#shape must be multiple of blocksizemaxvaldtyper)r&shapeT)r$Zcheck_contents)copyr&z*BSR data must be 3-dimensional, got shape=zinvalid blocksize=zmismatching blocksize={} vs {}z(unrecognized bsr_array constructor usagez+unrecognized form for %s_matrix constructorz!unable to infer matrix dimensionszneed to infer shapeFr*) full_check)!r __init__r formatr*tobsrindptrindicesdata_shape isinstancetuplerrr( ValueErrornpzerosrfloat_get_index_dtypemaxlen_coo_containerrarrayrndimasarray Exceptionr!astype check_format)selfZarg1r(r&r*r!MNRC idx_dtypeZcoorr2r1r0r$erKM/var/www/html/django/DPS/env/lib/python3.9/site-packages/scipy/sparse/_bsr.pyr-s                           z_bsr_base.__init__TcCs|j\}}|j\}}|jjjdkr= 0z8index pointer values must form a non-decreasing sequencer%N)r(r!r0r&kindrnamer1r?r6r2r<prunennzr;minr7diffr:r@r)rDr,rErFrGrHrIrKrKrLrCsN    z_bsr_base.check_format)returncCs|jjddS)zBlock size of the matrix.rN)r2r()rDrKrKrLr!sz_bsr_base.blocksizecCs0|durtd|j\}}t|jd||S)Nz6_getnnz over an axis is not implemented for BSR formatrP)NotImplementedErrorr!intr0)rDaxisrGrHrKrKrL_getnnzs z_bsr_base._getnnzc Cs|t|j\}}t|trdnd}ddd|jD}ddd|jD}d|d|d |jjd |j d |d |d S)Nr>matrixxcss|]}t|VqdSNstr.0r]rKrKrL z%_bsr_base.__repr__..css|]}t|VqdSr^r_rarKrKrLrcrd) r r.r4rjoinr(r!r&typerT)rD_fmtZ sparse_clsZ shape_strZblkszrKrKrL__repr__sz_bsr_base.__repr__rc Cs|j\}}|| ks||kr.tjd|jjdS|j\}}tjt|t|d|t|dt |jd}t ||||||||j |j t|j| |SNrr%)r(r7emptyr2r&r!r8rUr;rrZ bsr_diagonalr0r1ravel)rDkrowscolsrGrHyrKrKrLdiagonals    z_bsr_base.diagonalcCstdSr^rX)rDkeyrKrKrL __getitem__sz_bsr_base.__getitem__cCstdSr^rs)rDrtvalrKrKrL __setitem__sz_bsr_base.__setitem__cCs|jdd|SNFr+)tocoo _add_dense)rDotherrKrKrLrzsz_bsr_base._add_densec Cs`|j\}}|j\}}tj|jdt|j|jd}t|||||||j|j|j || |Srk) r(r!r7r8rr&rr0r1r2rm)rDr{rErFrGrHresultrKrKrL_matmul_vectors  z_bsr_base._matmul_vectorc Csr|j\}}|j\}}|jd}tj||ft|j|jd}t||||||||j|j|j | | |S)Nrr%) r!r(r7r8rr&rr0r1r2rm)rDr{rGrHrErFZn_vecsr|rKrKrL_matmul_multivectors    z_bsr_base._matmul_multivectorcCs|j\}}|j\}}|j\}}|jdkr4|jd}nd}|jdkr^|dkr^|j||fdd}n|j||fd}||j|j|j|jf} t|||||j| |j| |j| |j| } |j|j|j|j|jf| d} t j |jj| d} t j | | d} t j ||| t |j |j d} t | ||||||||j| |j| t |j|j| |j| t |j| | | | d ||} |j| | | f||f||fd S) NrrZcsrF)r!r*r r#r%rP)r(r!)r(r!r.r/r:r0r1rrBr7rlrr&rrmr2reshape_bsr_container)rDr{rEZK1ZK2rFrGnrHrIbnnzr0r1r2rKrKrL_matmul_sparsesR                   z_bsr_base._matmul_sparsecCs2|d|jfvr|j|dS|r*|S|SdS)a=Convert this array/matrix into Block Sparse Row Format. With copy=False, the data/indices may be shared between this array/matrix and the resultant bsr_array/bsr_matrix. If blocksize=(R, C) is provided, it will be used for determining block size of the bsr_array/bsr_matrix. Nr )r!tocsrr/r*)rDr!r*rKrKrLr/Vs z_bsr_base.tobsrc Cs|j\}}|j\}}|j}|j|j|jft||d}tj|d|d}tj||d} tj|t |j d} t |||||||jj |dd|jj |dd|j || | |j| | |f|jdS)Nr#rr%Fr+r()r(r!rTr:r0r1r;r7rlrr&rrBr2Z_csr_container) rDr*rErFrGrHrTrIr0r1r2rKrKrLrfs(   z_bsr_base.tocsrcCs|jddj|dSrx)rtocsc)rDr*rKrKrLr}sz_bsr_base.tocscc CsT|j\}}|j\}}t|j}|jjttjjkr\|tj}t ||krXt d|}|j t ||d}|tj |||d|} | ||d||} | ttj ||dddd|f7} | d} ||jj|dd||d||} | ttj ||d|df7} | d} |jd} |r<| } |j| | | ff|jdS) zConvert this array/matrix to COOrdinate format. When copy=False the data array will be shared between this array/matrix and the resultant coo_array/coo_matrix. zMatrix too big to convertr#r%rPrFr+r)r(r!r7rVr0r&itemsizeZintprBanyr6r:r;ZarangerepeatrZtiler1r2r*r=) rDr*rErFrGrHZ indptr_diffZindptr_diff_limitedrIrowcolr2rKrKrLrys4    &   z_bsr_base.tocoocCs|jddj||dS)NFr+)orderout)rytoarray)rDrrrKrKrLrsz_bsr_base.toarrayc Cs|dur|dkrtd|j\}}|j\}}|j||}|jdkr`|j||f||f|j|dStj||d|jjd}tj||j jd} tj|||f|j jd} t |||||||j|j |j || | |j| | |f||f|dS)N)rrzoSparse matrices do not support an 'axes' parameter because swapping dimensions is the only logical permutation.r)r!r&r*rr%)r(r*) r6r!r(rTrr&r7rlr0r1r2rrm) rDZaxesr*rGrHrErFZNBLKr0r1r2rKrKrL transposes&     z_bsr_base.transposecCs|js dS|j\}}|j\}}|jdkd||jdd}|d}|j||jdt|<t |||||j |j || dS)zRemove zero elements in-place.NrrPr)rZ) rTr!r(r2rsumZnonzeror<rZcsr_eliminate_zerosr0r1rS)rDrGrHrErFmaskZnonzero_blocksrKrKrLeliminate_zeross   z_bsr_base.eliminate_zerosc Cs|jr dS||j\}}|j\}}||}d}d}t|D]}|} |j|d}| |kr|j| } |j| } | d7} | |kr|j| | kr| |j| 7} | d7} qx| |j|<| |j|<|d7}qT||j|d<q>|d|_dS)zqEliminate duplicate array/matrix entries by adding them together The is an *in place* operation NrrT) Zhas_canonical_format sort_indicesr!r(ranger0r1r2rS) rDrGrHrErFZn_rowrTZrow_endrMZjjjr]rKrKrLsum_duplicatess0         z_bsr_base.sum_duplicatesc CsN|jr dS|j\}}|j\}}t|||||||j|j|jd|_dS)z9Sort the indices of this array/matrix *in place* NT)Zhas_sorted_indicesr!r(rr0r1r2rm)rDrGrHrErFrKrKrLrs   &z_bsr_base.sort_indicescCs|j\}}|j\}}t|j||dkr2td|jd}t|j|krRtdt|j|krhtd|jd||_|jd||_dS)z8Remove empty space after all non-zero elements. rz index pointer has invalid lengthrPz"indices array has too few elementszdata array has too few elementsN)r!r(r<r0r6r1r2)rDrGrHrErFrrKrKrLrSs   z_bsr_base.prunecCs|j||jd}tt|j||j}|j\}}t|jt|j}|j|j|j |j|j f|d} t j |jj | d} t j || d} gd} || vrt j |||t j d} n t j |||t|j|jd} ||j d||j d||||j| |j | |j|j| |j | t |j| | | | d}| d|} | d|||} ||d krp| } | } | d||} |j| | | f|j d S) z5Apply the binary operation fn to two sparse matrices.r r#r%)Z_ne_Z_lt_Z_gt_Z_le_Z_ge_rrrPNr'r) __class__r!getattrrr.r<r2r:r0r1r7rlr(Zbool_rr&rBrmr*r)rDr{opZin_shapeZ out_shapefnrGrHZmax_bnnzrIr0r1Zbool_opsr2Z actual_bnnzrKrKrL_binopt#sD          z_bsr_base._binoptcCsL|r*|j||j|jf|j|jdS|j||j|jf|j|jdSdS)zReturns a matrix with the same sparsity structure as self, but with different data. By default the structure arrays (i.e. .indptr and .indices) are copied. )r(r&N)rr1r*r0r(r&)rDr2r*rKrKrL _with_dataTsz_bsr_base._with_data)NNFN)T)N)r)NF)F)F)T)NN)NF)NN)T) __name__ __module__ __qualname___formatr-rCpropertyr5r!r[r__doc__rjrrrurwrzr}r~rr/rrryrrrrrrSrrrKrKrKrLrs@ r A     8      &    !  1rcCs t|tS)aIs `x` of a bsr_matrix type? Parameters ---------- x object to check for being a bsr matrix Returns ------- bool True if `x` is a bsr matrix, False otherwise Examples -------- >>> from scipy.sparse import bsr_array, bsr_matrix, csr_matrix, isspmatrix_bsr >>> isspmatrix_bsr(bsr_matrix([[5]])) True >>> isspmatrix_bsr(bsr_array([[5]])) False >>> isspmatrix_bsr(csr_matrix([[5]])) False )r4r)r]rKrKrLrhsrc@seZdZdZdS)ra Block Sparse Row format sparse array. This can be instantiated in several ways: bsr_array(D, [blocksize=(R,C)]) where D is a 2-D ndarray. bsr_array(S, [blocksize=(R,C)]) with another sparse array or matrix S (equivalent to S.tobsr()) bsr_array((M, N), [blocksize=(R,C), dtype]) to construct an empty sparse array with shape (M, N) dtype is optional, defaulting to dtype='d'. bsr_array((data, ij), [blocksize=(R,C), shape=(M, N)]) where ``data`` and ``ij`` satisfy ``a[ij[0, k], ij[1, k]] = data[k]`` bsr_array((data, indices, indptr), [shape=(M, N)]) is the standard BSR representation where the block column indices for row i are stored in ``indices[indptr[i]:indptr[i+1]]`` and their corresponding block values are stored in ``data[ indptr[i]: indptr[i+1] ]``. If the shape parameter is not supplied, the array dimensions are inferred from the index arrays. Attributes ---------- dtype : dtype Data type of the array shape : 2-tuple Shape of the array ndim : int Number of dimensions (this is always 2) nnz size data BSR format data array of the array indices BSR format index array of the array indptr BSR format index pointer array of the array blocksize Block size has_sorted_indices : bool Whether indices are sorted has_canonical_format : bool T Notes ----- Sparse arrays can be used in arithmetic operations: they support addition, subtraction, multiplication, division, and matrix power. **Summary of BSR format** The Block Sparse Row (BSR) format is very similar to the Compressed Sparse Row (CSR) format. BSR is appropriate for sparse matrices with dense sub matrices like the last example below. Such sparse block matrices often arise in vector-valued finite element discretizations. In such cases, BSR is considerably more efficient than CSR and CSC for many sparse arithmetic operations. **Blocksize** The blocksize (R,C) must evenly divide the shape of the sparse array (M,N). That is, R and C must satisfy the relationship ``M % R = 0`` and ``N % C = 0``. If no blocksize is specified, a simple heuristic is applied to determine an appropriate blocksize. **Canonical Format** In canonical format, there are no duplicate blocks and indices are sorted per row. Examples -------- >>> import numpy as np >>> from scipy.sparse import bsr_array >>> bsr_array((3, 4), dtype=np.int8).toarray() array([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=int8) >>> row = np.array([0, 0, 1, 2, 2, 2]) >>> col = np.array([0, 2, 2, 0, 1, 2]) >>> data = np.array([1, 2, 3 ,4, 5, 6]) >>> bsr_array((data, (row, col)), shape=(3, 3)).toarray() array([[1, 0, 2], [0, 0, 3], [4, 5, 6]]) >>> indptr = np.array([0, 2, 3, 6]) >>> indices = np.array([0, 2, 2, 0, 1, 2]) >>> data = np.array([1, 2, 3, 4, 5, 6]).repeat(4).reshape(6, 2, 2) >>> bsr_array((data,indices,indptr), shape=(6, 6)).toarray() array([[1, 1, 0, 0, 2, 2], [1, 1, 0, 0, 2, 2], [0, 0, 0, 0, 3, 3], [0, 0, 0, 0, 3, 3], [4, 4, 5, 5, 6, 6], [4, 4, 5, 5, 6, 6]]) NrrrrrKrKrKrLrsrc@seZdZdZdS)ra Block Sparse Row format sparse matrix. This can be instantiated in several ways: bsr_matrix(D, [blocksize=(R,C)]) where D is a 2-D ndarray. bsr_matrix(S, [blocksize=(R,C)]) with another sparse array or matrix S (equivalent to S.tobsr()) bsr_matrix((M, N), [blocksize=(R,C), dtype]) to construct an empty sparse matrix with shape (M, N) dtype is optional, defaulting to dtype='d'. bsr_matrix((data, ij), [blocksize=(R,C), shape=(M, N)]) where ``data`` and ``ij`` satisfy ``a[ij[0, k], ij[1, k]] = data[k]`` bsr_matrix((data, indices, indptr), [shape=(M, N)]) is the standard BSR representation where the block column indices for row i are stored in ``indices[indptr[i]:indptr[i+1]]`` and their corresponding block values are stored in ``data[ indptr[i]: indptr[i+1] ]``. If the shape parameter is not supplied, the matrix dimensions are inferred from the index arrays. Attributes ---------- dtype : dtype Data type of the matrix shape : 2-tuple Shape of the matrix ndim : int Number of dimensions (this is always 2) nnz size data BSR format data array of the matrix indices BSR format index array of the matrix indptr BSR format index pointer array of the matrix blocksize Block size has_sorted_indices : bool Whether indices are sorted has_canonical_format : bool T Notes ----- Sparse matrices can be used in arithmetic operations: they support addition, subtraction, multiplication, division, and matrix power. **Summary of BSR format** The Block Sparse Row (BSR) format is very similar to the Compressed Sparse Row (CSR) format. BSR is appropriate for sparse matrices with dense sub matrices like the last example below. Such sparse block matrices often arise in vector-valued finite element discretizations. In such cases, BSR is considerably more efficient than CSR and CSC for many sparse arithmetic operations. **Blocksize** The blocksize (R,C) must evenly divide the shape of the sparse matrix (M,N). That is, R and C must satisfy the relationship ``M % R = 0`` and ``N % C = 0``. If no blocksize is specified, a simple heuristic is applied to determine an appropriate blocksize. **Canonical Format** In canonical format, there are no duplicate blocks and indices are sorted per row. Examples -------- >>> import numpy as np >>> from scipy.sparse import bsr_matrix >>> bsr_matrix((3, 4), dtype=np.int8).toarray() array([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=int8) >>> row = np.array([0, 0, 1, 2, 2, 2]) >>> col = np.array([0, 2, 2, 0, 1, 2]) >>> data = np.array([1, 2, 3 ,4, 5, 6]) >>> bsr_matrix((data, (row, col)), shape=(3, 3)).toarray() array([[1, 0, 2], [0, 0, 3], [4, 5, 6]]) >>> indptr = np.array([0, 2, 3, 6]) >>> indices = np.array([0, 2, 2, 0, 1, 2]) >>> data = np.array([1, 2, 3, 4, 5, 6]).repeat(4).reshape(6, 2, 2) >>> bsr_matrix((data,indices,indptr), shape=(6, 6)).toarray() array([[1, 1, 0, 0, 2, 2], [1, 1, 0, 0, 2, 2], [0, 0, 0, 0, 3, 3], [0, 0, 0, 0, 3, 3], [4, 4, 5, 5, 6, 6], [4, 4, 5, 5, 6, 6]]) NrrKrKrKrLrsr))r __docformat____all__warningsrnumpyr7Zscipy._lib._utilrZ_matrixr_datar r Z _compressedr _baser r rrZ_sputilsrrrrrrrrrrrrrrrrrrrKrKrKrLs(      $Tk