
    Yh                     (   d Z g ZddlmZ ddlZddlZddlmZm	Z	 ddl
mZmZmZmZ ddlmZmZ ddlmZ dd	lmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$ dd
l%m&Z& ddl'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2  G d deee&          Z3ddZ4d Z5dS )z>Base class for sparse matrix formats using compressed storage.    )warnN)_prune_arraycopy_if_needed   )_spbaseissparsesparraySparseEfficiencyWarning)_data_matrix_minmax_mixin)_sparsetools)get_csr_submatrixcsr_sample_offsetscsr_todensecsr_sample_valuescsr_row_indexcsr_row_slicecsr_column_index1csr_column_index2csr_diagonal	expandptrcsr_has_canonical_formatcsr_eliminate_zeroscsr_sum_duplicatescsr_has_sorted_indicescsr_sort_indicescsr_matmat_maxnnz
csr_matmat)
IndexMixin)upcastupcast_char	to_nativeisshapegetdtype	isintlikedowncast_intp_indexget_sum_dtypecheck_shapeget_index_dtypebroadcast_shapesc                      e Zd ZdZd9dddZd:dZej        j        e_        d:dZej        j        e_        d;d	Zd
 Z	d Z
d Zd Zd Zd Zd Zd Zd<dZej        j        e_        d=dZej        j        e_        d:dZd Zd Zd Zd Zd Zd>dZd Zd>dZd9dZd Zd  Zd! Zd" Z d# Z!d$ Z"d% Z#d& Z$d;d'Z%ej%        j        e%_        d?d(Z&ej&        j        e&_        d) Z'e(d*e)fd+            Z*e*j+        d,e)fd-            Z*d. Z,e(d*e)fd/            Z-e-j+        d,e)fd0            Z-d1 Z.d2 Z/d3 Z0d4 Z1ej1        j        e1_        d;d5Z2d6 Z3d7 Z4d>d8Z5dS )@
_cs_matrixzY
    base array/matrix class for compressed row- and column-oriented arrays/matrices
    NFmaxprintc                ~	   t          j        | ||           t          |          rv|j        | j        k    r|r|                                }n|                    | j                  }|j        |j        |j        |j	        f\  | _        | _        | _        | _	        n,t          |t                    rt          || j                  rt          || j                  | _	        |                     | j                  \  }}|                     t%          | j                            }t)          j        dt-          |t.                              | _        t)          j        d|          | _        t)          j        |dz   |          | _        n8t1          |          dk    rc|                     |||	          }	|	                    | j                  }
|
\  | _        | _        | _        | _	        |                                  nt1          |          d
k    r|\  }}}d }|d|vrt%          |          }|                     ||f|d          }|st8          }t)          j        |||          | _        t)          j        |||          | _        t)          j        |||          | _        nt=          d| j        j          d|           	 t)          j!        |          }n2# tD          $ r%}t=          d| j        j          d|           |d }~ww xY wt          | tF                    r.|j$        dk    r#| j        dk    rt=          d|j$         d          |j$        dk    rt=          d|j$         d          |                     ||          }	|	                    | j                  }
|
\  | _        | _        | _        | _	        |t          || j                  | _	        n| j        	 t1          | j                  dz
  }| j                                        dz   }n"# tD          $ r}t=          d          |d }~ww xY wt          |                     ||f          | j                  | _	        |0t-          |          }| j        %                    |d          | _        | &                    d           d S )Nr-   allow_ndmaxvalr   )defaultr   dtype   shaper6      T)r3   check_contentscopyr6   zunrecognized z constructor input: csczCSC arrays don't support zD input. Use 2DzCSR arrays don't yet support zD.z!unable to infer matrix dimensionsFr=   
full_check)'r   __init__r   formatr=   asformatindptrindicesdata_shape
isinstancetupler#   	_allow_ndr(   _swap_shape_as_2d_get_index_dtypemaxr9   npzerosr$   floatlen_coo_container_coo_to_compressedsum_duplicatesr   array
ValueError	__class____name__asarray	Exceptionr	   ndimastypecheck_format)selfarg1r9   r6   r=   r.   MN	idx_dtypecooarraysrG   rF   rE   r3   enewdtypes                    j/var/www/tools.fuzzalab.pt/emblema-extractor/venv/lib/python3.11/site-packages/scipy/sparse/_compressed.pyrB   z_cs_matrix.__init__   s   dD8<<<<D>> @	G{dk))d)yy{{}}T[11T\49dkA=DKty$++ e$$ 7	Gtdn555 &C *$HHHzz$"3441 !11TZ1II	HQ(F(F(FGG	!x955 hq1uI>>>t99>>--d%u-MMC 33DJ??FHNEDKty$+''))))YY!^^.2+T7F "F(Qe^^!$U $ 5 5w6G7=?C !6 !E !EI   .-#%8G$i#P#P#PDL"$(6I"N"N"NDK "D F F FDII$ &BT^5L &B &B;?&B &B C C C
Fz$'' F F F  ">1H "> ">7;"> "> ? ?DEFF $(( YTY!^^u@T@T !WTY!W!W!WXXXy1}} !N!N!N!NOOO%%d%%88C++DJ77F@F=DKty$+ %ednEEEDKKZM$$q(L$$&&* M M M !DEE1LM &djj!Q&8&84>RRRDKH	(((>>DIU+++++s0   K% %
L/ LL/3P# #
Q-P==Qc                    |t          | j        d                   S | j        dk    r-|dv rt          | j        d                   S t          d          |dk     r|dz  }|                     |d|z
  f          \  }}|                     | j                  \  }}|dk    r(t          j        t          | j	                  |          S |dk    rt          j
        | j                  S t          d          )Nr   r   rk   axis out of boundsr   r7   	minlength)intrE   r]   rX   rL   r9   rP   bincountr&   rF   diff)r`   axis_rc   s       ri   _getnnzz_cs_matrix._getnnzv   s    <t{2'''Y!^^w4;r?+++1222axx	jj$D!122GD!::dj))DAqqyy{#6t|#D#DPQRRRRwt{+++1222    c                                                        |t          j         j                  S  j        dk    r,|dvrt          d          t          j         j                  S |dk     r|dz  }                     |d|z
  f          \  }}|dk    rs                      j                  \  }} j        dk    }|                                r j	        n j	        |         }t          j
        t          |          |          S |dk    rk j                                        rt          j         j                  S t          j         j                  }t          j         fd|D                       S t          d          )Nr   rl   rm   r   r7   rn   c                 X    g | ]&\  }}t          j        j        ||                   'S  )rP   count_nonzerorG   ).0ijr`   s      ri   
