403Webshell
Server IP : 217.160.0.135  /  Your IP : 216.73.217.85
Web Server : Apache
System : Linux www 6.18.52-i1-ampere #1203 SMP Mon Sep 14 18:29:59 CEST 2026 aarch64
User : sws1074145052 ( 1074145052)
PHP Version : 8.3.32
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : OFF  |  Pkexec : OFF
Directory :  /lib/python3/dist-packages/scipy/sparse/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /lib/python3/dist-packages/scipy/sparse/__pycache__/_bsr.cpython-311.pyc
�

d�c�b����dZdZddgZddlmZddlZddlmZm	Z	dd	l
mZdd
lm
Z
mZmZddlmZmZmZmZmZmZmZddlmZdd
lmZmZmZmZmZmZm Z Gd�dee	��Z!d�Z"dS)z)Compressed Block Sparse Row matrix formatzrestructuredtext en�
bsr_matrix�isspmatrix_bsr�)�warnN�)�_data_matrix�
_minmax_mixin)�
_cs_matrix)�
isspmatrix�_formats�spmatrix)�isshape�getdtype�getdata�	to_native�upcast�get_index_dtype�check_shape)�_sparsetools)�
bsr_matvec�bsr_matvecs�csr_matmat_maxnnz�
bsr_matmat�
bsr_transpose�bsr_sort_indices�	bsr_tocsrc��eZdZdZdZd d�Zd!d�Zd�Zee�	��Z	d"d
�Z
ej
je
_d�Zd#d
�Z
ej
je
_d�Zd�Zd�Zd�Zd�Zd�Zd$d�Zd%d�Zejje_d%d�Zejje_d!d�Zd&d�Zejje_d$d�Zejje_d�Zd�Zd�Zd�Zd&d�Zd!d�ZdS)'ra�Block Sparse Row matrix

    This can be instantiated in several ways:
        bsr_matrix(D, [blocksize=(R,C)])
            where D is a dense matrix or 2-D ndarray.

        bsr_matrix(S, [blocksize=(R,C)])
            with another sparse matrix S (equivalent to S.tobsr())

        bsr_matrix((M, N), [blocksize=(R,C), dtype])
            to construct an empty 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
        Number of stored values, including explicit zeros
    data
        Data array of the matrix
    indices
        BSR format index array
    indptr
        BSR format index pointer array
    blocksize
        Block size of the matrix
    has_sorted_indices
        Whether indices are sorted

    Notes
    -----
    Sparse matrices can be used in arithmetic operations: they support
    addition, subtraction, multiplication, division, and matrix power.

    **Summary of BSR format**

    The Block Compressed 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.  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 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.

    Examples
    --------
    >>> from scipy.sparse import bsr_matrix
    >>> import numpy as np
    >>> 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]])

    �bsrNFc�	�tj|��t|��rSt|��r|r|���}n|�|���}|�|���nbt|t���r�t|���rt|��|_|j\}}|�d}n0t|��std|z���t|��}tjd|zt!|t"�����|_|\}}	||zdks	||	zdkrtd���t't)||z||	z||	�����}
