
    tKg-                         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 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*  G d deee      Z+ddZ,d Z-y)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)
IndexMixin)upcastupcast_char	to_nativeisdenseisshapegetdtypeisscalarlike	isintlikedowncast_intp_indexget_sum_dtypecheck_shapeis_pydata_spmatrixc                      e Zd ZdZd@dZdAdZej
                  j                  e_        dBdZd Zd Z	d Z
d	 Zd
 Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd ZdCdZej.                  j                  e_        d Zd Zej2                  j                  e_        d Zej4                  j                  e_        dDdZej6                  j                  e_        dAdZd Zd Zd Zd Z d Z!d  Z"dEd!Z#d" Z$dEd#Z%d@d$Z&d% Z'd& Z(d' Z)d( Z*d) Z+d* Z,d+ Z-d, Z.d- Z/d. Z0dBd/Z1ejb                  j                  e1_        dFd0Z2ejd                  j                  e2_        d1 Z3e4d2e5fd3       Z6e6jn                  d4e5fd5       Z6d6 Z8e4d2e5fd7       Z9e9jn                  d4e5fd8       Z9d9 Z:d: Z;d; Z<d< Z=ejz                  j                  e=_        dBd=Z>d> Z?d? Z@y)G
_cs_matrixzY
    base array/matrix class for compressed row- and column-oriented arrays/matrices
    Nc                    t        j                  | |       t        | t              }t	        |      r|j
                  | j
                  k(  r|r|j                         }n|j                  | j
                        }|j                  |j                  |j                  |j                  f\  | _        | _	        | _
        | _        nt        |t              rt        ||      rt        ||      | _        | j                  | j                         \  }}| j#                  t%        | j&                              }t)        j*                  dt-        |t.                    | _
        t)        j*                  d|      | _	        t)        j*                  |dz   |      | _        nt1        |      dk(  r\| j3                  |||      }	|	j5                  | j                        }
|
\  | _        | _	        | _
        | _        | j7                          nht1        |      d	k(  r|\  }}}d }|d|vrt%        |      }| j#                  ||f|d
      }|st8        }t)        j:                  |||      | _	        t)        j:                  |||      | _        t)        j:                  |||      | _
        nt=        d| j>                  j@                   d|       	 t)        jB                  |      }t        | t              r7|jF                  dk  r(| j
                  dk(  rt=        d|jF                   d      | j3                  ||      }	|	j5                  | j                        }
|
\  | _        | _	        | _
        | _        |t        ||      | _        ne| j&                  Y	 t1        | j                        dz
  }| j                  j%                         dz   }t        | j                  ||f      |      | _        |"| j                  jI                  |d      | _
        | jK                  d       y # tD        $ r+}t=        d| j>                  j@                   d|       |d }~ww xY w# tD        $ r}t=        d      |d }~ww xY w)Nallow_1dmaxvalr   )defaultr   dtype   shaper,      T)r)   check_contentscopyr,   zunrecognized z constructor input: csczCSC arrays don't support zD input. Use 2Dz!unable to infer matrix dimensionsFr3   
