
    _Mh                        d Z g ZddlmZ ddl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+m,Z,m-Z-  G d deee          Z.ddZ/d Z0d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)
IndexMixin)upcastupcast_char	to_nativeisdenseisshapegetdtypeisscalarlike	isintlikedowncast_intp_indexget_sum_dtypecheck_shapeget_index_dtypebroadcast_shapesis_pydata_spmatrixc                   .   e Zd ZdZdCdddZdDdZej        j        e_        dDdZej        j        e_        dEd	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dFdZej        j        e_        d Zd Zej        j        e_        d Zej        j        e_        dGdZej        j        e_        dDdZd  Zd! Zd" Z d# Z!d$ Z"dHd%Z#d& Z$dHd'Z%dCd(Z&d) Z'd* Z(d+ Z)d, Z*d- Z+d. Z,d/ Z-d0 Z.dEd1Z/ej/        j        e/_        dId2Z0ej0        j        e0_        d3 Z1e2d4e3fd5            Z4e4j5        d6e3fd7            Z4d8 Z6e2d4e3fd9            Z7e7j5        d6e3fd:            Z7d; Z8d< Z9d= Z:d> Z;ej;        j        e;_        dEd?Z<d@ Z=dA Z>dHdBZ?dS )J
_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   shaper0      T)r-   check_contentscopyr0   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r7   
full_check)'r   __init__r   formatr7   asformatindptrindicesdata_shape
isinstancetupler   	_allow_ndr!   _swap_shape_as_2d_get_index_dtypemaxr3   npzerosr   floatlen_coo_container_coo_to_compressedsum_duplicatesr   array
ValueError	__class____name__asarray	Exceptionr	   ndimastypecheck_format)selfarg1r3   r0   r7   r(   MN	idx_dtypecooarraysrA   r@   r?   r-   enewdtypes                    X/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/scipy/sparse/_compressed.pyr<   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   re   axis out of boundsr   r1   	minlength)intr?   rW   rR   rF   r3   rJ   bincountr   r@   diff)rZ   axis_r]   s       rc   _getnnzz_cs_matrix._getnnzu   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   rf   rg   r   r1   rh   c                 X    g | ]&\  }}t          j        j        ||                   'S  )rJ   count_nonzerorA   ).0ijrZ   s      rc   
<listcomp>z,_cs_matrix.count_nonzero.<locals>.<listcomp>   s2    PPP$!QR-di!n==PPPrp   )rP   rJ   rt   rA   rW   rR   rF   r3   allr@   rk   r   rl   r?   	itertoolspairwiserQ   )rZ   rm   rn   r]   maskidxpairss   `      rc   rt   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2rp   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`.
        rv   z$indptr array has non-integer dtype ()r4   
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 sizere   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?   r0   kindr   namer@   rA   rW   rR   rF   rG   rM   prunennzrI   minrJ   rl   rH   rU   r   )rZ   r;   xr\   r]   r^   s         rc   rY   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	- 	-rp   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.
        Tr9   )rP   