tjd|
�	��|_tj||zd
z|
�	��|_�n.t/|��dkrA|�|�|||����|������n�t/|��d
k�r7|\}}}
d
}|�t)|��}|�t)|t)|����}t'||
f|d���}
tj|||
���|_tj|
||
���|_t5|||���|_|jjd
krtd|jj�����|�mt|��std|�����t|��|jjd
d�kr'td|�d|jjd
d������n�td���	tj|��}n*#t:$r}td|jz��|�d}~wwxYw|�||�	���|���}|�|��|�t|��|_n�|j�}	t/|j��d
z
}|j���d
z}|j\}}	t||z||	zf��|_n"#t:$r}td��|�d}~wwxYw|j�%|�td���t|��|_|�!|j� |d���|_|�!d���dS)N��	blocksize)rrzinvalid blocksize=%s�r)�defaultrz#shape must be multiple of blocksize��maxval��dtyper�)r&�shape�T)r$�check_contents)�copyr&z*BSR data must be 3-dimensional, got shape=zinvalid blocksize=zmismatching blocksize=z vs z)unrecognized bsr_matrix constructor usagez+unrecognized form for %s_matrix constructorz!unable to infer matrix dimensionszneed to infer shapeF�r+)�
full_check)"r�__init__r
rr+�tobsr�	_set_self�
isinstance�tupler
r�_shaper(�
ValueError�np�zerosr�float�datar�max�indices�indptr�len�_coo_container�arrayr�ndim�asarray�	Exception�formatr �astype�check_format)�self�arg1r(r&r+r �M�N�R�C�	idx_dtyper8r:r;r$�es                �3/usr/lib/python3/dist-packages/scipy/sparse/_bsr.pyr.zbsr_matrix.__init__ys<����d�#�#�#��d���M	!��d�#�#�
7��
7��y�y�{�{����z�z�I�z�6�6���N�N�4� � � � �
��U�
#�
#�F	!��t�}�}�:
N�)�$�/�/����j���!��$� %�I�I�"�9�-�-�M�(�)?�)�)K�L�L�L� %�i� 0� 0�I��H�T�I�%5�x��u�7U�7U�7U�V�V��	����!���E�a�<�<�A��E�a�<�<�$�%J�K�K�K�,�3�q�!�t�Q��T�1�a�3H�3H�I�I�I�	�!�x���;�;�;��� �h�q�!�t�a�x�y�A�A�A�����T���a�������'�'��E��'�G�G�M�M�"+�N��������T���a���*.�'��w�����$� ��Z�Z�F��(� ���Y���8�8�F�+�W�f�,=�f�;?�A�A�A�	�!�x��d�)�L�L�L��� �h�v�D�	�J�J�J���#�D�t�5�A�A�A��	��9�>�Q�&�&�$�*� �I�O�O�.�/�/�/��(�"�9�-�-�P�(�j�9�9�)N�O�O�O��Y�'�'�4�9�?�1�2�2�+>�>�>�(�j�%�I�I�t�y��q�r�r�':�':�*<�=�=�=��!�!L�M�M�M�
G��z�$�'�'�����
G�
G�
G� �"1�37�;�"?�@�@�EF�G�����
G�����&�&��E�'����e�i�e�(�(�
�
�N�N�4� � � ���%�e�,�,�D�K�K��z�!�9��D�K�(�(�1�,�A���(�(�*�*�Q�.�A��.�C�A�a�"-�q��s�1�Q�3�i�"8�"8�D�K�K��	!�Q�Q�Q�$�%H�I�I�q�P�����Q�����:���}� �!6�7�7�7�)�%�0�0������	�(�(��U�(�;�;�D�I����U��+�+�+�+�+s0�M/�/
N�9N�N�83Q�
Q1�Q,�,Q1Tc���|j\}}|j\}}|jjjdkr!td|jjjz��|jjjdkr!td|jjjz��t|j|jf��}tj
|j|���|_tj
|j|���|_t|j��|_|jj
dks|jj
dkrtd���|jj
dkrtd���t|j��||zdzkr,td	t|j��||zdzfz���|jd
d
krtd���t|j��t|j��krtd���|jd
t|j��krtd���|���|r�|jd
kr�|j���||zkr.td||z|j���fz���|j���d
krtd���tj|j�����d
krtd���dSdSdS)z�check whether the matrix format is valid

            *Parameters*:
                full_check:
                    True  - rigorous check, O(N) operations : default
                    False - basic check, O(1) operations

        �iz'indptr array has non-integer dtype (%s)z(indices array has non-integer dtype (%s)r%rz!indices, and indptr should be 1-Dr)zdata should be 3-Dz&index pointer size (%d) should be (%d)rz!index pointer should start with 0z*indices and data should have the same size���zQLast value of index pointer should be less than the size of index and data arraysz-column index values must be < %d (now max %d)z column index values must be >= 0z8index pointer values must form a non-decreasing sequenceN)r(r r;r&�kindr�namer:rr5r@rr8r?r4r<�prune�nnzr9�min�diff)rEr-rGrHrIrJrKs       rMrDzbsr_matrix.check_format�s����j���!��n���!��;��!�S�(�(��:��k�'�,�-�
.�
.�
.��<��"�c�)�)��;��l�(�-�.�
/�
/�
/�$�T�\�4�;�$?�@�@�	��j���I�>�>�>����z�$�,�i�@�@�@����d�i�(�(��	��<���!�!�T�[�%5��%:�%:��@�A�A�A��9�>�Q����1�2�2�2�
������1��q��(�(��E�!$�T�[�!1�!1�1�a�4�!�8� <�=�>�>�
>��K��N�a����@�A�A�A�
������T�Y���/�/��I�J�J�J��K��O�c�$�,�/�/�/�/��D�E�E�
E�	
�
�
�����		C��x�!�|�|��<�#�#�%�%��A��-�-�$�%T�XY�[\�X\�^b�^j�^n�^n�^p�^p�Wq�%q�r�r�r��<�#�#�%�%��)�)�$�%G�H�H�H��7�4�;�'�'�+�+�-�-��1�1�$�&B�C�C�C�		C�		C��|�
2�1�c�*�|jjdd�S)Nr)r8r()rEs rM�_get_blocksizezbsr_matrix._get_blocksize#s���y��q�r�r�"�"rW)�fgetc�x�|�td���|j\}}t|jd|z|z��S)Nz5getnnz over an axis is not implemented for BSR formatrP)�NotImplementedErrorr �intr;)rE�axisrIrJs    rM�getnnzzbsr_matrix.getnnz'sH����%�'7�8�8�
8��n���!��4�;�r�?�Q�&��*�+�+�+rWc��t|���d}d|j|jj|jfz|jz|fzzS)Nrz\<%dx%d sparse matrix of type '%s'
	with %d stored elements (blocksize = %dx%d) in %s format>)r�	getformatr(r&�typerTr )rErBs  rM�__repr__zbsr_matrix.__repr__0sQ���$�.�.�*�*�+�A�.��N���t�z����9�9�D�N�J�����	rWrc��|j\}}||ks||kr tjd|jj���S|j\}}tjt|t|d��z|t|d��z
��t|j�����}tj|||z||z|||j|j
tj|j��|�	�	|S�Nrr%)r(r5�emptyr8r&r r6rUr9rr�bsr_diagonalr;r:�ravel)rE�k�rows�colsrIrJ�ys       rM�diagonalzbsr_matrix.diagonal7s����Z�
��d����:�:��d����8�A�T�Y�_�5�5�5�5��~���1��H�S���A�q�	�	�)�4�#�a��)�)�+;�<�<�!�$�*�-�-�
/�
/�
/���!�!�T�Q�Y���	�1�a�"&�+�t�|�"$�(�4�9�"5�"5�q�	:�	:�	:��rWc��t��N�r\)rE�keys  rM�__getitem__zbsr_matrix.__getitem__I���!�!rWc��t�rorp)rErq�vals   rM�__setitem__zbsr_matrix.__setitem__LrsrWc�T�|�d����|��S�NFr,)�tocoo�
_add_dense)rE�others  rMrzzbsr_matrix._add_denseSs$���z�z�u�z�%�%�0�0��7�7�7rWc��|j\}}|j\}}tj|jdt	|j|j�����}t
||z||z|||j|j|j	�
��||�	�	|Sre)r(r r5r6rr&rr;r:r8rh)rEr{rGrHrIrJ�results       rM�_mul_vectorzbsr_matrix._mul_vectorVs����j���!��n���!���$�*�Q�-�v�d�j�%�+�/N�/N�O�O�O���1�a�4��A��q�!��K���t�y���'8�'8��6�	�	�	��
rWc
�n�|j\}}|j\}}|jd}tj||ft	|j|j�����}t
||z||z||||j|j|j	�
��|�
��|�
���
�
|S)Nrr%)r r(r5r6rr&rr;r:r8rh)rEr{rIrJrGrH�n_vecsr}s        rM�_mul_multivectorzbsr_matrix._mul_multivectorbs����n���!��j���!���Q�����1�V�*�F�4�:�e�k�,J�,J�K�K�K���A�q�D�!�Q�$���1���T�\�4�9�?�?�+<�+<����
�
�v�|�|�~�~�	/�	/�	/��
rWc�D�|j\}}|j\}}|j\}}t|��r|jd}nd}ddlm}	|	|��r |dkr|�||fd���}n|�||f���}t
|j|j|j|jf��}
t||z||z|j�
|
��|j�
|
��|j�
|
��|j�
|
����}t
|j|j|j|jf|���}
tj|jj|
���}tj||
���}
tj||z|zt|j|j�����}t|||z||z||||j�
|
��|j�
|
��tj|j��|j�
|
��|j�
|
��tj|j��||
|��|�d||��}|�||
|f||f||f�	��S)
Nr)�isspmatrix_csrF)r r+rr#r%rP)r(r )r(r r�_csrr�r/rr;r:rrCr5rfrr&rrhr8�reshape�_bsr_container)rEr{rG�K1�K2rHrI�nrJr�rK�bnnzr;r:r8s               rM�_mul_sparse_matrixzbsr_matrix._mul_sparse_matrixos����
���2�����A��n���!��%� � �	����"�A�A��A�(�(�(�(�(�(��>�%� � �	1�Q�!�V�V��K�K�1�Q�%�e�K�<�<�E�E��K�K�1�Q�%�K�0�0�E�#�T�[�$�,�%*�\�5�=�%B�C�C�	�!��A��q�!�t�!%��!3�!3�I�!>�!>�!%��!4�!4�Y�!?�!?�!&��!4�!4�Y�!?�!?�!&��!5�!5�i�!@�!@�	B�B��$�T�[�$�,�%*�\�5�=�%B�+/�1�1�1�	���$�+�+�9�=�=�=���(�4�y�1�1�1���x��!��D���t�z�%�+�(F�(F�G�G�G���4��A��q�!�t�Q��1��;�%�%�i�0�0��<�&�&�y�1�1��8�D�I�&�&��<�&�&�y�1�1��=�'�'�	�2�2��8�E�J�'�'����		�		�		��|�|�B�q��#�#���"�"�
�7�F�#�A�q�6�a��V�#�
�
�	
rWc��|d|jfvr(|����|���S|r|���S|S)aConvert this matrix into Block Sparse Row Format.

        With copy=False, the data/indices may be shared between this
        matrix and the resultant bsr_matrix.

        If blocksize=(R, C) is provided, it will be used for determining
        block size of the bsr_matrix.
        Nr)r �tocsrr/r+)rEr r+s   rMr/zbsr_matrix.tobsr�sP���T�4�>�2�2�2��:�:�<�<�%�%�	�%�:�:�:��	��9�9�;�;���KrWc�(�|j\}}|j\}}|j}t|j|jft