full_check)&r   __init__
isinstancer	   r   formatr3   asformatindptrindicesdata_shapetupler   r!   _swap_shape_as_2d_get_index_dtypemaxr/   npzerosr   floatlen_coo_container_coo_to_compressedsum_duplicatesr   array
ValueError	__class____name__asarray	Exceptionndimastypecheck_format)selfarg1r/   r,   r3   is_arrayMN	idx_dtypecooarraysr>   r=   r<   r)   emajor_dminor_ds                     \/home/alanp/www/video.onchill/myenv/lib/python3.12/site-packages/scipy/sparse/_compressed.pyr8   z_cs_matrix.__init__   s   dD)dG,D>{{dkk)dyy{}}T[[1T\\499dkkA=DKty$+ e$th/ *$Bzz$"3"341 !11TZZ1I	HHQ(FG	!xx95 hhq1uI>t9>--d%u-MC 33DJJ?FHNEDKty$+'')Y!^.2+T7F "F(Qe^!$U $ 5 5w6G7=?C !6 !EI  -#%88G$i#PDL"$((6I"NDK "D FDI$}T^^5L5L4M N;;?&&B C C
Fzz$' $(TYY]t{{e?S /		{/J  %%d%%8C++DJJ7F@F=DKty$+ %eh?DKZZMdkk*Q.,,**,q0 &djj'71C&DxXDK		((U(;DIU+7  F =1H1H0I J77;f"> ?DEFF&  M !DE1LMs0   P 5Q 	Q'&QQ	Q/Q**Q/c                    |t        | j                  d         S | j                  dk(  r'|dv rt        | j                  d         S t        d      |dk  r|dz  }| j	                  |d|z
  f      \  }}| j	                  | j
                        \  }}|dk(  r*t        j                  t        | j                        |      S |dk(  rt        j                  | j                        S t        d      )Nr   )r   rb   zaxis out of boundsr   r-   )	minlength)intr<   rR   rM   rA   r/   rE   bincountr   r=   diff)rU   axis_rY   s       r`   _getnnzz_cs_matrix._getnnzr   s    <t{{2''YY!^w4;;r?++122ax	jj$D!12GD!::djj)DAqqy{{#6t||#D-.0 0wwt{{++122    c                 :   | j                   j                  j                  dk7  r/t        d| j                   j                  j                   dd       | j
                  j                  j                  dk7  r/t        d| j
                  j                  j                   dd       | j                  j                  | j
                  j                  | j                   j                  fD ]  }|dk7  s	t        d       | j                  | j                        \  }}t        | j                         |dz   k7  r't        d	t        | j                          d
|dz          | j                   d   dk7  rt        d      t        | j
                        t        | j                        k7  rt        d      | j                   d   t        | j
                        kD  rt        d      | j                          |r+| j                  dkD  r| j
                  j                         |k\  rt        d|       | j
                  j                         dk  rt        d      t!        j"                  | j                         j                         dk  rt        d      | j%                  | j                   | j
                  f      }t!        j&                  | j                   |      | _         t!        j&                  | j
                  |      | _        t)        | j                        | _        yy)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`.
        iz$indptr array has non-integer dtype ()r0   
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 sizerb   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 sequencer+   N)r<   r,   kindr   namer=   r>   rR   rM   rA   rB   rH   prunennzrD   minrE   rf   rC   rP   r   )rU   r7   xrX   rY   rZ   s         r`   rT   z_cs_matrix.check_format   s|    ;;!!S(78I8I8N8N7OqQ<<""c)89K9K9P9P8QQRS ))..$,,"3"3T[[5E5EFAAv !JKK G
 zz$++,1A%23t{{3C2DKPQTUPUwWXXKKNa@AA TYY/IJJKKOc$,,// A B B 	

xx!|<<##%*$'9!%=>><<##%)$%;<<774;;'++-1$%OPP--t{{DLL.IJI**T[[	BDK::dll)DDL!$)),DI rj   c                     | j                          | j                   || j                  |      d      }|j                          |S )zScalar version of self._binopt, for cases in which no new nonzeros
        are added. Produces a new sparse array in canonical form.
        Tr5   )rK   
_with_datar>   eliminate_zeros)rU   otheropress       r`   _scalar_binoptz_cs_matrix._scalar_binopt   s>     	oobE2o>
rj   c                    t        |      rt        j                  |      r+| j                  | j                  t        j
                        S |dk(  rut        dt        d       | j                  t        j                  | j                  t        j
                              }| j                  |t        j                        }||z
  S | j                  |t        j                        S t        |      r| j                         |k(  S t        |      rt         S t#        |      rt        dt        d       | j                  |j                  k7  ry| j$                  |j$                  k7  r|j'                  | j$                        }| j)                  |d      }| j                  t        j                  | j                  t        j
                              }||z
  S t         S )	Nr+   r   zOComparing a sparse matrix with 0 using == is inefficient, try using != instead.r0   rn   zHComparing sparse matrices using == is inefficient, try using != instead.F_ne_)r   rE   isnanrN   r/   bool_r   r
   onesr|   operatorneeqr   todenser"   NotImplementedr   r:   r;   _binopt)rU   ry   all_trueinvr{   s        r`   __eq__z_cs_matrix.__eq__   s\   xx~~djj~AAz /0G !#  >>"''$**BHH*MN))%=#~%**5(++>>U^<<>U**&!!e_  !8QH zzU[[(,t{{3,,uf-C~~bggdjj&IJHc>!!!rj   c                 \   t        |      rt        j                  |      rRt        dt        d       | j                  t        j                  | j                  t        j                              }|S |dk7  rut        dt        d       | j                  t        j                  | j                        t        j                        }| j                  |t        j                        }||z
  S | j                  |t        j                        S t        |      r| j                         |k7  S t        |      rt         S t#        |      r`| j                  |j                  k7  ry| j$                  |j$                  k7  r|j'                  | j$                        }| j)                  |d      S t         S )	Nz:Comparing a sparse matrix with nan using != is inefficientr0   rn   r+   r   z^Comparing a sparse matrix with a nonzero scalar using != is inefficient, try using == instead.Tr~   )r   rE   r   r   r
   rN   r   r/   r   r|   r   r   r   r   r   r"   r   r   r:   r;   r   )rU   ry   r   r   s       r`   __ne__z_cs_matrix.__ne__   s<   xx $%<L>>"''$**BHH*MN! >,<  >>"''$***=RXX>N))%=#~%**5(++>>U^<<>U**&!!e_zzU[[(,t{{3<<v..!!rj   c                    t        |      rd|k(  r|dv rt        d       |d|      rzt        |t        d       t	        j
                  | j                  t	        j                  |            }|j                  |       | j                  |      }| j                  ||      S | j                  ||      S t        |      r || j                         |      S t        |      r| j                  |j                  k7  rt        d      | j                   |j                   k7  r|j#                  | j                         }|dvr| j                  ||      S t        d	t        d       | j                  t	        j$                  | j                  t        j&                              }| j                  ||d