<listcomp>z,_cs_matrix.count_nonzero.<locals>.<listcomp>   s2    PPP$!QR-di!n==PPPrv   )rV   rP   rz   rG   r]   rX   rL   r9   allrF   rq   r&   rr   rE   	itertoolspairwiserW   )r`   rs   rt   rc   maskidxpairss   `      ri   rz   z_cs_matrix.count_nonzero   sp   <#DI...9>>7"" !5666#DI...!88AID**dAH-..a199::dj))DAq9>D"&((**D$,,$,t2DC;23771EEEEQYYy}} ,wt{+++&t{33E8PPPP%PPPQQQ1222rv   Tc                    | j         j        j        dk    r$t          d| j         j        j         dd           | j        j        j        dk    r$t          d| j        j        j         dd           | j        j        | j        j        | j         j        fD ]}|dk    rt          d          | 	                    | j
                  \  }}t          | j                   |dz   k    r*t          d	t          | j                    d
|dz              | j         d         dk    rt          d          t          | j                  t          | j                  k    rt          d          | j         d         t          | j                  k    rt          d          |                                  |r | j        dk    r| j                                        |k    rt          d|           | j                                        dk     rt          d          t!          j        | j                                                   dk     rt          d          |                     | j         | j        f          }t!          j        | j         |          | _         t!          j        | j        |          | _        t)          | j                  | _        dS dS )a  Check whether the array/matrix respects the CSR or CSC format.

        Parameters
        ----------
        full_check : bool, optional
            If `True`, run rigorous check, scanning arrays for valid values.
            Note that activating those check might copy arrays for casting,
            modifying indices and index pointers' inplace.
            If `False`, run basic checks on attributes. O(1) operations.
            Default is `True`.
        r|   z$indptr array has non-integer dtype ()r:   
stacklevelz%indices array has non-integer dtype (r   z'data, indices, and indptr should be 1-Dzindex pointer size z should be r   z!index pointer should start with 0z*indices and data should have the same sizerk   zQLast value of index pointer should be less than the size of index and data arrayszindices must be < zindices must be >= 0z(indptr must be a non-decreasing sequencer5   N)rE   r6   kindr   namerF   rG   r]   rX   rL   rM   rS   prunennzrO   minrP   rr   rN   r[   r"   )r`   rA   xrb   rc   rd   s         ri   r_   z_cs_matrix.check_format   s    ;!S((Q8I8NQQQ   <"c))S9K9PSSS    ).$,"3T[5EF 	L 	LAAvv !JKKK  zz$+,,1A%%W3t{3C3CWWPQTUPUWWXXXKNa@AAA TY//IJJJKOc$,//// A B B B 	

 	-x!||<##%%**$%=!%=%=>>><##%%))$%;<<<74;''++--11$%OPPP--t{DL.IJJI*T[	BBBDK:dl)DDDDL!$),,DIII	- 	-rv   c                     |                                   |                      || j        |          d          }|                                 |S )zScalar version of self._binopt, for cases in which no new nonzeros
        are added. Produces a new sparse array in canonical form.
        Tr?   )rV   
_with_datarG   eliminate_zeros)r`   otheropress       ri   _scalar_binoptz_cs_matrix._scalar_binopt   sP     	oobbE22o>>
rv   c                    |j         | j         k    r t          d| j          d|j          d          t          | j        j        |j        j                  }|                     d          d         }t          j        |||d          }|j        j	        r|n|j
        }|                     | j                  \  }}t          ||| j        | j        | j        |           |                     |d	          S )
NzIncompatible shapes ( and r   CFr   T)r6   orderr=   Fr?   )r9   rX   r!   r6   charrL   rP   rW   flagsc_contiguousTrM   r   rE   rF   rG   
_container)r`   r   r6   r   resultyrb   rc   s           ri   
_add_densez_cs_matrix._add_dense   s    ;$*$$TTZTTekTTTUUUDJOU[-=>>

4  #%uEEEEl/=FFVXzz$+,,1Aq$+t|TYBBBvE222rv   c                 .    |                      |d          S )N_plus__binoptr`   r   s     ri   _add_sparsez_cs_matrix._add_sparse  s    ||E8,,,rv   c                 .    |                      |d          S )N_minus_r   r   s     ri   _sub_sparsez_cs_matrix._sub_sparse  s    ||E9---rv   c                 ^   t          |          r]| j        |j        k    r+|                     |          }|                     |d          S |j        dk    r\|                     |                                d                   }| j        dk    r"|                    d| j        d         f          S |S |j        dk    r-|                     |                                d                   S | j        dv r,|                    | j        	                                          S | j
        \  }}|j
        \  }}|dk    rA|dk    r;|                    |                     ||                                                    S |dk    rA|dk    r;|                     |                    ||                                                    S t          | t                    }|dk    rs||k    rmt          |                                                                |          }|                     |          }| j        dk    r|n|                    d|f          S |dk    rO||k    rIt          |                                                                 |          }	|                    |	          S |dk    rO||k    rIt          |                                                                |          }|                    |           S |dk    rO||k    rIt          |                                                                 |          }
|
                    |          S t#          d	| j         d