_with_datarA   eliminate_zeros)rZ   otheropress       rc   _scalar_binoptz_cs_matrix._scalar_binopt   sP     	oobbE22o>>
rp   c                    t          |          rt          j        |          r&|                     | j        t          j                  S |dk    rtt          dt          d           |                     t          j        | j        t          j                            }| 	                    |t          j                  }||z
  S | 	                    |t          j                  S t          |          r|                                 |k    S t          |          rt           S t#          |          rt          dt          d           | j        |j        k    rdS | j        |j        k    r|                    | j                  }|                     |d          }|                     t          j        | j        t          j                            }||z
  S t           S )	Nr/   r   zOComparing a sparse matrix with 0 using == is inefficient, try using != instead.r4   r   zHComparing sparse matrices using == is inefficient, try using != instead.F_ne_)r   rJ   isnanrS   r3   bool_r   r
   onesr   operatorneeqr   todenser$   NotImplementedr   r=   r>   _binopt)rZ   r   all_trueinvr   s        rc   __eq__z_cs_matrix.__eq__   s     	"x B~~dj~AAAzz /0G !# # # #  >>"'$*BH*M*M*MNN))%==#~%**5(+>>>U^^ 	"<<>>U**&& 	"!!e__ 	"  !8QH H H H zU[((u,,t{33,,uf--C~~bgdj&I&I&IJJHc>!!!rp   c                 h   t          |          rt          j        |          rQt          dt          d           |                     t          j        | j        t          j                            }|S |dk    rtt          dt          d           |                     t          j        | j                  t          j                  }| 	                    |t          j                  }||z
  S | 	                    |t          j                  S t          |          r|                                 |k    S t          |          rt           S t#          |          rR| j        |j        k    rdS | j        |j        k    r|                    | j                  }|                     |d          S t           S )	Nz:Comparing a sparse matrix with nan using != is inefficientr4   r   r/   r   z^Comparing a sparse matrix with a nonzero scalar using != is inefficient, try using == instead.Tr   )r   rJ   r   r   r
   rS   r   r3   r   r   r   r   r   r   r   r$   r   r   r=   r>   r   )rZ   r   r   r   s       rc   __ne__z_cs_matrix.__ne__  s    	"x ? $%<L L L L>>"'$*BH*M*M*MNN! >,< < < <  >>"'$**=*=RX>NN))%==#~%**5(+>>>U^^ 	"<<>>U**&& 	"!!e__ 	"zU[((t,,t{33<<v...!!rp   c                    t          |          rd|k    r|dv rt          d           |d|          rt          |t          d           t	          j        | j        t	          j        |                    }|                    |           | 	                    |          }| 
                    ||          S |                     ||          S t          |          r ||                                 |          S t          |          r| j        |j        k    rt          d          | j        |j        k    r|                    | j                  }|dvr| 
                    ||          S t          d	t          d           | 	                    t	          j        | j        t          j                            }| 
                    ||d
k    rdnd          }||z
  S t(          S )Nr   )_le__ge_z >= and <= don't work with 0.r4   r   r/   inconsistent shapes)r   r   zUComparing sparse matrices using >= and <= is inefficient, using <, >, or !=, instead.r   _gt__lt_)r   NotImplementedErrorr   r
   rJ   emptyr3   result_typefillrS   r   r   r   r   r   rR   r=   r>   r   r   r   )rZ   r   r   op_namebad_scalar_msg	other_arrr   r   s           rc   _inequalityz_cs_matrix._inequality7  s    	"Ezzg)999)*IJJJAu 6^%<KKKKHTZr~e7L7LMMM	u%%% NN955	||Iw777**5"555U^^ 	"2dllnne,,,e__ 	"zU[(( !6777,,t{33...||E7333 /(Q8 8 8 8 ~~bgdj&I&I&IJJH,,u60A0AffvNNCc>!!!rp   c                 F    |                      |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rZ   r   s     rc   __lt__z_cs_matrix.__lt__Z  '    x{F!89 9 	9rp   c                 F    |                      |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     rc   __gt__z_cs_matrix.__gt__`  r   rp   c                 F    |                      |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     rc   __le__z_cs_matrix.__le__f  '    x{F!78 8 	8rp   c                 F    |                      |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     rc   __ge__z_cs_matrix.__ge__l  r   rp   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 (z and r   CFr   T)r0   orderr7   Fr9   )r3   rR   r   r0   charrF   rJ   rQ   flagsc_contiguousTrG   r   r?   r@   rA   
_container)rZ   r   r0   r   resultyr\   r]   s           rc   
_add_densez_cs_matrix._add_densev  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2rp   c                 .    |                      |d          S )N_plus_r   r   s     rc   _add_sparsez_cs_matrix._add_sparse  s    ||E8,,,rp   c                 .    |                      |d          S )N_minus_r   r   s     rc   _sub_sparsez_cs_matrix._sub_sparse  s    ||E9---rp   c                 &   t          |          r|                     |          S t          |          rM| 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	          t'          j        |          }|j        dk    r't'          j        |                                 |          S |j        dk    ri|j        t&          j        k    rt2          S t5          | j        |j                  }|                     |j        d                                       |          S | j        dv rYt5          | 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	        |          }nU|j        d         | j        d
         k    r*t'          j        |j	        |dd|j!        f                   }nt%          d	          | "                    |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         |          }n[|j        d         | j        d         k    r0t'          j        |j	        dddf         ||j)                           }nt%          d	          | "                    |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                                                   }nt|j        d         dk    rT| j        d         |j        d         k    r8t'          j        |j	        ||j)                                                           }nt%          d	          |                    t&          j                                                  |_	        |S )z=Point-wise multiplication by array/matrix, vector, or scalar._elmul_r   r   )r   r   r   r   r   )r   r   r1   r   re   Nr,   r/   Fr9   r3   r7   )*r   _mul_scalarr   r3   rS   r   toarrayrW   reshaperA   sumrG   _matmul_sparsetocscrC   r	   _make_diagonal_csrravelrR   rJ   