k(  rdnd      }||z
  S t(        S )Nr   )_le__ge_z >= and <= don't work with 0.r0   rn   r+   inconsistent shapes)r   r   zUComparing sparse matrices using >= and <= is inefficient, using <, >, or !=, instead.r   _gt__lt_)r   NotImplementedErrorr   r
   rE   emptyr/   result_typefillrN   r   r|   r   r   r   rM   r:   r;   r   r   r   )rU   ry   rz   op_namebad_scalar_msg	other_arrr   r{   s           r`   _inequalityz_cs_matrix._inequality  sm   Ezg)99)*IJJAu^%<KHHTZZr~~e7LM	u% NN95	||Iw77**5"55U^dllne,,e_zzU[[( !677,t{{3..||E733 /(Q8 ~~bggdjj&IJH,,u60AfvNCc>!!!rj   c                 F    | j                  |t        j                  dd      S )Nr   zgComparing a sparse matrix with a scalar greater than zero using < is inefficient, try using >= instead.)r   r   ltrU   ry   s     r`   __lt__z_cs_matrix.__lt__<  $    x{{F!89 	9rj   c                 F    | j                  |t        j                  dd      S )Nr   zdComparing a sparse matrix with a scalar less than zero using > is inefficient, try using <= instead.)r   r   gtr   s     r`   __gt__z_cs_matrix.__gt__B  r   rj   c                 F    | j                  |t        j                  dd      S )Nr   zgComparing a sparse matrix with a scalar greater than zero using <= is inefficient, try using > instead.)r   r   ler   s     r`   __le__z_cs_matrix.__le__H  $    x{{F!78 	8rj   c                 F    | j                  |t        j                  dd      S )Nr   zdComparing a sparse matrix with a scalar less than zero using >= is inefficient, try using < instead.)r   r   ger   s     r`   __ge__z_cs_matrix.__ge__N  r   rj   c                 H   |j                   | j                   k7  r&t        d| j                    d|j                    d      t        | j                  j                  |j                  j                        }| j                  d      d   }t        j                  |||d      }|j                  j                  r|n|j                  }| j                  | j                        \  }}t        ||| j                  | j                  | j                  |       | j!                  |d	      S )
NzIncompatible shapes (z and rm   CFr   T)r,   orderr3   Fr5   )r/   rM   r   r,   charrA   rE   rL   flagsc_contiguousTrB   r   r<   r=   r>   
_container)rU   ry   r,   r   resultyrX   rY   s           r`   
_add_densez_cs_matrix._add_denseX  s    ;;$**$4TZZLekk]RSTUUDJJOOU[[-=-=>

4 #%uEEll//FVXXzz$++,1Aq$++t||TYYBvE22rj   c                 &    | j                  |d      S )N_plus_r   r   s     r`   _add_sparsez_cs_matrix._add_sparsec  s    ||E8,,rj   c                 &    | j                  |d      S )N_minus_r   r   s     r`   _sub_sparsez_cs_matrix._sub_sparsef  s    ||E9--rj   c                    t        |      r| j                  |      S t        |      r| j                  |j                  k(  r#| j	                  |      }| j                  |d      S |j                  dk(  rS| j                  |j                         d         }| j                  dk(  r |j                  d| j                  d   f      S |S |j                  dk(  r"| j                  |j                         d         S | j                  dv r)|j                  | j                  j                               S | j                  \  }}|j                  \  }}|dk(  r4|dk(  r/|j                  | j                  ||      j                               S |dk(  r4|dk(  r/| j                  |j                  ||      j                               S t        | t              }|dk(  rb||k(  r]t!        |j                         j#                         |      }| j                  |      }| j                  dk(  r|S |j                  d|f      S |dk(  r>||k(  r9t!        | j                         j#                         |      }	|j                  |	      S |dk(  r>||k(  r9t!        |j                         j#                         |      }|j                  |       S |dk(  r>||k(  r9t!        | j                         j#                         |      }
|
j                  |      S t%        d	      t'        j(                  |      }|j                  dkD  r$t'        j*                  | j                         |      S |j,                  dk(  rz|j.                  t&        j0                  k(  rt2        S t'        j4                  | j                  |j                        }| j                  |j6                  d         j                  |      S | j                  dv rgt'        j4                  | j                  |j                        }t'        j*                  | j                  j                         |      j                  |      S | j9                         }| j                  |j                  k(  rat'        j*                  |j                  ||j:                           }|j=                  t&        j>                        j#                         |_	        |S t'        j@                  |      }| j                  d   dk(  s| j                  dk(  r[|j                  d   dk(  r!t'        j*                  |j                  |      }n\|j                  d   | j                  d
   k(  r2t'        j*                  |j                  |dd|jB                  f         }nt%        d	      t'        jD                  t'        jF                  |j                  d         |jH                        }t'        jJ                  |jB                  |j                  d         }| jM                  |j=                  t&        j>                        j#                         ||ff|j                  d   | j                  d
   fd      S | j                  d   dk(  rn|j                  d   dk(  r(t'        j*                  |j                  dddf   |      }n_|j                  d   | j                  d   k(  r5t'        j*                  |j                  dddf   ||jN                           }nt%        d	      t'        jD                  |jN                  |j                  d         }t'        jJ                  t'        jF                  |j                  d         tQ        |jB                              }| jM                  |j=                  t&        j>                        j#                         ||ff| j                  d   |j                  d   fd      S |j                  d   dk(  r_| j                  d   |j                  d   k(  r@t'        j*                  |j                  |dd|jB                  f   j#                               }nx|j                  d   dk(  r[| j                  d   |j                  d   k(  r<t'        j*                  |j                  ||jN                     j#                               }nt%        d	      |j=                  t&        j>                        j#                         |_	        |S )z=Point-wise multiplication by array/matrix, vector, or scalar._elmul_r   r   )r   r   r   r   r   )r   r   r-   r   rb   NFr/   r3   ))r   _mul_scalarr   r/   rN   r   toarrayrR   reshaper>   sumrB   _matmul_sparsetocscr9   r	   _make_diagonal_csrravelrM   rE   
asanyarraymultiplysizer,   object_r   broadcast_shapesflattocoocoordsviewndarray
atleast_2dcolrepeatarangers   tilerI   rowrH   )rU   ry   r   sMsNoMoNrW   	new_otherr3   new_selfbshaperetr>   other2dr   r   s                    r`   r   z_cs_matrix.multiplyi  s    ##E**E?zzU[[(u-||E955{{f$))%--/$*?@99>!>>1djjm*<=={{d"''(:;;zz^+((99 &&FB''FBQw27++DLLR,@,F,F,HIIQw27**5==R+@+F+F+HII!$0HQw28.u}}/D/D/FQ	,,Y7!%avLV^^QG5LLQw28)$,,.*>*>*@(K++D11 Qw28.u}}/D/D/FQ	 //55Qw28-dlln.B.B.DhO..u55233 e$::>;;t||~u55::?{{bjj(%%((U[[AF##EJJqM2::6BB::'((U[[AF;;tyy}}6>>vFFjjl::$;;sxxszz):;Dyy,224CHJ --&::a=Aa}}Q1${{388W5q!TZZ^3{{388WQZ-@A !677))BIIgmmA&67AC''#''7==#34C&&2::&,,.c
;}}Q'B8 '   ::a=A}}Q1${{388AtG#4g>q!TZZ]2{{388AtG#4gcgg6FG !677))CGGW]]1%56C''"))GMM!$45s377|DC&&2::&,,.c
;zz!}gmmA&67 '   ==q TZZ]gmmA6F%F;;sxxCGG)<)B)B)DED]]1"tzz!}a8H'H;;sxx)9)?)?)ABD23399RZZ(..0
rj   c           	      p   | j                   \  }}t        j                  |t        | j                  j
                  |j                  j
                              }t        t        | j                  dz         } |||| j                  | j                  | j                  ||       | j                  dk(  r|d   S |S )Nr+   _matvecr   r   )rB   rE   rF   r   r,   r   getattrr   r:   r<   r=   r>   rR   )rU   ry   rX   rY   r   fns         r`   _matmul_vectorz_cs_matrix._matmul_vector  s      1 !;tzz@P@P#QR \4;;#:;
1adllDIIufE IINvay66rj   c                    | j                   \  }}|j                  d   }t        j                  ||ft	        | j
                  j                  |j
                  j                              }t        t        | j                  dz         } ||||| j                  | j                  | j                  |j                         |j                                | j                  dk(  r|j                  |f      S |S )Nrb   r+   _matvecsr   )rB   r/   rE   rF   r   r,   r   r   r   r:   r<   r=   r>   r   rR   r   )rU   ry   rX   rY   n_vecsr   r   s          r`   _matmul_multivectorz_cs_matrix._matmul_multivector  s      1R1f+ +DJJOOU[[=M=M NP \4;;#;<
1adllDII;;=&,,.	* 99>>>6),,rj   c                    | j                   \  }}|j                  }|dk(  r*|j                  d|j                  d   f      j                  }|j
                  \  }}d}| j                  dk(  r||fz  }|dk(  r||fz  }| j                  ||f      d   }| j                  |      }| j                  | j                  | j                  |j                  |j                  f      }	t        t        | j                  dz         }
 |
||t        j                  | j                  |	      t        j                  | j                  |	      t        j                  |j                  |	      t        j                  |j                  |	            }|dk(  rk|dk(  r5t        j                   dt#        | j$                  |j$                              S | j                  |t#        | j$                  |j$                              S | j                  | j                  | j                  |j                  |j                  f|      }	t        j&                  |dz   |	      }t        j&                  ||	      }t        j&                  |t#        | j$                  |j$                              }t        t        | j                  dz         }
 |
||t        j                  | j                  |	      t        j                  | j                  |	      | j(                  t        j                  |j                  |	      t        j                  |j                  |	      |j(                  |||       |dk(  rt        j                   |d         S | j                  |||f|	      S )
Nr   r    r-   _matmat_maxnnzr+   r(   _matmatr/   )rB   rR   r   r/   r   r?   rA   rN   rC   r<   r=   r   r   r:   rE   rP   rL   r   r,   r   r>   )rU   ry   rX   K1o_ndimK2rY   	new_shape	major_dimrZ   r   rs   r<   r=   r>   s                  r`   r   z_cs_matrix._matmul_sparse   s   !!2Q;MM1ekk!n"5688EA 	99>!IQ;!IJJ1v&q)	u%))4;;%*\\5==+B C	 \4;;1A#ABADKKy9DLL	:ELL	:EMM;	=
 !8Bxx