|j                   t%          j        |          }|j        dk    r't%          j        |                                 |          S |j        dk    ri|j        t$          j        k    rt0          S t3          | j        |j                  }|                     |j        d                                       |          S | j        dv rYt3          | j        |j                  }t%          j        | j        	                                |                              |          S |                                 }| j        |j        k    r]t%          j        |j        ||j                           }|                    t$          j                                                  |_        |S t%          j        |          }| j        d         dk    s| j        dk    r|j        d         dk    rt%          j        |j        |          }ne|j        d         | j        d         k    r*t%          j        |j        |dd|j         f                   }nt#          d	| j         d
|j                   | !                    |j         |j"        |j        d         z            }t%          j#        t%          j$        |j        d         |          |j"                  }t%          j%        |j         &                    |d          |j        d                   }| '                    |                    t$          j                                                  ||ff|j        d         | j        d         fd          S | j        d         dk    r|j        d         dk    r%t%          j        |j        dddf         |          }nk|j        d         | j        d         k    r0t%          j        |j        dddf         ||j(                           }nt#          d	| j         d
|j                   | !                    |j(        |j"        |j        d         z            }t%          j#        |j(        &                    |d          |j        d                   }t%          j%        t%          j$        |j        d         |          |j"                  }| '                    |                    t$          j                                                  ||ff| j        d         |j        d         fd          S |j        d         dk    rX| j        d         |j        d         k    r<t%          j        |j        |dd|j         f                                                   }n|j        d         dk    rT| j        d         |j        d         k    r8t%          j        |j        ||j(                                                           }nt#          d	| j         d
|j                   |                    t$          j                                                  |_        |S )z?Element-wise multiplication by array/matrix, vector, or scalar._elmul_r   r   )r   r   r   r   r   )r   r   r7   inconsistent shapes r   rk   Nr2   r5   Fr?   r9   r=   ))r   r9   rY   r   _mul_scalartoarrayr]   reshaperG   sumrM   _matmul_sparsetocscrI   r	   _make_diagonal_csrravelrX   rP   
asanyarraymultiplysizer6   object_NotImplementedr*   flattocoocoordsviewndarray
atleast_2dcolrN   r   repeatarangetiler^   rT   row)r`   r   r   sMsNoMoNis_array	new_otherr=   new_selfbshaperetrG   other2drd   r   r   s                     ri   _multiply_2d_with_broadcastingz)_cs_matrix._multiply_2d_with_broadcasting  sQ    E?? +	TzU[((u--||E9555{f$$))%--//$*?@@9>>!>>1djm*<==={d""''(:;;;z^++((999 &FB'FBQww277++DLLR,@,@,F,F,H,HIIIQww277**5==R+@+@+F+F+H+HIII!$00HQww288.u}}/D/D/F/FQQ	,,Y77!%avvV^^QG5L5LLQww288)$,,..*>*>*@*@(KK++D111 Qww288.u}}/D/D/F/FQQ	 //555Qww288-dllnn.B.B.D.DhOO..u555RDJRRU[RRSSS e$$:>>;t||~~u555:??{bj((%%%dj%+>>F##EJqM22::6BBB:''%dj%+>>F;ty}}66>>vFFFjjll:$$;sxsz):;;Dyy,,2244CHJ -&&:a=Aa}Q1$${38W55q!TZ^33{38WQQQZ-@AA !V
!V!V!V!VWWW--cg58Ww}Q?O5O . Q QI)BIgmA&6iHHH#'RRC'#'...??qAQRRC&&2:&&,,..c
;}Q'B8 '    :a=A}Q1$${38AAAtG#4g>>q!TZ]22{38AAAtG#4gcg6FGG !V
!V!V!V!VWWW--cg58Ww}Q?O5O . Q QI)CGNN95NAA7=QRCSTTC'")GM!$4IFFFPPC&&2:&&,,..c
;z!}gmA&67 '    =q  TZ]gmA6F%F%F;sxCG)<)B)B)D)DEEDD]1""tz!}a8H'H'H;sx)9)?)?)A)ABBDDRDJRRU[RRSSS99RZ((..00
rv   c           	      *   | j         \  }}t          j        |t          | j        j        |j        j                            }t          t          | j        dz             } |||| j	        | j
        | j        ||           | j        dk    r|d         n|S )Nr5   _matvecr   r   )rM   rP   rQ   r!   r6   r   getattrr   rC   rE   rF   rG   r]   )r`   r   rb   rc   r   fns         ri   _matmul_vectorz_cs_matrix._matmul_vector  s     1 !;tz@P#Q#QRRR \4;#:;;
1adlDIufEEE INNvayy6rv   c                    | j         \  }}|j        d         }t          j        ||ft	          | j        j        |j        j                            }t          t          | j	        dz             } ||||| j
        | j        | j        |                                |                                           | j        dk    r|                    |f          S |S )Nrk   r5   _matvecsr   )rM   r9   rP   rQ   r!   r6   r   r   r   rC   rE   rF   rG   r   r]   r   )r`   r   rb   rc   n_vecsr   r   s          ri   _matmul_multivectorz_cs_matrix._matmul_multivector  s     1R1f+ +DJOU[=M N NP P P \4;#;<<
1adlDI;;==&,,..	* 	* 	* 9>>>>6),,,rv   c                    | j         \  }}|j        }|dk    r'|                    d|j        d         f          j        }|j        dk    r|j        n|j        d         df\  }}d}| j        dk    r||fz  }|dk    r||fz  }| j        dk    r|nd|dk    r|ndf}|                     |          }| j        | j        |j        |j        f}	| 	                    ||f          \  }}| 	                    | |f          \  }
}| 
                    |	          }t          j        |
j        |          }t          j        |
j        |          }t          j        |j        |          }t          j        |j        |          }t          ||||||          }|dk    rc|dk    r.t          j        dt          | j        |j                            S |                     |t          | j        |j                            S | 
                    |	|          }||k    rn|}t          j        |
j        |          }t          j        |
j        |          }t          j        |j        |          }t          j        |j        |          }t          j        |dz   |          }t          j        ||          }t          j        |t          | j        |j                            }t%          |||||
j        |||j        |||           |dk    rt          j        |d                   S |                     |||f|          }||k    r4|j        dk    r|                                }|                    |          }|S )	Nr   r   r7   ry   r5   r2   r9   csr)rM   r]   r   r9   r   rH   rY   rE   rF   rL   rN   rP   r[   r   rW   r    r6   emptyr   rG   rC   tocsr)r`   r   rb   K1o_ndimK2rc   	new_shape
faux_shapeindex_arrayssord   s_indptr	s_indiceso_indptr	o_indicesr   new_idx_dtyperE   rF   rG   r   s                          ri   r   z_cs_matrix._matmul_sparse  s_   !2Q;;MM1ek!n"5668E %
aek!na5HA 	9>>!IQ;;!I9>>aaqv{{!!J
u%%T\5<Ozz1a&!!1zz4-((1)),77	:ahi888Jqy	:::	:ahi888Jqy	:::	1h	8YOO!88Bx
EK)H)HIIII>>)6$*ek3R3R>SSS--l3-GGI%%%Iz!()<<<H
19I>>>Iz!()<<<H
19I>>>I!a%y111(3i000x6$*ek#B#BCCC1aYY7D	* 	* 	*
 ??8DG$$$nndGV4JnGG""zU""iikk++i((C
rv   r   c           
         |                      | j                  \  }}|                      || f          \  }}|| k    s||k    r t          j        d| j        j                  S t          j        t          |t          |d          z   |t          |d          z
            t          | j                            }t          |||| j
        | j        | j        |           |S )Nr   r5   )rL   r9   rP   r   rG   r6   r   rO   r    r   rE   rF   )r`   krb   rc   rt   r   s         ri   diagonalz_cs_matrix.diagonal  s    zz$*%%1zz1qb'""177a1ff8ATY_5555HSSAYYC1II66fTZ>P>PQQQQ1dk4<AFFFrv   c                    | j         dk    rt          | d          s||                     d          d         v rt          | j                  }t          j        t          | j                  dz
  |          }| 	                    t
          j
                  \  }}|||<   |                     |          }|dz  dk    r|j        }|                    d||          S t          j        | |||          S )	zSum the array/matrix over the given axis.  If the axis is None, sum
        over both rows and columns, returning a scalar.
        r7   	blocksize))r   rk   )r   r   r   r5   ry   )rs   r6   out)r]   hasattrrL   r'   r6   rP   rQ   rS   rE   _minor_reduceadd_ascontainerr   r   r   )r`   rs   r6   r   	res_dtyper   major_indexvalues           ri   r   z_cs_matrix.sum  s     INN74#=#=N