||�����}tj|dz|���}tj||���}	tj|t|j
�����}
t||z||z|||j�|d���|j�|d���|j
||	|
�
�
|�|
|	|f|j���S)Nr#rr%Fr,�r()r(r rTrr;r:r9r5rfrr&rrCr8�_csr_container)rEr+rGrHrIrJrTrKr;r:r8s           rMr�zbsr_matrix.tocsr�s���z���1��~���1��h��#�T�[�$�,�$?�+.�s�A�;�;�8�8�8�	���!�a�%�y�1�1�1���(�3�i�0�0�0���x��6�$�*�#5�#5�6�6�6���!�q�&��q�&��Q��+�$�$�Y�U�$�;�;��,�%�%�i�e�%�<�<��)����	�	�	��"�"�D�'�6�#:�$�*�"�M�M�MrWc�V�|�d����|���Srx)r��tocsc)rEr+s  rMr�zbsr_matrix.tocsc�s'���z�z�u�z�%�%�+�+��+�6�6�6rWc�8�|j\}}|j\}}tj|j��}|jjtjtj��jkrH|�tj��}tj	||k��rtd���|}|tj||z��z�|��}|�||z���
d||��}|tjtj|���
dd��d|f��z
}|�
d��}||jz�||z���
d||��}	|	tjtj|��|df��z
}	|	�
d��}	|j�
d��}
|r|
���}
|�|
||	ff|j���S)z�Convert this matrix to COOrdinate format.

        When copy=False the data array will be shared between
        this matrix and the resultant coo_matrix.
        zMatrix too big to convertrPrr�)r(r r5rVr;r&�itemsize�intprC�anyr4�arange�repeatr��tiler:r8r+r=)rEr+rGrHrIrJ�indptr_diff�indptr_diff_limited�row�colr8s           rMryzbsr_matrix.tocoo�s����j���!��n���!��g�d�k�*�*����%�����(9�(9�(B�B�B�"-�"4�"4�R�W�"=�"=���v�)�[�8�9�9�
>� �!<�=�=�=�-�K��2�9�Q��T�?�?�"�*�*�;�7�7���j�j��1��o�o�%�%�b��1�-�-���r�w�r�y��|�|�+�+�B�q�1�1�A�a�5�9�9�9���k�k�"�o�o���4�<��'�'��!��,�,�4�4�R��!�<�<���r�w�r�y��|�|�a��U�+�+�+���k�k�"�o�o���y� � ��$�$���	��9�9�;�;�D��"�"�
�C��:��d�j�#�
�
�	
rWc�X�|�d����||���S)NFr,)�order�out)ry�toarray)rEr�r�s   rMr�zbsr_matrix.toarray�s)���z�z�u�z�%�%�-�-�E�s�-�C�C�CrWc
�n�|�td���|j\}}|j\}}|j||zz}|jdkr"|�||f||f|j|���St
j||zdz|jj���}t
j||j	j���}	t
j|||f|j
j���}
t||z||z|||j|j	|j
���||	|
����
�
|�|
|	|f||f|���S)NzoSparse matrices do not support an 'axes' parameter because swapping dimensions is the only logical permutation.r)r r&r+rr%)r(r+)
r4r r(rTr�r&r5rfr;r:r8rrh)rE�axesr+rIrJrGrH�NBLKr;r:r8s           rM�	transposezbsr_matrix.transpose�s[�����L�N�N�
N��~���1��z���1��x�!�A�#����8�q�=�=��&�&��1�v�!�Q��-1�Z�d�'�D�D�
D���!�Q�$��(�$�+�*;�<�<�<���(�4�t�|�'9�:�:�:���x��q�!��D�I�O�<�<�<���a��d�A�q�D�!�Q��k�4�<�����1B�1B��g�t�z�z�|�|�	5�	5�	5��"�"�D�'�6�#:�*+�Q��d�#�<�<�	<rWc��|jsdS|j\}}|j\}}|jdk�d||z���d���}|���d}|j||jdt|���<tj	||z||z|j
|j|��|���dS)zRemove zero elements in-place.NrrPr)r^)
rTr r(r8r��sum�nonzeror<r�csr_eliminate_zerosr;r:rS)rErIrJrGrH�mask�nonzero_blockss       rM�eliminate_zeroszbsr_matrix.eliminate_zeross����x�	��F��n���!��j���!��	�Q��'�'��1�Q�3�/�/�3�3��3�;�;��������*��*.�)�N�*C��	�&�3�~�&�&�&�'�	�(��A��q�!�t�T�[�)-��t�	=�	=�	=��
�
�����rWc� �|jrdS|���|j\}}|j\}}||z}d}d}t	|��D]�}|}	|j|dz}|	|kr�|j|	}
|j|	}|	dz
}	|	|kr=|j|	|
kr,||j|	z
}|	dz
}	|	|kr|j|	|
k�,|
|j|<||j|<|dz
}|	|k��||j|dz<��|���d|_dS)zkEliminate duplicate matrix entries by adding them together

        The is an *in place* operation
        NrrT)	�has_canonical_format�sort_indicesr r(�ranger;r:r8rS)rErIrJrGrH�n_rowrT�row_endrO�jj�j�xs            rM�sum_duplicateszbsr_matrix.sum_duplicates1sP��
�$�	��F��������~���1��z���1��Q��������u���
	#�
	#�A��B��k�!�A�#�&�G��w�,�,��L��$���I�b�M���a����7�l�l�t�|�B�'7�1�'<�'<����2��&�A��!�G�B��7�l�l�t�|�B�'7�1�'<�'<�%&���S�!�!"��	�#���q����w�,�,� #�D�K��!�����
�
����$(��!�!�!rWc
���|jrdS|j\}}|j\}}t||z||z|||j|j|j�����d|_dS)z3Sort the indices of this matrix *in place*
        NT)�has_sorted_indicesr r(rr;r:r8rh)rErIrJrGrHs     rMr�zbsr_matrix.sort_indicesRsj���"�	��F��n���!��j���!���A��q�!�t�Q��4�;���d�i�o�o�FW�FW�X�X�X�"&����rWc��|j\}}|j\}}t|j��||zdzkrt	d���|jd}t|j��|krt	d���t|j��|krt	d���|jd|�|_|jd|�|_dS)z9 Remove 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<r;r4r:r8)rErIrJrGrHr�s      rMrSzbsr_matrix.prune_s����n���!��j���!��t�{���q�!�t�a�x�'�'��?�@�@�@��{�2����t�|���t�#�#��A�B�B�B��t�y�>�>�D� � ��>�?�?�?��I�e�t�e�$��	��|�E�T�E�*����rWc���|�||j���}tt|j|z|jz��}|j\}}t|j��t|j��z}t|j|j	|j|j	f|���}	tj|jj|	���}
tj||	���}gd�}||vr'tj||z|ztj
���}
n4tj||z|zt|j|j�����}
||jd|z|jd|z|||j�|	��|j	�|	��|j|j�|	��|j	�|	��tj|j��|
||
�
�
|
d}|d|�}|
d||z|z�}
||d	zkr(|���}|
���}
|
�d||��}
|�|
||
f|j�
��S)z5Apply the binary operation fn to two sparse matrices.rr#r%)�_ne_�_lt_�_gt_�_le_�_ge_rrrPNr'r�)�	__class__r �getattrrrBr<r8rr;r:r5rfr(�bool_rr&rCrhr+r�)rEr{�op�in_shape�	out_shape�fnrIrJ�max_bnnzrKr;r:�bool_opsr8�actual_bnnzs               rM�_binoptzbsr_matrix._binopttsC��
���u����?�?���\�4�;��#3�d�k�#A�
B�
B���n���!��t�y�>�>�C��
�O�O�3��#�T�[�$�,�%*�\�5�=�%B�+3�5�5�5�	���$�+�+�9�=�=�=���(�8�9�5�5�5��;�;�;��
��>�>��8�A�a�C��L���9�9�9�D�D��8�A�a�C��L��t�z�%�+�0N�0N�O�O�O�D�
��4�:�a�=�!��T�Z��]�A�-�q�!��;���i�(�(��<���y�)�)��9��<���y�)�)��=���	�*�*�
�8�E�J������		�		�		��R�j���,�;�,�'���$�Q�q�S��_�$�%����!��#�#��l�l�n�n�G��9�9�;�;�D��|�|�B�q��#�#���~�~�t�W�f�5�T�Z�~�H�H�HrWc�
�|rS|�||j���|j���f|j|j���S|�||j|jf|j|j���S)z�Returns 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&)r�r:r+r;r(r&)rEr8r+s   rM�
_with_datazbsr_matrix._with_data�s���
�	F��>�>�4���(9�(9�(;�(;�D�K�<L�<L�<N�<N�"O�)-��$�*�"�F�F�
F��>�>�4���T�[�"A�)-��$�*�"�F�F�
FrW)NNFN)Tror!)NF)F)NN) �__name__�
__module__�__qualname__�__doc__rBr.rDrY�propertyr r_rrcrmrrrvrzr~r�r�r/r�r�ryr�r�r�r�r�rSr�r��rWrMrrsW������_�_�@�F�j,�j,�j,�j,�X8C�8C�8C�8C�|#�#�#���n�-�-�-�I�,�,�,�,��_�,�F�N����
�
�
�
� �(�0�H��"�"�"�"�"�"�8�8�8�
�
�
����4
�4
�4
�t���� N�N�N�N�*�N�*�E�M�7�7�7�7��N�*�E�M�"
�"
�"
�"
�HD�D�D�D��&�.�G�O�<�<�<�<�2!�*�2�I�����()�)�)�B'�'�'�+�+�+�*.I�.I�.I�.I�b
F�
F�
F�
F�
F�
FrWc�X�ddlm}t|t��pt||��S)a�Is 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_matrix, isspmatrix_bsr
    >>> isspmatrix_bsr(bsr_matrix([[5]]))
    True

    >>> from scipy.sparse import bsr_matrix, csr_matrix, isspmatrix_bsr
    >>> isspmatrix_bsr(csr_matrix([[5]]))
    False
    r)�	bsr_array)�_arraysr�r1r)r�r�s  rMrr�s5��.#�"�"�"�"�"��a��$�$�@�
�1�i�(@�(@�@rW)#r��
__docformat__�__all__�warningsr�numpyr5�_datarr�_compressedr	�_baser
rr�_sputilsr
rrrrrr�rrrrrrrrrrr�rWrM�<module>r�s���/�/�%�
��)�
*������������.�.�.�.�.�.�.�.�#�#�#�#�#�#�1�1�1�1�1�1�1�1�1�1�5�5�5�5�5�5�5�5�5�5�5�5�5�5�5�5�5�5�������&�&�&�&�&�&�&�&�&�&�&�&�&�&�&�&�&�&�
Y
F�Y
F�Y
F�Y
F�Y
F��]�Y
F�Y
F�Y
F�FA�A�A�A�ArW

Youez - 2016 - github.com/yon3zu
LinuXploit