EKK)HII>>)6$**ekk3R>SS))4;;%*\\5==+B+. * 0	 )a-y9((3i0xx6$**ekk#BC\4;;#:;
1aDKKy9::dll)499::ell)4::emm95::7D	" ?88DG$$~~tWf5Y~GGrj   c           
         | j                   \  }}|| k  s||k\  r+t        j                  d| j                  j                        S t        t        | j                  dz         }t        j                  t        |t        |d      z   |t        |d      z
        t        | j                              } ||| j                   d   | j                   d   | j                  | j                  | j                  |       |S )Nr   r+   	_diagonalr   )r/   rE   r   r>   r,   r   r   r:   rt   rD   r   r<   r=   )rU   krowscolsr   r   s         r`   diagonalz_cs_matrix.diagonal6  s    ZZ
d:d88ATYY__55\4;;#<=HHSAq	)4#a)+;<!$**-/
1djjmTZZ]DKK99a	rj   c                    t        |      r ||      rt        dt        d       t        j                  | j
                  t        j                  |      j                        }|j                  |       | j                  |      }| j                  ||      S | j                           || j                  t        j                  |            }| j                  || j                  | j                  f|j                  | j
                        }|S t        |      r || j!                         |      S t#        |      r| j                  ||      S t%        d      )NzITaking maximum (minimum) with > 0 (< 0) number results to a dense matrix.r0   rn   r+   )r,   r/   zOperands not compatible.)r   r   r
   rE   r   r/   rP   r,   r   rN   r   rK   r>   r=   r<   r   r   r   rM   )rU   ry   npopr   dense_checkr   new_datamats           r`   _maximum_minimumz_cs_matrix._maximum_minimumG  s   5! +,C !# HHTZZrzz%7H7N7NO	u% NN95	||Iw77##%		2::e+<=nnhdkk%J+3>> % M
U^..e_<<w//788rj   c                 H    | j                  |t        j                  dd       S )N	_maximum_c                 2    t        j                  |       dkD  S Nr   rE   rP   ru   s    r`   <lambda>z$_cs_matrix.maximum.<locals>.<lambda>`      BJJqMA<Mrj   )r   rE   maximumr   s     r`   r	  z_cs_matrix.maximum^  %    $$UBJJ%02MO 	Orj   c                 H    | j                  |t        j                  dd       S )N	_minimum_c                 2    t        j                  |       dk  S r  r  r  s    r`   r  z$_cs_matrix.minimum.<locals>.<lambda>f  r  rj   )r   rE   minimumr   s     r`   r  z_cs_matrix.minimumd  r
  rj   c                 &   | j                   dk(  rt        | d      s|| j                  d      d   v rt        | j                        }t        j                  t        | j                        dz
  |      }| j                  t
        j                        \  }}|||<   | j                  |      }|dz  dk(  r|j                  }|$|j                  |j                  k7  rt        d      |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.
        r-   	blocksize))r   rb   )r   r   r   r+   zdimensions do not matchr   )rg   r,   out)rR   hasattrrA   r    r,   rE   rF   rH   r<   _minor_reduceadd_ascontainerr   r/   rM   r   r   )rU   rg   r,   r  	res_dtyper   major_indexvalues           r`   r   z_cs_matrix.sumn  s     IIN74#=

#56q99%djj1I((3t{{+a/yAC!%!3!3BFF!;K$C##C(Cax1}ee399		#9 !:;;77%S799 ;;t$eEErj   c                     || j                   }t        j                  t        j                  | 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
        )r>   rE   flatnonzerorf   r<   reduceatr   )rU   ufuncr>   r  r  s        r`   r  z_cs_matrix._minor_reduce  sZ     <99DnnRWWT[[%9:t24;;{3KLNE!!rj   c                     d|cxk  r| j                   d   k  rhn net        j                  | j                  |k(        }|j                  r| j
                  |d      S | j
                  j                  j                  d      S t        d| d      )Nr   zindex (z) out of range)	r/   rE   r  r=   r   r>   r,   type
IndexError)rU   idxspots      r`   _get_intz_cs_matrix._get_int  su    $tzz!}$>>$,,#"56Dyyyya))99??''**73%~677rj   c                    | j                  | j                        \  }}| j                  ||f      \  }}t        ||| j                  | j                  | j
                  ||dz   ||dz   	      \  }}}	|	j                  | j                        S )Nr   r+   )rA   r/   r   r<   r=   r>   r   r,   )
rU   r   r   rX   rY   majorminorr<   r=   r>   s
             r`   _get_intXintz_cs_matrix._get_intXint  s~    zz$**%1zz3*-u 1q$++t||TYY519eUQY!0 xxdjjx))rj   c                     | j                  ||f      \  }}|j                  dv r"|j                  dv r| j                  ||d      S | j                  |      j	                  |      S )N)r   NTr5   )rA   step_get_submatrix_major_slice_minor_slicerU   r   r   r%  r&  s        r`   _get_sliceXslicez_cs_matrix._get_sliceXslice  sc    zz3*-u::"uzzY'>&&ue$&??  '44U;;rj   c                    | j                   j                  }| j                  | j                        \  }}| j                  ||f      \  }}t	        j
                  ||      }t	        j
                  ||      }t	        j                  |j                  | j                        }t        ||| j                  | j                   | j                  |j                  |j                         |j                         |	       |j                  dk(  r| j                  |      S | j                  |j                  |j                              S )Nr+   r   )r=   r,   rA   r/   rE   rP   r   r   r   r<   r>   r   rR   r  rN   r   )	rU   r   r   rZ   rX   rY   r%  r&  vals	            r`   _get_arrayXarrayz_cs_matrix._get_arrayXarray  s    LL&&	zz$**%1zz3*-u

5	2

5	2hhuzz4!QT\\499**ekkmU[[]C	I::?$$S))~~ckk%++677rj   c                 n    | j                  ||f      \  }}| j                  |      j                  |      S N)rA   _major_index_fancy_minor_index_fancyr-  s        r`   _get_columnXarrayz_cs_matrix._get_columnXarray  s4    zz3*-u&&u-@@GGrj   c           	         | j                  | j                  | j                  f      }t        j                  ||      j                         }| j                  | j                        d   }t        |      }| j                  dk(  r| j                  ||f      n|f}|dk(  r| j                  || j                        S | j                  |dz      | j                  |   z
  j                  |      }t        j                  |dz   |      }t        j                  ||dd        |d   }	t        j                  |	|      }