#566q999%dj11I(3t{++a/yAAAC!%!3!3BF!;!;K$C##C((Cax1}}e77%S7999;t$eEEEErv   c                     || j         }t          j        t          j        | j                            }|                    |t          | j        |                             }||fS )a  Reduce nonzeros with a ufunc over the minor axis when non-empty

        Can be applied to a function of self.data by supplying data parameter.

        Warning: this does not call sum_duplicates()

        Returns
        -------
        major_index : array of ints
            Major indices where nonzero

        value : array of self.dtype
            Reduce result for nonzeros in each major_index
        )rG   rP   flatnonzerorr   rE   reduceatr&   )r`   ufuncrG   r   r   s        ri   r   z_cs_matrix._minor_reduce  s_     <9DnRWT[%9%9::t24;{3KLLN NE!!rv   c                    |                      | j                  \  }}|                      ||f          \  }}t          ||| j        | j        | j        ||dz   ||dz   	  	        \  }}}	|	                    | j                  S )Nr   r5   )rL   r9   r   rE   rF   rG   r   r6   )
r`   r   r   rb   rc   majorminorrE   rF   rG   s
             ri   _get_intXintz_cs_matrix._get_intXint  s    zz$*%%1zz3*--u 1q$+t|TY519eUQY!0 !0 xxdjx)))rv   c                     |                      ||f          \  }}|j        dv r!|j        dv r|                     ||d          S |                     |                              |          S )Nr   NTr?   )rL   step_get_submatrix_major_slice_minor_slicer`   r   r   r  r  s        ri   _get_sliceXslicez_cs_matrix._get_sliceXslice&  sq    zz3*--u:""uzY'>'>&&ue$&???  ''44U;;;rv   c                 X   | j         j        }|                     | j                  \  }}|                     ||f          \  }}t	          j        ||          }t	          j        ||          }t	          j        |j        | j                  }t          ||| j	        | j         | j
        |j        |                                |                                |	  	         |j        dk    r|                     |          S |                     |                    |j                            S )Nr5   r   )rF   r6   rL   r9   rP   r[   r   r   r   rE   rG   r   r]   r   rY   r   )	r`   r   r   rd   rb   rc   r  r  vals	            ri   _get_arrayXarrayz_cs_matrix._get_arrayXarray,  s    L&	zz$*%%1zz3*--u
5	222
5	222huz444!QT\49*ekkmmU[[]]C	I 	I 	I:??$$S)))~~ckk%+66777rv   c                     |                      ||f          \  }}|                     |                              |          S N)rL   _major_index_fancy_minor_index_fancyr  s        ri   _get_columnXarrayz_cs_matrix._get_columnXarray;  s=    zz3*--u&&u--@@GGGrv   c           	         |                      | j        | j        f          }t          j        ||                                          }|                     | j                  d         }t          |          }| j	        dk    r|                     ||f          n|f}|dk    r| 
                    || j                  S | j        |dz            | j        |         z
                      |          }t          j        |dz   |          }t          j        ||dd                    |d         }	t          j        |	|          }
t          j        |	| j                  }t!          ||| j                            |d	          | j                            |d	          | j        |
|           | 
                    ||