asanyarraymultiplysizer0   object_r   r#   flattocoocoordsviewndarray
atleast_2dcolrH   r   repeatarangetilerX   rN   row)rZ   r   r   sMsNoMoNis_array	new_otherr7   new_selfbshaperetrA   other2dr^   r   r   s                     rc   r   z_cs_matrix.multiply  s$     	+##E***E?? +	4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2333 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 !6777--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 !6777--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233399RZ((..00
rp   c           	      *   | j         \  }}t          j        |t          | j        j        |j        j                            }t          t          | j        dz             } |||| j	        | j
        | j        ||           | j        dk    r|d         n|S )Nr/   _matvecr   r   )rG   rJ   rK   r   r0   r   getattrr   r=   r?   r@   rA   rW   )rZ   r   r\   r]   r   fns         rc   _matmul_vectorz_cs_matrix._matmul_vector  s     1 !;tz@P#Q#QRRR \4;#:;;
1adlDIufEEE INNvayy6rp   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 )Nre   r/   _matvecsr   )rG   r3   rJ   rK   r   r0   r   r   r   r=   r?   r@   rA   r   rW   r   )rZ   r   r\   r]   n_vecsr   r   s          rc   _matmul_multivectorz_cs_matrix._matmul_multivector  s     1R1f+ +DJOU[=M N NP P P \4;#;<<
1adlDI;;==&,,..	* 	* 	* 9>>>>6),,,rp   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}|                     ||f          d         }	|                     |          }|                     | j	        | j
        |j	        |j
        f          }
t          t          | j        dz             } |||t          j        | j	        |
          t          j        | j
        |
          t          j        |j	        |
          t          j        |j
        |
                    }|dk    rc|dk    r.t          j        dt#          | j        |j                            S |                     |t#          | j        |j                            S |                     | 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 |                     |||f|	          }||k    r4|j        d
k    r|                                }|                    |          }|S )Nr   r   r1   rs   _matmat_maxnnzr/   r,   _matmatr3   csr)rG   rW   r   r3   r   rB   rF   rS   rH   r?   r@   r   r   r=   rJ   rU   rQ   r   r0   r   rA   tocsr)rZ   r   r\   K1o_ndimK2r]   	new_shape
faux_shape	major_dimr^   r   r   r?   r@   rA   r   s                    rc   r   z_cs_matrix._matmul_sparse"  sr   !2Q;;MM1ek!n"5668E %
aek!na5HA 	9>>!IQ;;!I9>>aaqv{{!!J
JJ1v&&q)	u%%))4;%*\5=+B C C	 \4;1A#ABBbADKy999DL	:::EL	:::EM;;;	= =
 !88Bx