t        j                  |	| j                        }t!        ||| j                  j                  |d	      | j                  j                  |d	      | j"                  |
|       | j                  ||
|f|d
      S )zBIndex along the major axis where idx is an array of ints.
        r+   r   r-   r   Nr  rb   Fr5   r   )rC   r<   r=   rE   rP   r   rA   rB   rH   rR   rN   r,   rS   rF   cumsumr   r   r>   )rU   r!  rZ   r=   rY   rX   r   row_nnz
res_indptrrs   res_indicesres_datas               r`   r4  z_cs_matrix._major_index_fancy  s    ))4;;*EF	**S	288:JJt(()!,L*.))q.DJJ1v&qd	6>>)4::>>>;;w{+dkk'.BBJJ9UXXac3

		'z!"~.nhhs)488Ctzz2KKyu5LL	6II	
 ~~xjA$-E  ; 	;rj   c           
      h   |t        d      k(  r|r| j                         S | S | j                  | j                        \  }}|j	                  |      \  }}}t        t        |||            }| j                  dk(  r| j                  ||f      n|f}|dk(  r| j                  || 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(  rot        | j                  |   | j                  |         }t        j                  | j                  |   |      }t        j                  | j                  |   |      }nm|d   }t        j                   ||      }t        j                   || j                        }t#        |||| j                  | j                  | j                  ||       | j                  |||f|d	
      S )z@Index along the major axis where idx is a slice object.
        Nr-   r   r+   rb   r   r8  r5   Fr   )slicer3   rA   rB   r=   rH   rangerR   rN   r,   r<   rE   rF   r9  rL   r>   r   r   )rU   r!  r3   rX   rY   startstopr)  r   start0stop0start1stop1r:  rZ   r;  all_idxr<  r=  rs   s                       r`   r+  z_cs_matrix._major_slice  s    %+"&499;0D0zz$++,1KKNtTeT4()*.))q.DJJ1v&qd	6>>)4::>>> t2:%1*E	4!8++fU4/0KKuT)*+LL&&	XXac3

		'z!"~.19DKK.D0ABG((4<<#8tDKxx		' 2>HR.C((3i8Kxx4::6H%tT[[$,,))[(< ~~xjA$-E  ; 	;rj   c           
         | j                  | j                  | j                  f      }| j                  j                  |d      }| j                  j                  |d      }t	        j
                  ||      j                         }| j                  | j                        \  }}t        |      }| j                  dk(  r| j                  ||f      n|f}|dk(  r| j                  || j                        S t	        j                  ||      }	t	        j                  | j                  |      }
t        |||||||	|
       t	        j                   |      j                  |d      }|
d   }t	        j"                  ||      }t	        j"                  || j                        }t%        ||	t        | j                        || j&                  ||       | j                  |||
f|d      S )zBIndex along the minor axis where idx is an array of ints.
        Fr5   r+   r-   r   rb   r   )rC   r=   r<   rS   rE   rP   r   rA   rB   rH   rR   rN   r,   rF   
empty_liker   argsortr   r   r>   )rU   r!  rZ   r=   r<   rX   rY   r   r   col_offsetsr;  	col_orderrs   r<  r=  s                  r`   r5  z_cs_matrix._minor_index_fancy4  s    ))4<<*EF	,,%%ie%<##IE#:jjI.446zz$++,1H*.))q.DJJ1v&qd	6>>)4::>>> hhq	2]]4;;i@
		
 JJsO**95*A	nhhs)488Ctzz2)[#dll2C!499k8	E~~xjA$-E  ; 	;rj   c                    |t        d      k(  r|r| j                         S | S | j                  | j                        \  }}|j	                  |      \  }}}t        t        |||            }|dk(  r.| j                  | j                  ||f      | j                        S |dk(  r| j                  ||      S | j                  t        j                  |||            S )z@Index along the minor axis where idx is a slice object.
        Nr   r+   r   )r&  r3   )r?  r3   rA   rB   r=   rH   r@  rN   r,   r*  r5  rE   r   )rU   r!  r3   rX   rY   rA  rB  r)  s           r`   r,  z_cs_matrix._minor_slice[  s     %+"&499;0D0zz$++,1KKNtTeT4()6>>$**aV"4DJJ>GG19&&St&<<&&ryyd'CDDrj   c                    | j                  | j                        \  }}t        ||      \  }}t        ||      \  }}	|dk(  r#|dk(  r||k(  r|	|k(  r|r| j                         S | S t	        ||| j
                  | j                  | j                  ||||		      \  }
}}| j                  ||z
  |	|z
  f      }| j                  dk(  r|d   f}| j                  |||