|f|d
          S )zBIndex along the major axis where idx is an array of ints.
        r5   r   r7   r   Nr   rk   Fr?   r   )rN   rE   rF   rP   r[   r   rL   rM   rS   r]   rY   r6   r^   rQ   cumsumr   r   rG   )r`   r   rd   rF   rc   rb   r   row_nnz
res_indptrr   res_indicesres_datas               ri   r  z_cs_matrix._major_index_fancy@  s    ))4;*EFF	*S	22288::JJt())!,LL*.)q..DJJ1v&&&qd	66>>)4:>>>>;w{+dk'.BBJJ9UUXa!e9555

	'z!""~....nhs)4448Ctz222Kyu55L	66I	
 	
 	
 ~~xjA$-E  ; ; 	;rv   c           
      ^   |t          d          k    r|r|                                 n| S |                     | j                  \  }}|                    |          \  }}}t          t          |||                    }| j        dk    r|                     ||f          n|f}|dk    r|                     || j	                  S ||}
}	|dk    r|dk    rd}
|dz   |dz   }}| j
        |||         | j
        |	|
|         z
  }| j        j	        }t          j        |dz   |          }t          j        ||dd                    |dk    rit          | j
        |         | j
        |                   }t          j        | j        |         |          }t          j        | j        |         |          }n^|d         }t          j        ||          }t          j        || j	                  }t#          |||| j
        | j        | j        ||           |                     |||f|d	
          S )z@Index along the major axis where idx is a slice object.
        Nr7   r   r5   rk   r   r  r?   Fr   )slicer=   rL   rM   rF   rS   ranger]   rY   r6   rE   rP   rQ   r  rW   rG   r   r   )r`   r   r=   rb   rc   startstopr  r   start0stop0start1stop1r  rd   r  all_idxr  r  r   s                       ri   r	  z_cs_matrix._major_slice`  s9    %++"&0499;;;D0zz$+,,1KKNNtTeT4(())*.)q..DJJ1v&&&qd	66>>)4:>>>> t2::%1**E	4!8+fU4/0KuT)*+L&	Xac333

	'z!""~....199DK.D0ABBG(4<#8tDDDKx	' 2>>>HHR.C(3i888Kx4:666H%tT[$,)[(< < < ~~xjA$-E  ; ; 	;rv   c           
         |                      | j        | j        f          }| j                            |d          }| j                            |d          }t	          j        ||                                          }|                     | j                  \  }}t          |          }| j
        dk    r|                     ||f          n|f}|dk    r|                     || j                  S t	          j        ||          }	t	          j        | j        |          }
t          |||||||	|
           t	          j        |                              |d          }|
d         }t	          j        ||          }t	          j        || j                  }t%          ||	t          | j                  || j        ||           |                     |||
f|d          S )zBIndex along the minor axis where idx is an array of ints.
        Fr?   r5   r7   r   rk   r   )rN   rF   rE   r^   rP   r[   r   rL   rM   rS   r]   rY   r6   rQ   
empty_liker   argsortr   r   rG   )r`   r   rd   rF   rE   rb   rc   r   r   col_offsetsr  	col_orderr   r  r  s                  ri   r  z_cs_matrix._minor_index_fancy  s    ))4<*EFF	,%%ie%<<##IE#::jI...4466zz$+,,1HH*.)q..DJJ1v&&&qd	66>>)4:>>>> hq	222]4;i@@@
		
 		
 		
 JsOO**95*AA	nhs)4448Ctz222)[#dl2C2C!49k8	E 	E 	E~~xjA$-E  ; ; 	;rv   c                    |t          d          k    r|r|                                 n| S |                     | j                  \  }}|                    |          \  }}}t          t          |||                    }|dk    r1|                     |                     ||f          | j                  S |dk    r| 	                    ||          S | 
                    t          j        |||                    S )z@Index along the minor axis where idx is a slice object.
        Nr   r5   r   )r  r=   )r  r=   rL   rM   rF   rS   r  rY   r6   r  r  rP   r   )r`   r   r=   rb   rc   r  r   r  s           ri   r
  z_cs_matrix._minor_slice  s     %++"&0499;;;D0zz$+,,1KKNNtTeT4(())66>>$**aV"4"4DJ>GGG199&&St&<<<&&ryd'C'CDDDrv   c                    |                      | j                  \  }}t          ||          \  }}t          ||          \  }}	|dk    r*|dk    r$||k    r|	|k    r|r|                                 n| S t	          ||| j        | j        | j        ||||		  	        \  }
}}|                      ||z
  |	|z
  f          }| j        dk    r	|d         f}| 	                    |||
f|| j
        d          S )zbReturn a submatrix of this matrix.

        major, minor: None, int, or slice with step 1
        r   r   F)r9   r6   r=   )rL   rM   _process_slicer=   r   rE   rF   rG   r]   rY   r6   )r`   r  r  r=   rb   rc   i0i1j0j1rE   rF   rG   r9   s                 ri   r  z_cs_matrix._get_submatrix  s   
 zz$+,,1q))Bq))B77rQww277rQww"&0499;;;D0 1q$+t|TYBB!H !H 

BGR"W-..9>>1XKE~~tWf5U$(JU  < < 	<rv   c                 h    |                      ||f          \  }}|                     |||           d S r  rL   	_set_manyr`   r   r   r   r|   r}   s         ri   _set_intXintz_cs_matrix._set_intXint  7    zz3*%%1q!Qrv   c                 h    |                      ||f          \  }}|                     |||           d S r  r3  r5  s         ri   _set_arrayXarrayz_cs_matrix._set_arrayXarray  r7  rv   c                 ,    | j         |                     ||f            |j        \  }}|dk    o|j        d         dk    }|dk    o|j        d         dk    }|j        |j        }	}t          j        |j        | j                  }|j	        dk    rd S |r^t          j
        t          j        |          t          |                    }t          j        |	|          }	t          j        ||          }|r^t          j
        ||          }t          j        t          j        |          t          |	                    }	t          j
        ||          }|                     |||	f         |||	f         f          \  }
}|                     |
||           d S )Nr   r   r5   )
_zero_manyrL   r9   r   r   rP   r[   rG   r6   r   r   r   rS   r   r4  )r`   r   r   r   rb   rc   broadcast_rowbroadcast_colrcr|   r}   s               ri   _set_arrayXarray_sparsez"_cs_matrix._set_arrayXarray_sparse  sa   S#J//00y1Q2171:?Q2171:?uae1JqvTZ0006Q;;F 		")A,,A//A1A1A 	 	!QA	!c!ff--A	!QAzz3q!t9c!Q$i0111q!Qrv   c           
         d| j         v rd S | j        dk    rt          d          | j         \  }}|j        dk    }|dk     r}|rt          ||z   |          }n!t          ||z   |t	          |                    }t          j        | ||z
  | j        j                  }t          j        || j        j                  }n{|rt          |||z
            }n!t          |||z
  t	          |                    }t          j        || j        j                  }t          j        |||z   | j        j                  }|s|d t	          |                   }t          j	        t          j
        || j                                                            }	|	                                j         |                                j         k    rt          j        |	|j                   }	|	j        dk    rd S |                     ||f          \  }}|                     ||f          \  }}|	j        }
t          j        |
| j        j                  }t#          ||| j        | j        |
|||          }|dk    r4|                                  t#          ||| j        | j        |
|||           d|vr|	| j        |<   d S |dk    }| j        |                                z
  | j        dz  k     rH|	|         | j        ||         <   | }||         }||         }|                     |||	|                    d S |                                 }|                    ||           |                    | j                  }|\  | _        | _        | _        }d S )Nr   r   z"diagonals cant be set in 1d arraysr5   rk   gMbP?)r9   r]   NotImplementedErrorr   rS   rP   r   rF   r6   
atleast_1dr[   r   squeezebroadcast_tor   rL   r   r   rE   rV   rG   r   r   _insert_manyr   _setdiagrU   )r`   valuesr   rb   rc   	broadcast	max_indexr|   r}   r   	n_samplesoffsetsr   r   re   rf   rt   s                    ri   rG  z_cs_matrix._setdiag  sX   
??F9>>%&JKKKz1[A%	q55 7AqMM		Aq#f++66		1"i!m4<3EFFFA	)4<+=>>>AA  71q5MM		1q5#f++66		)4<+=>>>A	!Q]$,2DEEEA 	%GSVVG_FM"*V4:>>>??EEGG99;;		 11117++A6Q;;Fzz1a&!!1zz1a&!!1F	(9DL,>??? At{DL)!"Aw0 0!88!!!q!T[$,	 !W. . .W!"DIgF1 8dhhjj 48e#333'(wDIgdm$5D$A$AaAdG,,,,, **,,CLL###++DJ77F6<3DKty!!!rv   c                    |                      | j                  \  }}d }t          j        t          j        || j        j                                                            }t          j        t          j        || j        j                                                            } |||            |||           ||||fS )Nc                     |                                  }||k    rt          d| d| d          |                                 }|| k     rt          d| d| d          d S )Nzindex (z) out of range (>= r   z) out of range (< -)rO   
IndexErrorr   )rF   boundr   s      ri   check_boundsz1_cs_matrix._prepare_indices.<locals>.check_bounds<  s{    ++--Ce|| !K3!K!K5!K!K!KLLL++--CeV|| !K3!K!K5!K!K!KLLL |rv   r5   )rL   rM   rP   rC  r[   rF   r6   r   )r`   r|   r}   rb   rc   rQ  s         ri   _prepare_indicesz_cs_matrix._prepare_indices9  s    zz$+,,1	M 	M 	M M"*Qdl.@AAABBHHJJM"*Qdl.@AAABBHHJJQQ!Qzrv   c           
         |                      ||          \  }}}}t          j        t          j        || j                                                            }|j        }t          j        || j        j                  }t          ||| j
        | j        ||||          }|dk    r4|                                  t          ||| j
        | j        ||||           d|vr|| j        |<   dS t          d| j        j         dt           d           |dk    }	||	         | j        ||	         <   |	 }	||	         }||d	k     xx         |z  cc<   ||	         }||d	k     xx         |z  cc<   |                     ||||	                    dS )
zSets value at each (i, j) to x

        Here (i,j) index major and minor respectively, and must not contain
        duplicate entries.
        r5   r   rk   Nz%Changing the sparsity structure of a z. is expensive. lil and dok are more efficient.r:   r   r   )rR  rP   rC  r[   r6   r   r   r   rF   r   rE   rV   rG   r   rY   rZ   r
   rF  )
r`   r|   r}   r   rb   rc   rK  rL  r   r   s
             ri   r4  z_cs_matrix._set_manyJ  s    **1a00