EK)H)HIIII>>)6$*ek3R3R>SSS))4;%*\5=+B+. * 0 0	 )a-y999(3i000x6$*ek#B#BCCC\4;#:;;
1aDKy999:dl)4449:el)444:em9555:7D	" 	" 	" ??8DG$$$nndGV4JnGG""zU""iikk++i((C
rp   r   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   )r3   rJ   r   rA   r0   r   r   r=   r   rI   r   r?   r@   )rZ   krowscolsr   r   s         rc   diagonalz_cs_matrix.diagonal^  s    Z
d::d8ATY_5555\4;#<==HSAq		)4#a))+;<<!$*--/ / /
1djmTZ]DK9a	 	 	rp   c                    t          |          r ||          rt          dt          d           t          j        | j        t          j        |          j                  }|                    |           | 	                    |          }| 
                    ||          S |                                   || j        t          j        |                    }| 	                    || j        | j        f|j        | j                  }|S t          |          r ||                                 |          S t#          |          r| 
                    ||          S t%          d          )NzITaking maximum (minimum) with > 0 (< 0) number results to a dense matrix.r4   r   r/   )r0   r3   zOperands not compatible.)r   r   r
   rJ   r   r3   rU   r0   r   rS   r   rP   rA   r@   r?   r   r   r   rR   )rZ   r   npopr   dense_checkr   new_datamats           rc   _maximum_minimumz_cs_matrix._maximum_minimumo  s_    	9{5!!  +,C !# # # # HTZrz%7H7H7NOOO	u%%% NN955	||Iw777##%%%4	2:e+<+<==nnhdk%J+3> % M M
U^^ 	94...e__ 	9<<w///7888rp   c                 H    |                      |t          j        dd           S )N	_maximum_c                 2    t          j        |           dk    S Nr   rJ   rU   r   s    rc   <lambda>z$_cs_matrix.maximum.<locals>.<lambda>      BJqMMA<M rp   )r  rJ   maximumr   s     rc   r  z_cs_matrix.maximum  ,    $$UBJ%02M2MO O 	Orp   c                 H    |                      |t          j        dd           S )N	_minimum_c                 2    t          j        |           dk     S r  r  r  s    rc   r  z$_cs_matrix.minimum.<locals>.<lambda>  r  rp   )r  rJ   minimumr   s     rc   r#  z_cs_matrix.minimum  r  rp   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.
        r1   	blocksize))r   re   )r   r   r   r/   rs   )rm   r0   out)rW   hasattrrF   r    r0   rJ   rK   rM   r?   _minor_reduceadd_ascontainerr   r   r   )rZ   rm   r0   r'  	res_dtyper   major_indexvalues           rc   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Erp   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
        )rA   rJ   flatnonzerorl   r?   reduceatr   )rZ   ufuncrA   r-  r.  s        rc   r)  z_cs_matrix._minor_reduce  s_     <9DnRWT[%9%9::t24;{3KLLN NE!!rp   c                    |                      | j                  \  }}|                      ||f          \  }}t          ||| j        | j        | j        ||dz   ||dz   	  	        \  }}}	|	                    | j                  S )Nr   r/   )rF   r3   r   r?   r@   rA   r   r0   )
rZ   r   r   r\   r]   majorminorr?   r@   rA   s
             rc   _get_intXintz_cs_matrix._get_intXint  s    zz$*%%1zz3*--u 1q$+t|TY519eUQY!0 !0 xxdjx)))rp   c                     |                      ||f          \  }}|j        dv r!|j        dv r|                     ||d          S |                     |                              |          S )Nr   NTr9   )rF   step_get_submatrix_major_slice_minor_slicerZ   r   r   r4  r5  s        rc   _get_sliceXslicez_cs_matrix._get_sliceXslice  sq    zz3*--u:""uzY'>'>&&ue$&???  ''44U;;;rp   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 )Nr/   r   )r@   r0   rF   r3   rJ   rU   r   r   r   r?   rA   r   rW   r+  rS   r   )	rZ   r   r   r^   r\   r]   r4  r5  vals	            rc   _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7rp   c                     |                      ||f          \  }}|                     |                              |          S N)rF   _major_index_fancy_minor_index_fancyr=  s        rc   _get_columnXarrayz_cs_matrix._get_columnXarray  s=    zz3*--u&&u--@@GGGrp   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.
        r/   r   r1   r   Nr'  re   Fr9   r   )rH   r?   r@   rJ   rU   r   rF   rG   rM   rW   rS   r0   rX   rK   cumsumr   r   rA   )rZ   r}   r^   r@   r]   r\   r  row_nnz