f|| j                  d      S )zbReturn a submatrix of this matrix.

        major, minor: None, int, or slice with step 1
        r   r   F)r/   r,   r3   )rA   rB   _process_slicer3   r   r<   r=   r>   rR   rN   r,   )rU   r%  r&  r3   rX   rY   i0i1j0j1r<   r=   r>   r/   s                 r`   r*  z_cs_matrix._get_submatrixk  s    
 zz$++,1q)Bq)B7rQw27rQw"&499;0D0 1q$++t||TYYBB!H 

BGR"W-.99>1XKE~~tWf5U$(JJU  < 	<rj   c                 V    | j                  d|f      \  }}| j                  |||       y r  rA   	_set_many)rU   r!  ru   r%  r&  s        r`   _set_intz_cs_matrix._set_int  s(    zz1c(+uueQ'rj   c                 &   | j                  t        j                  |      |f      \  }}|j                  d   dk(  xr |j                  d   dk7  }|r-t        j                  |j
                  |j                  d         }| j                  |||       y )Nrb   r   )rA   rE   
zeros_liker/   r   r>   rV  )rU   r!  ru   r%  r&  	broadcasts         r`   
_set_arrayz_cs_matrix._set_array  su    zz2==#5s";<uGGBK1$=RA)=			!&&#))B-0AueQ'rj   c                 V    | j                  ||f      \  }}| j                  |||       y r3  rU  rU   r   r   ru   rl   js         r`   _set_intXintz_cs_matrix._set_intXint  (    zz3*%1q!Qrj   c                 V    | j                  ||f      \  }}| j                  |||       y r3  rU  r]  s         r`   _set_arrayXarrayz_cs_matrix._set_arrayXarray  r`  rj   c                 R    | j                   | j                  ||f        |j                  \  }}|dk7  xr |j                  d   dk(  }|dk7  xr |j                  d   dk(  }|j                  |j                  }	}t        j                  |j                  | j                        }|j                  dk(  ry |r^t        j                  t        j                  |      t        |            }t        j                  |	|      }	t        j                  ||      }|r^t        j                  ||      }t        j                  t        j                  |      t        |	            }	t        j                  ||      }| j                  |||	f   |||	f   f      \  }
}| j                  |
||       y )Nr   r   r+   )
_zero_manyrA   r/   r   r   rE   rP   r>   r,   r   r   r   rH   r   rV  )rU   r   r   ru   rX   rY   broadcast_rowbroadcast_colrcrl   r^  s               r`   _set_arrayXarray_sparsez"_cs_matrix._set_arrayXarray_sparse  sF   S#J/0yy1Q21771:?Q21771:?uuaee1JJqvvTZZ066Q;		"))A,A/A1A1A		!QA		!c!f-A		!QAzz3q!t9c!Q$i011q!Qrj   c           
      4   d| j                   v ry | 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                         j                   |j                         j                   k7  r t        j                  |	|j                         }	|	j                  dk(  ry | j                  ||f      \  }}| j                  ||f      \  }}|	j                  }
t        j                   |
| j                  j                        }t#        ||| j$                  | j                  |
|||      }|dk(  r6| j'                          t#        ||| j$                  | j                  |
|||       d|vr|	| j(                  |<   y |dk  }|j+                         | j,                  dz  k  r9||   }||   }| j/                  |||	|          | }|	|   | j(                  ||   <   y | j1                         }|j3                  ||       |j5                  | j                        }|\  | _        | _        | _        }y )Nr   r   z"diagonals cant be set in 1d arraysr+   rb   gMbP?)r/   rR   r   rt   rH   rE   r   r=   r,   
atleast_1drP   r   squeezebroadcast_tor   rA   r   r   r<   rK   r>   r   rs   _insert_manyr   _setdiagrJ   )rU   valuesr   rX   rY   rZ  	max_indexrl   r^  ru   	n_samplesoffsetsr   maskr[   r\   rh   s                    r`   ro  z_cs_matrix._setdiag  s   

?99>%&JKKzz1[[A%	q5AqM	Aq#f+6			1"i!m4<<3E3EFA		)4<<+=+=>A 1q5M	1q5#f+6			)4<<+=+=>A		!Q]$,,2D2DEAGSV_FMM"**V4::>?EEG99;		 1 11177+A66Q;zz1a&!1zz1a&!1FF	((9DLL,>,>? At{{DLL)!"Aw0!8!q!T[[$,,	 !W.W!"DIIg2 88:5(($A$AaAdG,5D'(wDIIgdm$ **,CLL#++DJJ7F6<3DKty!rj   c                    | j                  | j                        \  }}d }t        j                  t        j                  || j
                  j                              j                         }t        j                  t        j                  || j
                  j                              j                         } |||        |||       ||||fS )Nc                     | j                         }||k\  rt        d||fz        | j                         }|| k  rt        d||fz        y )Nzindex (%d) out of range (>= %d)zindex (%d) out of range (< -%d))rD   r   rt   )r=   boundr!  s      r`   check_boundsz1_cs_matrix._prepare_indices.<locals>.check_bounds  se    ++-Ce| !B"%u". / /++-CeV| !B"%u". / / rj   r+   )rA   rB   rE   rk  rP   r=   r,   r   )rU   rl   r^  rX   rY   rx  s         r`   _prepare_indicesz_cs_matrix._prepare_indices  s    zz$++,1	/ MM"**Qdll.@.@ABHHJMM"**Qdll.@.@ABHHJQQ!Qzrj   c           
         | j                  ||      \  }}}}t        j                  t        j                  || j                              j                         }|j                  }t        j                  || j                  j                        }t        ||| j                  | j                  ||||      }|dk(  r6| j                          t        ||| j                  | j                  ||||       d|vr|| j                  |<   yt        d| j                  j                   dt         d       |dkD  }	||	   | j                  ||	   <   |	 }	||	   }||d	k  xx   |z  cc<   ||	   }||d	k  xx   |z  cc<   | j#                  ||||	          y)
zSets value at each (i, j) to x

        Here (i,j) index major and minor respectively, and must not contain
        duplicate entries.
        r+   r   rb   Nz%Changing the sparsity structure of a z. is expensive. lil and dok are more efficient.r0   rn   r   )ry  rE   rk  rP   r,   r   r   r   r=   r   r<   rK   r>   r   rN   rO   r
   rn  )