1aM"*Qdj999::@@BBF	(9DL,>??? At{DL)!"Aw0 0!88!!!q!T[$,	 !W. . . W!"DIgF  ?9P ? ? ?(Q8 8 8 8 R<D'(wDIgdm$5D$Aa!eHHHMHHH$Aa!eHHHMHHHaAdG,,,,,rv   c           
      v   |                      ||          \  }}}}t          |          }t          j        || j        j                  }t          ||| j        | j        ||||          }|dk    r4|                                  t          ||| j        | j        ||||           d| j	        ||dk             <   dS )zSets value at each (i, j) to zero, preserving sparsity structure.

        Here (i,j) index major and minor respectively.
        r5   r   r   rk   N)
rR  rS   rP   r   rF   r6   r   rE   rV   rG   )r`   r|   r}   rb   rc   rK  rL  r   s           ri   r;  z_cs_matrix._zero_manyq  s    
 **1a00
1aFF	(9DL,>??? At{DL)!"Aw0 0!88!!!q!T[$,	 !W. . . ,-	''B,'(((rv   c           	         t          j        |d          }|                    |d          }|                    |d          }|                    |d          }| j        }|                     | j        | j        f| j        d         |j        z             }t          j        | j        |          | _        t          j        | j        |          | _        t          j        ||          }t          j        ||          }g }g }t          j	        |d	          \  }	}
t          j
        |
t          |                    }
t          j        |
          }d
}t          t          |	|
|
dd                             D ]O\  }\  }}}| j        |         }| j        |         }|
                    | j        ||                    |
                    | j        ||                    t          j	        |||         ddd         d	          \  }}t          |          ||z
  k    r;|
                    |||                    |
                    |||                    nj|
                    |||         ddd         |                    |
                    |||         ddd         |                    t          |          ||<   |}Q| j        |         }|
                    | j        |d                    |
                    | j        |d                    t          j        |          | _        t          j        |          | _        t          j        | j        j        |          } |d
          |d
<   t          j        | j                  }||	xx         |z  cc<   ||dd<   t          j        ||          | _        |rd| _        |                                  |                     d           dS )a:  Inserts new nonzero at each (i, j) with value x

        Here (i,j) index major and minor respectively.
        i, j and x must be non-empty, 1d arrays.
        Inserts each major group (e.g. all entries per row) at a time.
        Maintains has_sorted_indices property.
        Modifies i, j, x in place.
        	mergesort)r   clip)moderk   r2   r5   T)return_indexr   r   Nr  Fr@   )rP   r(  takehas_sorted_indicesrN   rF   rE   r   r[   uniqueappendrS   rr   	enumerateziprG   concatenater   r9   r  sort_indicesr_   )r`   r|   r}   r   r   do_sortrd   indices_parts
data_partsui	ui_indptrnew_nnzsprevr?  iijsjer  r   uj	uj_indptrnnzsindptr_diffs                          ri   rF  z_cs_matrix._insert_many  s    
1;///FF5vF&&FF5vF&&FF5vF&&) ))4<*E,0KOaf,D * G G	jI>>>z$,i@@@Jq	***Jq	*** 
	!$777IIiQ00	79%%(RIabbM)J)JKK 	 	OA|BK%E;r?D  eDj!9:::did
3444 Ia2htttn4HHHMB	2ww"r'!!$$Qr"uX...!!!BrE(++++$$Qr"uXddd^I%>???!!!BrE(44R4.";<<<!"ggDD BT\%&&1222$)EFF+,,, ~m44N:..	x);;;)A,,Qgdk**B8#QRRi$/// 	 &+D#U+++++rv   c                    | j         dk    r>|                                 }|                     |j        |j        ff|j        |          S |                     | j                  \  }}| j        }t          j        t          |          | j        j
                  }t          || j        |           |                     ||f          }|                     | j        |f| j        || j
                  S )Nr   r?   r5   r<   )r]   r   rT   rG   rF   r9   rL   rP   r   rS   r6   r   rE   )r`   r=   r   	major_dim	minor_dimminor_indicesmajor_indicesr   s           ri   r   z_cs_matrix.tocoo  s    9>>**,,C&&3;.'A39SW&XXX#zz$*55	9]!3!34<;MNNN)T[-888]M:;;""Y$dj # 
 
 	
rv   c                    |||                      d          d         }|                     ||          }|j        j        s|j        j        st          d          |j        j        r|                                 }|}n|                                 }|j        }|                     |j	                  \  }}t          |||j        |j        |j        |           |S )Ncfr   z&Output array must be C or F contiguous)rL   _process_toarray_argsr   r   f_contiguousrX   r   r   r   rM   r   rE   rF   rG   )r`   r   r   r   r   rb   rc   s          ri   r   z_cs_matrix.toarray  s    ;5=JJt$$Q'E((44	& 	G#)*@ 	GEFFF9! 	