res_indptrr   res_indicesres_datas               rc   rD  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  ; ; 	;rp   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.
        Nr1   r   r/   re   r   rH  r9   Fr   )slicer7   rF   rG   r@   rM   rangerW   rS   r0   r?   rJ   rK   rI  rQ   rA   r   r   )rZ   r}   r7   r\   r]   startstopr9  r  start0stop0start1stop1rJ  r^   rK  all_idxrL  rM  r   s                       rc   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  ; ; 	;rp   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.
        Fr9   r/   r1   r   re   r   )rH   r@   r?   rX   rJ   rU   r   rF   rG   rM   rW   rS   r0   rK   
empty_liker   argsortr   r   rA   )rZ   r}   r^   r@   r?   r\   r]   r  r  col_offsetsrK  	col_orderr   rL  rM  s                  rc   rE  z_cs_matrix._minor_index_fancy3  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  ; ; 	;rp   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   r/   r   )r5  r7   )rO  r7   rF   rG   r@   rM   rP  rS   r0   r:  rE  rJ   r   )rZ   r}   r7   r\   r]   rQ  rR  r9  s           rc   r<  z_cs_matrix._minor_sliceZ  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Drp   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)r3   r0   r7   )rF   rG   _process_slicer7   r   r?   r@   rA   rW   rS   r0   )rZ   r4  r5  r7   r\   r]   i0i1j0j1r?   r@   rA   r3   s                 rc   r:  z_cs_matrix._get_submatrixj  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  < < 	<rp   c                 h    |                      ||f          \  }}|                     |||           d S rC  rF   	_set_manyrZ   r   r   r   rv   rw   s         rc   _set_intXintz_cs_matrix._set_intXint  7    zz3*%%1q!Qrp   c                 h    |                      ||f          \  }}|                     |||           d S rC  re  rg  s         rc   _set_arrayXarrayz_cs_matrix._set_arrayXarray  ri  rp   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   r/   )
_zero_manyrF   r3   r   r   rJ   rU   rA   r0   r   r   r   rM   r   rf  )rZ   r   r   r   r\   r]   broadcast_rowbroadcast_colrcrv   rw   s               rc   _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rp   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 arraysr/   re   gMbP?)r3   rW   r   r   rM   rJ   r   r@   r0   
atleast_1drU   r   squeezebroadcast_tor   rF   r   r   r?   rP   rA   r   r   _insert_manyr   _setdiagrO   )rZ   valuesr  r\   r]   	broadcast	max_indexrv   rw   r   	n_samplesoffsetsr   r|   r_   r`   rn   s                    rc   rx  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!!!rp   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 (< -)rI   
IndexErrorr   )r@   boundr}   s      rc   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 |rp   r/   )rF   rG   rJ   rt  rU   r@   r0   r   )rZ   rv   rw   r\   r]   r  s         rc   _prepare_indicesz_cs_matrix._prepare_indices  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rp   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.
        r/   r   re   Nz%Changing the sparsity structure of a z. is expensive. lil and dok are more efficient.r4   r   r   )r  rJ   rt  rU   r0   r   r   r   r@   r   r?   rP   rA   r   rS   rT   r
   rw  )
rZ   rv   rw   r   r\   r]   r|  r}  r   r|   s
             rc   rf  z_cs_matrix._set_many  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,,,,,rp   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.
        r/   r   r   re   N)
r  rM   rJ   r   r@   r0   r   r?   rP   rA   )rZ   rv   rw   r\   r]   r|  r}  r   s           rc   rm  z_cs_matrix._zero_many  s    
 **1a00
1aFF	(9DL,>??? At{DL)!"Aw0 0!88!!!q!T[$,	 !W. . . ,-	''B,'(((rp   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)modere   r,   r/   T)return_indexr   r   NrH  Fr:   )rJ   rZ  takehas_sorted_indicesrH   r@   r?   r   rU   uniqueappendrM   rl   	enumerateziprA   concatenater   r3   rI  sort_indicesrY   )rZ   rv   rw   r   r   do_sortr^   indices_parts
data_partsui	ui_indptrnew_nnzsprevrq  iijsjerQ  rR  uj	uj_indptrnnzsindptr_diffs                          rc   rw  z_cs_matrix._insert_many0  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+++++rp   c                    | j         dk    r>|                                 }|                     |j        |j        ff|j        |          S |                     | j                  \  }}| j        }t          j        t          |          | j        j
                  }t          j        || j        |           |                     ||f          }|                     | j        |f| j        || j
                  S )Nr   r9   r/   r6   )rW   r  rN   rA   r@   r3   rF   rJ   r   rM   r0   r   	expandptrr?   )rZ   r7   r  r	  	minor_dimminor_indicesmajor_indicesr   s           rc   r   z_cs_matrix.tocoo|  s    9>>**,,C&&3;.'A39SW&XXX#zz$*55	9]!3!34<;MNNNy$+}EEE]M:;;""Y$dj # 
 
 	
rp   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)rF   _process_toarray_argsr   r   f_contiguousrR   r  r   r   rG   r   r?   r@   rA   )rZ   r   r'  r   r   r\   r]   s          rc   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
rp   c                     |                      | j                  \  }}t          j        ||| j        | j        | j                   |                                  dS )z\Remove zero entries from the array/matrix

        This is an *in place* operation.
        N)rF   rG   r   csr_eliminate_zerosr?   r@   rA   r   rZ   r\   r]   s      rc   r   z_cs_matrix.eliminate_zeros  sL    
 zz$+,,1(At{DL$)TTT

rp   returnc                     t          | dd          sd| _        nWt          | d          sGt          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_formatrM   r?   r@   has_canonical_formatrZ   s    rc   r  z_cs_matrix.has_canonical_format  s     t2D99 	).D&&677 	(,5$$q($+t|E E) )D% ))rp   r@  c                 D    t          |          | _        |r	d| _        d S d S )NT)r  r  r  rZ   r@  s     rc   r  z_cs_matrix.has_canonical_format  s0    %)#YY" 	+&*D###	+ 	+rp   c                     | j         rdS |                                  |                     | j                  \  }}t	          j        ||| j        | j        | j                   | 	                                 d| _         dS )zfEliminate duplicate entries by adding them together

        This is an *in place* operation.
        NT)
r  r  rF   rG   r   csr_sum_duplicatesr?   r@   rA   r   r  s      rc   rP   z_cs_matrix.sum_duplicates  sx    
 $ 	Fzz$+,,1'1dk4<SSS

$(!!!rp   c                     t          | d          sGt          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_indicesrM   r?   r@   r  r  s    rc   r  z_cs_matrix.has_sorted_indices  s`     t233 	'+3$$q($+t|E E( (D$ ''rp   c                 .    t          |          | _        d S rC  )r  r  r  s     rc   r  z_cs_matrix.has_sorted_indices  s    #'99   rp   c                 V    |                                  }|                                 |S )z?Return a copy of this array/matrix with sorted indices
        )r7   r  )rZ   As     rc   sorted_indicesz_cs_matrix.sorted_indices  s&     IIKK	rp   c                     | j         sDt          j        t          | j                  dz
  | j        | j        | j                   d| _         dS dS )z9Sort the indices of this array/matrix *in place*
        r   TN)r  r   csr_sort_indicesrM   r?   r@   rA   r  s    rc   r  z_cs_matrix.sort_indices  s]     & 	+)#dk*:*:Q*>*.,	C C C&*D###	+ 	+rp   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)	rF   rG   rM   r?   rR   r@   r   rA   r   )rZ   r	  s     rc   r   z_cs_matrix.prune  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			rp   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 )Nr*   r%  r   r   zshape must be divisible into z blocks. Got rH  )r!   rE   r(  r%  divmodrR   r3   rF   rM   rG   r@   r?   rA   rJ   resizer   ry   r)  r*  rI  rB   )rZ   r3   bmbnnew_Mrmnew_Nrnr\   r]   r|   r-  r@  s                rc   r  z_cs_matrix.resize  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rp   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.
        r2   )rS   r@   r7   r?   r3   r0   )rZ   rA   r7   s      rc   r   z_cs_matrix._with_data:  s    
  	F>>4):):)<)<#';#3#3#5#5#7(,