rU   rl   r^  ru   rX   rY   rr  rs  r   rt  s
             r`   rV  z_cs_matrix._set_many  sw    **1a0
1aMM"**Qdjj9:@@BFF	((9DLL,>,>? At{{DLL)!"Aw0!8!q!T[[$,,	 !W. W!"DIIg 89P9P8Q R? ?(Q8 R<D'(wDIIgdm$5D$Aa!eHMH$Aa!eHMHaAdG,rj   c           
         | j                  ||      \  }}}}t        |      }t        j                  || j                  j
                        }t        ||| j                  | j                  ||||      }|dk(  r6| j                          t        ||| j                  | j                  ||||       d| j                  ||dkD     <   y)zSets value at each (i, j) to zero, preserving sparsity structure.

        Here (i,j) index major and minor respectively.
        r+   r   r   rb   N)
ry  rH   rE   r   r=   r,   r   r<   rK   r>   )rU   rl   r^  rX   rY   rr  rs  r   s           r`   rd  z_cs_matrix._zero_many*  s    
 **1a0
1aF	((9DLL,>,>? At{{DLL)!"Aw0!8!q!T[[$,,	 !W. ,-		''B,'(rj   c           	         t        j                  |d      }|j                  |d      }|j                  |d      }|j                  |d      }| j                  }| 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 ]  \  }\  }}}| j                  |   }| j                  |   }|j                  | j
                  ||        |j                  | j                  ||        t        j                  ||| ddd   d	      \  }}t        |      ||z
  k(  r)|j                  |||        |j                  |||        nH|j                  ||| ddd   |          |j                  ||| ddd   |          t        |      ||<   |} | j                     }|j                  | j
                  |d        |j                  | 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| _        | j)                          | j+                  d       y)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)rp   clip)moderb   r(   r+   T)return_indexr   r   Nr8  Fr6   )rE   rJ  takehas_sorted_indicesrC   r=   r<   r   rP   uniqueappendrH   rf   	enumeratezipr>   concatenater   r/   r9  sort_indicesrT   )rU   rl   r^  ru   r   do_sortrZ   indices_parts
data_partsui	ui_indptrnew_nnzsprevrh  iijsjerA  rB  uj	uj_indptrnnzsindptr_diffs                          r`   rn  z_cs_matrix._insert_many>  s8    

1;/FF5vF&FF5vF&FF5vF&)) ))4<<*E,0KKOaff,D * G	jjI>zz$,,i@JJq	*JJq	* 
		!$7IIIiQ0	779%(RIabM)JKOA|BKK%E;;r?D  eD!9:diid34 IIa2httn4HMB	2w"r'!$$Qr"X.!!!Br(+$$Qr"Xdd^I%>?!!!Br(4R4.";<!"gD#  L( BT\\%&12$))EF+, ~~m4NN:.	xx));A,Qggdkk*B8#QRii$/&+D#U+rj   c                 8   | j                   dk(  rE| j                         }| j                  |j                  |j                  ff|j
                  |      S | j                  | j
                        \  }}| j                  }t        j                  t        |      | j                  j                        }t        j                  || j                  |       | j                  ||f      }| j                  | j                  |f| j
                  || j                        S )Nr   r5   r+   r2   )rR   tocsrrI   r>   r=   r/   rA   rE   r   rH   r,   r   	expandptrr<   )rU   r3   csrr   	minor_dimminor_indicesmajor_indicesr   s           r`   r   z_cs_matrix.tocoo  s    99>**,C&&3;;.'A399SW&XX#zz$**5	9]!34<<;M;MNy$++}E]M:;""YY$djj # 
 	
rj   c                    ||| j                  d      d   }| j                  ||      }|j                  j                  s!|j                  j                  st        d      |j                  j                  r| j                         }|}n| j                         }|j                  }|j                  |j                        \  }}t        |||j                  |j                  |j                  |       |S )Ncfr   z&Output array must be C or F contiguous)rA   _process_toarray_argsr   r   f_contiguousrM   r  r   r   rB   r   r<   r=   r>   )rU   r   r  ru   r   rX   rY   s          r`   r   z_cs_matrix.toarray  s    ;5=JJt$Q'E((4		&&#))*@*@EFF99!!

AA

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

        This is an *in place* operation.
        N)rA   rB   r   csr_eliminate_zerosr<   r=   r>   rr   rU   rX   rY   s      r`   rx   z_cs_matrix.eliminate_zeros  sG    
 zz$++,1((At{{DLL$))T

rj   returnc                    t        | dd      sd| _        | j                  S t        | d      sOt        t	        j
                  t        | j                        dz
  | 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  boolr   csr_has_canonical_formatrH   r<   r=   has_canonical_formatrU   s    r`   r  z_cs_matrix.has_canonical_format  s{     t2D9).D& ))) 67(,55$q($++t||E)D% )))rj   r0  c                 8    t        |      | _        |rd| _        y y )NT)r  r  r  rU   r0  s     r`   r  z_cs_matrix.has_canonical_format  s    %)#Y"&*D# rj   c                    | j                   ry| j                          | j                  | j                        \  }}t	        j
                  ||| j                  | j                  | j                         | j                          d| _         y)zfEliminate duplicate entries by adding them together

        This is an *in place* operation.
        NT)