AAA

AAwwq~&&1Aq!(AIqvq999
rv   c                     |                      | j                  \  }}t          ||| j        | j        | j                   |                                  dS )z\Remove zero entries from the array/matrix

        This is an *in place* operation.
        N)rL   rM   r   rE   rF   rG   r   r`   rb   rc   s      ri   r   z_cs_matrix.eliminate_zeros  sI    
 zz$+,,1Aq$+t|TYGGG

rv   returnc                     t          | dd          sd| _        nTt          | d          sDt          | j                  dz
  }t          t          || j        | j                            | _        | j        S )aZ  Whether the array/matrix has sorted indices and no duplicates

        Returns
            - True: if the above applies
            - False: otherwise

        has_canonical_format implies has_sorted_indices, so if the latter flag
        is False, so will the former be; if the former is found True, the
        latter flag is also set.
        _has_sorted_indicesTF_has_canonical_formatr   )	r   r~  r   rS   rE   boolr   rF   has_canonical_formatr`   rb   s     ri   r  z_cs_matrix.has_canonical_format  s{     t2D99 	).D&&677 	DK  1$A(,(DKFF) )D% ))rv   r  c                 D    t          |          | _        |r	d| _        d S d S )NT)r  r~  r[  r`   r  s     ri   r  z_cs_matrix.has_canonical_format  s0    %)#YY" 	+&*D###	+ 	+rv   c                     | j         rdS |                                  |                     | j                  \  }}t	          ||| j        | j        | j                   |                                  d| _         dS )zfEliminate duplicate entries by adding them together

        This is an *in place* operation.
        NT)	r  ra  rL   rM   r   rE   rF   rG   r   rz  s      ri   rV   z_cs_matrix.sum_duplicates  su    
 $ 	Fzz$+,,11adlDIFFF

$(!!!rv   c                     t          | d          sDt          | j                  dz
  }t          t	          || j        | j                            | _        | j        S )zWhether the indices are sorted

        Returns
            - True: if the indices of the array/matrix are in sorted order
            - False: otherwise
        r}  r   )r   rS   rE   r  r   rF   r}  r  s     ri   r[  z_cs_matrix.has_sorted_indices-  s[     t233 	DK  1$A'+&q$+t|DD( (D$ ''rv   c                 .    t          |          | _        d S r  )r  r}  r  s     ri   r[  z_cs_matrix.has_sorted_indices=  s    #'99   rv   c                 V    |                                  }|                                 |S )z?Return a copy of this array/matrix with sorted indices
        )r=   ra  )r`   As     ri   sorted_indicesz_cs_matrix.sorted_indicesB  s&     IIKK	rv   c                     | j         sAt          | j                  dz
  }t          || j        | j        | j                   d| _         dS dS )z9Sort the indices of this array/matrix *in place*
        r   TN)r[  rS   rE   r   rF   rG   r  s     ri   ra  z_cs_matrix.sort_indicesM  sU     & 	+DK  1$AQT\49EEE&*D###	+ 	+rv   c                    |                      | j                  d         }t          | j                  |dz   k    rt	          d          t          | j                  | j        k     rt	          d          t          | j                  | j        k     rt	          d          t          | j        d| j                           | _        t          | j        d| j                           | _        dS )z8Remove empty space after all non-zero elements.
        r   r   z index pointer has invalid lengthz)indices array has fewer than nnz elementsz&data array has fewer than nnz elementsN)	rL   rM   rS   rE   rX   rF   r   rG   r   )r`   rq  s     ri   r   z_cs_matrix.pruneU  s     JJt011!4	t{y1},,?@@@t|tx''HIIIty>>DH$$EFFF#DL$($;<< 9DH9!566			rv   c                    t          || j                  }t          | d          r{| j        \  }}t	          |d         |          \  }}t	          |d         |          \  }}|s|rt          d| j         d|           | j        d         |z  | j        d         |z  }	}nR|                     t          |          dk    r|n	d|d         f          \  }}|                     | j	                  \  }}	||k     rV| j
        d | j        |                  | _
        | j        d | j        |                  | _        | j        d |dz            | _        nX||k    rRt          j        | j        |dz             | _        | j        |dz   d                              | j        |                    ||	k     r| j
        |k     }
t          j        |
          s| j
        |
         | _
        | j        |
         | _        |                     t          j        |
          \  }}| j                            d           || j        dd          |<   t          j        | j        | j                   || _        d S )Nr0   r   r   r   zshape must be divisible into z blocks. Got r  )r(   rK   r   r   divmodrX   r9   rL   rS   rM   rF   rE   rG   rP   resizefillr   r   r   r  rH   )r`   r9   bmbnnew_Mrmnew_Nrnrb   rc   r   r   r  s                ri   r  z_cs_matrix.resized  sV   EDN;;;4%% 
	1^FBuQx,,IE2uQx,,IE2 :R :  "9 "9 "916"9 "9 : : ::a=B&
1(;qAA::s5zz!||ee!U1XOOLE5::d/00DAq199<(;U);(;<DL	"54;u#5"56DI+juqyj1DKKQYY)DK;;DKKA$$T[^444199<%'D6$<< 8#|D1 IdO	#'#5#5bfd#C#C S  ###/2ABB,	$+4;7777rv   c                 
   |rS|                      || j                                        | j                                        f| j        |j                  S |                      || j        | j        f| j        |j                  S )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.
        r8   )rY   rF   r=   rE   r9   r6   )r`   rG   r=   s      ri   r   z_cs_matrix._with_data  s    
  	F>>4):):)<)<#';#3#3#5#5#7(,
(,
 " 4 4 4
 >>4t{"C(,
$* " F F Frv   c                    |                      |          }t          t          d|z   dz             }| j        |j        z   }|                     | j        | j        |j        |j        f|          }t          j        | j        j	        |          }t          j        ||          }g d}||v r!t          j        |t          j
                  }	n.t          j        |t          | j        |j                            }	|                     | j                  \  }
} ||
|t          j        | j        |          t          j        | j        |          | j        t          j        |j        |          t          j        |j        |          |j        |||	           |                      |	||f| j	                  }|                                 |S )z5apply the binary operation fn to two sparse matrices.r   r2   r5   )_ne__lt__gt__le__ge_r   )rY   r   r   r   rN   rE   rF   rP   r   r9   bool_r    r6   rL   rM   r[   rG   r   )r`   r   r   r   maxnnzrd   rE   rF   bool_opsrG   rb   rc   r  s                ri   r   z_cs_matrix._binopt  s   u%% \52:#566EI%))4;%*\5=+B+1 * 3 3	 $++9===(6333;;;>>8F"(333DD8F&U[*I*IJJJDzz$+,,1
1a:dk333:dl)4449:el)444:em9555:7D	" 	" 	" NND'62$*NEE				rv   c                 $   |j         | j         k    rt          d| j          d|j                    |                     |d          }t          j        |j        t          j                  rt          j        | j         | j                  }|                    t          j	                   |
                                }| j        dk    r	|d         f}d||<   |                                }|j        ||j        <   |                     |          S |}|S )z?
        Divide this matrix by a second sparse matrix.
        r   r   _eldiv_r5   r   rk   r   )r9   rX   r   rP   