(,
 " 4 4 4
 >>4t{"C(,
$* " F F Frp   c                    |                      |          }t          t          | j        |z   | j        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,   r/   )r   r   r   r   r   r  )rS   r   r   r=   r   rH   r?   r@   rJ   r   r3   r   r   r0   rG   rU   rA   r   )rZ   r   r   r   maxnnzr^   r?   r@   bool_opsrA   r\   r]   r  s                rc   r   z_cs_matrix._binoptH  s   u%% \4;#3dk#ABBEI%))4;%*\5=+B+1 * 3 3	 $++9===(6333;;;>>8F"(333DD8F&U[*I*IJJJD 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				rp   c                    |j         | j         k    rt          d          |                     |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   _eldiv_r/   r   re   r   )r3   rR   r   rJ   
issubdtyper0   inexactr   r   nannonzerorW   r   rA   r   r   )rZ   r   rp  r'  r   s        rc   _divide_sparsez_cs_matrix._divide_sparsek  s     ;$*$$2333LL	**="*-- 	
 (4:TZ888CHHRV]]__FyA~~ *CK		AFCM??3''' CJrp   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 )Nr*   zcannot be broadcastr   r   F)r0   r7   r   r1   z0CSR/CSC broadcast_to cannot have shape >2D. Got Dc              3   "   K   | ]
}|d k    V  dS r8  rs   )ru   ss     rc   	<genexpr>z+_cs_matrix._broadcast_to.<locals>.<genexpr>  s&      ))!qAv))))))rp   )r3   r7   r!   rE   r#   rR   rM   rP   r   rS   r0   rJ   fullrA   r   rQ   _csr_containerrG   rF   ry   r   r@   r   r?   )rZ   r3   r7   r]   rA   r@   r?   	old_shaperW   r\   r   r   s               rc   _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Orp   )NNFrC  )T)r   )NNNF)NN)@rT   
__module____qualname____doc__r<   ro   r   rt   rY   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r  r#  r   r)  r6  r>  rA  rF  rD  r;  rE  r<  r:  rh  rk  rr  rx  r  rf  rm  rw  r   r   r   propertyr  r  setterrP   r  r  r  r   r  r   r   r  r  rs   rp   rc   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  "" "" ""H "  "  "D!" !" !"F9 9 99 9 98 8 88 8 8	3 	3 	3- - -. . .y y y~
7 
7 
7   : : :x	 	 	 	 '/H9 9 9.O O O o-GOO O O o-GO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rp   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_matrixr,   r/   Nre   r  )_csrr  r  rM   r"   rJ   r   )rA   r   r  r  r]   r^   r?   r@   s           rc   r   r     s     ,+++++++%5		:ID		Aq)))IYq1uI...FSbSkG9dGV,QF;;;;rp   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)rC   rO  r@   rR   r   r   r  	TypeError)slnumr`  ra  strides        rc   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r6Mrp   r  )1r  __all__warningsr   rz   r   numpyrJ   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$   r&   r   r_  rs   rp   rc   <module>r     sA   D D
                9 9 9 9 9 9 9 9 F F F F F F F F F F F F . . . . . . . .      A A A A A A A A A A A A A A A A A A A A      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +_P _P _P _P _P}j _P _P _PD-< < < <"    rp   