r  r  rA   rB   r   csr_sum_duplicatesr<   r=   r>   rr   r  s      r`   rK   z_cs_matrix.sum_duplicates  sg    
 $$zz$++,1''1dkk4<<S

$(!rj   c                     t        | d      sOt        t        j                  t	        | j
                        dz
  | 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  r  r   csr_has_sorted_indicesrH   r<   r=   r  r  s    r`   r  z_cs_matrix.has_sorted_indices  sV     t23'+33$q($++t||E(D$ '''rj   c                 $    t        |      | _        y r3  )r  r  r  s     r`   r  z_cs_matrix.has_sorted_indices  s    #'9 rj   c                 F    | j                         }|j                          |S )z?Return a copy of this array/matrix with sorted indices
        )r3   r  )rU   As     r`   sorted_indicesz_cs_matrix.sorted_indices  s     IIK	rj   c                     | j                   sTt        j                  t        | j                        dz
  | j                  | j
                  | j                         d| _         yy)z9Sort the indices of this array/matrix *in place*
        r   TN)r  r   csr_sort_indicesrH   r<   r=   r>   r  s    r`   r  z_cs_matrix.sort_indices  sL     &&))#dkk*:Q*>*.,,		C&*D# 'rj   c                    | j                  | j                        d   }t        | j                        |dz   k7  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                         | _        y)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)	rA   rB   rH   r<   rM   r=   rs   r>   r   )rU   r   s     r`   rr   z_cs_matrix.prune  s     JJt001!4	t{{y1},?@@t||txx'HIItyy>DHH$EFF#DLL$(($;< 9DHH!56	rj   c                    t        |t        | t                    }t        | d      rw| j                  \  }}t        |d   |      \  }}t        |d   |      \  }}|s|rt        d| j                   d|       | j                  d   |z  | j                  d   |z  }	}nG| j                  t        |      dkD  r|nd|d   f      \  }}| j                  | j                        \  }}	||k  rZ| j                  d | j                  |    | _        | j                  d | j                  |    | _        | j                  d |dz    | _        n[||kD  rVt        j                  | j                  |dz         | _        | j                  |dz   d  j!                  | j                  |          ||	k  r| j                  |k  }
t        j"                  |
      s| j                  |
   | _        | j                  |
   | _        | j%                  t        j&                  |
      \  }}| j                  j!                  d       || j                  dd  |<   t        j(                  | j                  | j                         || _        y )Nr&   r  r   r   zshape must be divisible into z blocks. Got r8  )r!   r9   r	   r  r  divmodrM   r/   rA   rH   rB   r=   r<   r>   rE   resizer   allr  r  r9  r?   )rU   r/   bmbnnew_Mrmnew_NrnrX   rY   rt  r  r0  s                r`   r  z_cs_matrix.resize  s   EJtW,EF4%^^FBuQx,IE2uQx,IE2R #@@P#0"9 : :::a=B&

1(;qA::s5z!|e!U1XOLE5::d//0DAq19<<(;U);<DL		"54;;u#56DI++juqy1DKQY))DKK;DKKKA$$T[[^419<<%'D66$<#||D1 IIdO	#'#5#5bffd#C S  #/2AB,		$++4;;7rj   c                 :   |r[| j                  || j                  j                         | j                  j                         f| j                  |j
                        S | j                  || 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.
        r.   )rN   r=   r3   r<   r/   r,   )rU   r>   r3   s      r`   rw   z_cs_matrix._with_dataH  s    
 >>4):):)<#';;#3#3#5#7(,

(,

 " 4 4
 >>4t{{"C(,

$** " F Frj   c                 8   | j                  |      }t        t        | j                  |z   | j                  z         }| j                  |j                  z   }| j                  | j                  | j                  |j                  |j                  f|      }t        j                  | j                  j                  |      }t        j                  ||      }g d}||v r&t        j                  |t        j                        }	n5t        j                  |t        | j                  |j                              }	| j                  \  }
} ||
|t        j                  | j                  |      t        j                  | j                  |      | j                   t        j                  |j                  |      t        j                  |j                  |      |j                   |||	       | j                  |	||f| j                        }|j#                          |S )z5apply the binary operation fn to two sparse matrices.r(   r+   )r~   r   r   r   r   r   )rN   r   r   r:   rs   rC   r<   r=   rE   r   r/   r   r   r,   rB   rP   r>   rr   )rU   ry   rz   r   maxnnzrZ   r<   r=   bool_opsr>   rX   rY   r  s                r`   r   z_cs_matrix._binoptV  s   u% \4;;#3dkk#ABEII%))4;;%*\\5==+B+1 * 3	 $++++9=((63;>88F"((3D88F&U[[*IJD  1
1a::dkk3::dll)499::ell)4::emm95::7D	" NND'62$**NE		rj   c                 .   |j                   | j                   k7  rt        d      | j                  |d      }t        j                  |j
                  t        j                        rt        j                  | j                   | j
                        }|j                  t        j                         |j                         }| j                  dk(  r|d   f}d||<   |j                         }|j                  ||j                  <   | j                  |      S |}|S )z?
        Divide this matrix by a second sparse matrix.
        r   _eldiv_r+   r   rb   r   )r/   rM   r   rE   
issubdtyper,   inexactr   r   nannonzerorR   r   r>   r   r   )rU   ry   rg  r  r   s        r`   _divide_sparsez_cs_matrix._divide_sparsey  s     ;;$**$233LL	*=="**-
 ((4::TZZ8CHHRVV]]_FyyA~ *CK	AFFCM??3'' CJrj   )NNFr3  )T)r   )NNNF)NN)ArO   
__module____qualname____doc__r8   ri   r   rT   r|   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r	  r  r   r  r#  r'  r.  r1  r6  r4  r+  r5  r,  r*  rW  r[  r_  rb  ri  ro  ry  rV  rd  rn  r   r   rx   propertyr  r  setterrK   r  r  r  rr   r  rw   r   r  r   rj   r`   r$   r$      sH   U,n3& oo--GO7-F""H "D!"F9988	3-.uv
7 4Hl	 ''//H9.O oo--GOO oo--GOF4 ++%%CK"48J*<8H
;B&;P%;NE <*((   2B=H&%-N-(F,X
 MM))EM" oo--GO *d * *,   + + !+
) (D ( ( -d - -+7!F ^^++FNF!Frj   r$   c                     ddl m}m} |r|n|}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_matrixNrb   r   )_csrr  r  rH   rE   r   )r>   rW   r  r  rY   r<   r=   s          r`   r   r     sN     ,%	:ID	AYYq1uFSbkGdGV,QF;;rj   c                 2   | d|}}||fS t        | t              r5| j                  |      \  }}}|dk7  rt        d      t	        ||      }||fS t        |       r3| dk  r| |z  } | | dz   }}|dk  s||kD  rt        d| d| d|       ||fS t        d      )Nr   r   z$slicing with step != 1 not supportedzindex out of bounds: 0 <= z < z <= zexpected slice or scalar)r9   r?  r=   rM   rt   r   r   	TypeError)slnumrP  rQ  strides        r`   rO  rO    s    	zCB r6M 
B	CBQ;CDDR[ r6M 
26#IBR!VB6R#X9"SDNOO r6M 233rj   r  ).r  __all__warningsr   r   numpyrE   scipy._lib._utilr   r   _baser   r   r	   r
   _datar   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   rO  r   rj   r`   <module>r     sq    D
    9 F F . A A A G G G G
}}j }@,< rj   