issubdtyper6   inexactr   r  nannonzeror]   r   rG   r   r   )r`   r   r>  r   r   s        ri   _divide_sparsez_cs_matrix._divide_sparse  s     ;$*$$RDJRRU[RRSSSLL	**="*-- 	
 (4:TZ888CHHRV]]__FyA~~ *CK		AFCM??3''' CJrv   c                    | j         |k    r|r|                                 n| S t          || j                  }t	          | j         |          |k    rt          d          t          | j                   dk    rt          |          dk    r|                                  | j        dk    r| 	                    || j
        d          S |d         }t          j        || j        d                   }t          j        d|          }t          j        d|g          }|                     |||f|d          S | j        }t          |          dk    r"t          |          }t          d	| d
          | j        dk    r| 	                    || j
        d          S |                                  |                     |          \  }	}|                     |          \  }
}t'          d |D                       rqt          j        |	|z  | j        d                   }t          j        t          j        |          |	          }t          j        dt          |          dz   |          }n|
dk    rs||k    rmt          j        | j        |	          }t          j        | j        |	          }t          j        dt          |          dz   t          | j                            }ni|dk    rc|
|	k    r]t          j        | j        |          }t          j        t          j        |          t          | j                            }| j        |z  }| 	                    |||f|d          S )Nr0   zcannot be broadcastr   r   F)r6   r=   r   r7   z0CSR/CSC broadcast_to cannot have shape >2D. Got Dc              3   "   K   | ]
}|d k    V  dS r  ry   )r{   r   s     ri   	<genexpr>z+_cs_matrix._broadcast_to.<locals>.<genexpr>  s&      ))!qAv))))))rv   )r9   r=   r(   rK   r*   rX   rS   rV   r   rY   r6   rP   fullrG   r   rW   _csr_containerrM   rL   r   r   rF   r   rE   )r`   r9   r=   rc   rG   rF   rE   	old_shaper]   rb   r   r   s               ri   _broadcast_toz_cs_matrix._broadcast_to  s   :"&0499;;;D0ET^===DJ..%772333tz??aCJJ!OO!!!x1}}~~e4:E~JJJaA71dil++Di!nnGXq!f%%F&&gv'>eRW&XXX %	u::??u::DWPTWWWXXX8q==>>%tz>FFFzz%  1I&&B))y))))) 	%71q5$)A,//DgbillA..GYq#d))a-33FF1WWq749a((DgdlA..GYq#d))a-TY@@FF1WWq9TY**DgbillC	NN;;G[1_F~~tWf5U~OOOrv   )NNFr  )T)r   )NNNF)NN)6rZ   
__module____qualname____doc__rB   ru   r   rz   r_   r   r   r   r   r   r   r   r   r   r   r   r  r  r  r  r  r	  r  r
  r  r6  r9  r@  rG  rR  r4  r;  rF  r   r   r   propertyr  r  setterrV   r[  r  ra  r   r  r   r   r  r  ry   rv   ri   r,   r,      s>        V,T V, V, V, V, V,p3 3 3 3$ o-GO3 3 3 34 $19M7- 7- 7- 7-F  	3 	3 	3- - -. . .v v vx
7 
7 
7   ; ; ;z    '/HF F F F, +%CK" " " "4* * *< < <8 8 8H H H
; ; ;@&; &; &; &;P%; %; %;NE E E E < < < <*               2B= B= B=H  "%- %- %-N- - -(F, F, F,X
 
 
 
 M)EM   " o-GO   *d * * * X*,  + + + + ! +
) ) ) (D ( ( ( X( -d - - - -  + + +7 7 7! ! !F ^+FNF F F F! ! !F  80P 0P 0P 0P 0P 0Prv   r,   Fc                     ddl m}m} |r|n|}t          |           }t	          |          }t          j        |dz   |          }|dd         } || ||f||f          S )zbuild diagonal csc_array/csr_array => self._csr_container

    Parameter `data` should be a raveled numpy array holding the
    values on the diagonal of the resulting sparse matrix.
    r   )	csr_array
csr_matrixr2   r5   Nrk   r   )_csrr  r  rS   r)   rP   r   )rG   r   r  r  rc   rd   rE   rF   s           ri   r   r     s     ,+++++++%5		:ID		Aq)))IYq1uI...FSbSkG9dGV,QF;;;;rv   c                 j   | d|}}nt          | t                    r?|                     |          \  }}}|dk    rt          d          t	          ||          }nUt          |           r7| dk     r| |z  } | | dz   }}|dk     s||k    rt          d| d| d|           nt          d          ||fS )Nr   r   z$slicing with step != 1 not supportedzindex out of bounds: 0 <= z < z <= zexpected slice or scalar)rI   r  rF   rX   r   r%   rO  	TypeError)slnumr.  r/  strides        ri   r-  r-    s    	zCB	B		 4CBQ;;CDDDR[[	2 466#IBR!VB66R#XXN"NNNNNNOOO  2333r6Mrv   r  )6r  __all__warningsr   r   numpyrP   scipy._lib._utilr   r   _baser   r   r	   r
   _datar   r    r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   _indexr   _sputilsr    r!   r"   r#   r$   r%   r&   r'   r(   r)   r*   r,   r   r-  ry   rv   ri   <module>r     sz   D D
               9 9 9 9 9 9 9 9 F F F F F F F F F F F F . . . . . . . .      : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : :      V V V V V V V V V V V V V V V V V V V V V V V V V V
rP rP rP rP rP}j rP rP rPj'< < < <"    rv   