3

6^                 @   s$  d Z ddlmZmZm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 ddlmZmZmZ dd	lmZmZ dd
l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/m0Z0m1Z1m2Z2m3Z3m4Z4 G dd deee%Z5dd Z6dS )z>Base class for sparse matrix formats using compressed storage.    )divisionprint_functionabsolute_import)warnN)zipxrange)_prune_array   )spmatrix
isspmatrixSparseEfficiencyWarning)_data_matrix_minmax_mixin)
dia_matrix)_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get_index_dtypedowncast_intp_indexget_sum_dtypecheck_shapematrixasmatrixc               @   sZ  e Zd ZdZdyddZdzddZejje_d{dd	Zd|ddZdd Z	dd Z
dd Zdd Zdd Zdd Zdd Zdd Zdd Zdd  Zd!d" Zd#d$ Zd%d& Zd'd( Zd)d* Zd}d,d-Zejje_d.d/ Zd0d1 Zejje_d2d3 Zejje_d~d4d5Zejje_dd6d7Zd8d9 Zd:d; Zd<d= Z d>d? Z!d@dA Z"ddBdCZ#dDdE Z$ddFdGZ%ddHdIZ&dJdK Z'dLdM Z(dNdO Z)dPdQ Z*dRdS Z+dTdU Z,dVdW Z-dXdY Z.ddZd[Z/ej/je/_dd\d]Z0ej0je0_d^d_ Z1d`da Z2dbdc Z3e4e2e3ddZ5dedf Z6dgdh Z7didj Z8e4e7e8ddZ9dkdl Z:dmdn Z;dodp Z<dqdr Z=ej=je=_ddsdtZ>dudv Z?dwdx Z@dS )
_cs_matrixzAbase matrix class for compressed row and column oriented matricesNFc             C   s  t j|  t|rF|j| jkr,|r,|j }n|j| j}| j| nt|trt	|rt
|| _| j\}}tt||d}tjdt|td| _tjd|| _tj| j||fd d |d| _nt|dkrddlm} | j|||d}	| j|	 nt|d	krt|\}
}}d }|d k	r*t|}t||f|d
d}tj|||d| _tj|||d| _tj|
||d| _ntdj| jnZytj|}W n& tk
r   tdj| jY nX ddlm} | j| j|||d |d k	rt
|| _n`| jd krVy t| jd }| jj d }W n tk
r@   tdY nX t
| j||f| _|d k	rrtj| j|d| _| jdd d S )N)maxvalr   )defaultr	   )dtype   )
coo_matrix)shape   T)r)   Zcheck_contents)copyr+   z(unrecognized {}_matrix constructor usagez!unable to infer matrix dimensionsF)
full_check) r   __init__r   formatr0   asformat	_set_self
isinstancetupler   r%   _shaper.   r"   maxnpzerosr   floatdataindices_swapindptrlencoor-   	__class__array
ValueErrorasarray	Exceptioncheck_format)selfZarg1r.   r+   r0   MN	idx_dtyper-   otherr=   r>   r@   r)   	major_dim	minor_dim rP   8/tmp/pip-build-vw4w4j08/scipy/scipy/sparse/compressed.pyr2      sj    








z_cs_matrix.__init__c             C   s   |d krt | jd S |dk r&|d7 }| j|d| f\}}| j| j\}}|dkrhtjt| j|dS |dkr|tj| jS t	dd S )Nr	   r   r,   )Z	minlengthzaxis out of bounds)
intr@   r?   r.   r:   Zbincountr#   r>   diffrE   )rI   axis_rK   rP   rP   rQ   getnnzn   s    z_cs_matrix.getnnzc             C   s4   |r|j  }|j| _|j| _|j| _t|j| _dS )z:take the member variables of other and assign them to selfN)r0   r=   r>   r@   r%   r.   r8   )rI   rM   r0   rP   rP   rQ   r5      s    z_cs_matrix._set_selfTc             C   s  | j d\}}| j | j\}}| jjjdkrDtdj| jjjdd | jjjdkrjtdj| jjjdd t	| j| jf}t
j| j|d| _t
j| j|d| _t| j| _x.| jj| jj| jjgD ]}|d	krtd
qW t| j|d	 krtdjt| j|d	 | jd dkr tdt| jt| jkr>td| jd t| jkr\td| j  |r| jdkr| jj |krtdj||| jj dk rtdj|t
j| jj dk rtddS )zcheck whether the matrix format is valid

        Parameters
        ----------
        full_check : bool, optional
            If `True`, rigorous check, O(N) operations. Otherwise
            basic check, O(1) operations (default True).
        rowcolumniz'indptr array has non-integer dtype ({})r/   )
stacklevelz(indices array has non-integer dtype ({}))r+   r	   z'data, indices, and indptr should be 1-Dz&index pointer size ({}) should be ({})r   z!index pointer should start with 0z*indices and data should have the same sizezQLast value of index pointer should be less than the size of index and data arraysz{} index values must be < {}z{} index values must be >= 0z8index pointer values must form a non-decreasing sequenceN)rX   rY   rR   )r?   r.   r@   r+   kindr   r3   namer>   r"   r:   rF   r   r=   ndimrE   rA   prunennzr9   minrT   )rI   r1   Z
major_nameZ
minor_namerN   rO   rL   xrP   rP   rQ   rH      sF    

z_cs_matrix.check_formatc             C   s*   | j   | j|| j|dd}|j  |S )zScalar version of self._binopt, for cases in which no new nonzeros
        are added. Produces a new spmatrix in canonical form.
        T)r0   )sum_duplicates
_with_datar=   eliminate_zeros)rI   rM   opresrP   rP   rQ   _scalar_binopt   s    z_cs_matrix._scalar_binoptc             C   s   t |rxtj|r$| j| jtjdS |dkrhtdtdd | jtj| jtjd}| j	|t
j}|| S | j	|t
jS nt|r| j |kS t|rtdtdd | j|jkrdS | j|jkr|j| j}| j|d}| jtj| jtjd}|| S dS d S )	N)r+   r   zOComparing a sparse matrix with 0 using == is inefficient, try using != instead.r/   )r[   zHComparing sparse matrices using == is inefficient, try using != instead.F_ne_)r    r:   isnanrC   r.   bool_r   r   onesrh   operatorneeqr   todenser   r3   r4   _binopt)rI   rM   all_trueinvrg   rP   rP   rQ   __eq__   s0    

z_cs_matrix.__eq__c             C   s   t |rtj|r<tdtdd | jtj| jtjd}|S |dkrtdtdd | jtj| jtjd}| j	|t
j}|| S | j	|t
jS nTt|r| j |kS t|r| j|jkrdS | j|jkr|j| j}| j|dS dS d S )	Nz:Comparing a sparse matrix with nan using != is inefficientr/   )r[   )r+   r   z^Comparing a sparse matrix with a nonzero scalar using != is inefficient, try using == instead.Tri   )r    r:   rj   r   r   rC   rl   r.   rk   rh   rm   ro   rn   r   rp   r   r3   r4   rq   )rI   rM   rr   rs   rP   rP   rQ   __ne__   s,    


z_cs_matrix.__ne__c             C   s,  t |rzd|kr"|dkr"tdnV|d|rlt|t tj| jtj|d}|j| | j	|}| j
||S | j||S nt|r|| j |S t|r | j|jkrtdn| j|jkr|j| j}|dkr| j
||S tdt | j	tj| jtjd}| j
||dkrdnd	}|| S td
d S )Nr   _le__ge_z >= and <= don't work with 0.)r+   zinconsistent shapeszUComparing sparse matrices using >= and <= is inefficient, using <, >, or !=, instead._gt__lt_zOperands could not be compared.)rv   rw   )rw   rv   )r    NotImplementedErrorr   r   r:   emptyr.   Zresult_typefillrC   rq   rh   r   rp   r   rE   r3   r4   rl   rk   )rI   rM   rf   op_nameZbad_scalar_msg	other_arrrr   rg   rP   rP   rQ   _inequality  s2    






z_cs_matrix._inequalityc             C   s   | j |tjddS )Nry   zgComparing a sparse matrix with a scalar greater than zero using < is inefficient, try using >= instead.)r   rm   lt)rI   rM   rP   rP   rQ   __lt__;  s    z_cs_matrix.__lt__c             C   s   | j |tjddS )Nrx   zdComparing a sparse matrix with a scalar less than zero using > is inefficient, try using <= instead.)r   rm   gt)rI   rM   rP   rP   rQ   __gt__A  s    z_cs_matrix.__gt__c             C   s   | j |tjddS )Nrv   zgComparing a sparse matrix with a scalar greater than zero using <= is inefficient, try using > instead.)r   rm   le)rI   rM   rP   rP   rQ   __le__G  s    z_cs_matrix.__le__c             C   s   | j |tjddS )Nrw   zdComparing a sparse matrix with a scalar less than zero using >= is inefficient, try using < instead.)r   rm   ge)rI   rM   rP   rP   rQ   __ge__M  s    z_cs_matrix.__ge__c             C   s   |j | j krtdt| jj|jj}| jdd }tj|||dd}| j| j \}}|jj	rb|n|j
}t||| j| j| j| t|ddS )NzIncompatible shapes.ZCFr   T)r+   orderr0   F)r0   )r.   rE   r   r+   charr?   r:   rD   flagsc_contiguousTr   r@   r>   r=   r&   )rI   rM   r+   r   resultrJ   rK   yrP   rP   rQ   
_add_denseW  s    z_cs_matrix._add_densec             C   s   | j |dS )NZ_plus_)rq   )rI   rM   rP   rP   rQ   _add_sparseb  s    z_cs_matrix._add_sparsec             C   s   | j |dS )NZ_minus_)rq   )rI   rM   rP   rP   rQ   _sub_sparsee  s    z_cs_matrix._sub_sparsec             C   s2  t |r| j|S t|r:| j|jkr>| j|}| j|dS |jdkrZ| j|j d S | jdkrv|j| j d S | jd dkr|jd dkr| j|j S | jd dkr|jd dkr|j| j S |jd dkr$| jd |jd kr$t	|j j
 dgf|jd |jd fd}| j|S | jd dkr~| jd |jd kr~t	| j j
 dgf| jd | jd fd}|j|S |jd dkr| jd |jd krt	|j j
 dgf|jd |jd fd}|j| S | jd dkr2| jd |jd kr2t	| j j
 dgf| jd | jd fd}|j|S tdtj|}|jdkr`tj| j |S |jdkr|| j|jd S | jdkrtj| j d |S ddlm} | j }| j|jkrtj|j||j|jf }n@| jd dkr|jd dkrtj|j|}n<|jd | jd kr@tj|j|dd|jf }ntdtjtj|jd t|j}tj|j|jd }||jtjj
 ||ff|jd | jd fd	d
S | jd dkr|jd dkrtj|jdddf |}n@|jd | jd kr tj|jdddf ||j }ntdtj|j|jd }tjtj|jd t|j}||jtjj
 ||ff| jd |jd fd	d
S |jd dkr| jd |jd krtj|j|dd|jf j
 }nH|jd dkr| jd |jd krtj|j||j j
 }ntd|jtjj
 |_|S )zPPoint-wise multiplication by another matrix, vector, or
        scalar.
        Z_elmul_r	   r   )r.   zinconsistent shapesr,   )r-   NF)r.   r0   )r	   r	   )r   r   )r	   r	   )r   r   )r	   r	   )r   r   )r    Z_mul_scalarr   r.   rC   rq   toarray_mul_sparse_matrixtocscr   ravelrE   r:   Z
atleast_2dr^   multiplysizeZflatrB   r-   tocoor=   rX   colrepeatarangerA   tileviewZndarray)rI   rM   r0   r-   retr=   rX   r   rP   rP   rQ   r   h  s    




&
&
&
&

"&"&z_cs_matrix.multiplyc             C   sT   | j \}}tj|t| jj|jjd}tt| jd }|||| j	| j
| j|| |S )N)r+   Z_matvec)r.   r:   r;   r   r+   r   getattrr   r3   r@   r>   r=   )rI   rM   rJ   rK   r   fnrP   rP   rQ   _mul_vector  s    
z_cs_matrix._mul_vectorc          	   C   sl   | j \}}|j d }tj||ft| jj|jjd}tt| jd }||||| j	| j
| j|j |j  |S )Nr	   )r+   Z_matvecs)r.   r:   r;   r   r+   r   r   r   r3   r@   r>   r=   r   )rI   rM   rJ   rK   Zn_vecsr   r   rP   rP   rQ   _mul_multivector  s    


z_cs_matrix._mul_multivectorc             C   s  | j \}}|j \}}| j||fd }| j|}t| j| j|j|jf|| d}tj|d |d}tt	| j
d }	|	||tj| j|dtj| j|dtj|j|dtj|j|d| |d }
t| j| j|j|jf|
d}tj||d}tj|
|d}tj|
t| j|jd}tt	| j
d }	|	||tj| j|dtj| j|d| jtj|j|dtj|j|d|j||| | j|||f||fdS )	Nr   )r)   r	   )r+   Z_matmat_pass1Z_matmat_pass2)r.   rR   )r.   r?   rC   r"   r@   r>   r:   r{   r   r   r3   rF   r   r+   r=   )rI   rM   rJ   ZK1ZK2rK   Z
major_axisrL   r@   r   r`   r>   r=   rP   rP   rQ   r     s>    







z_cs_matrix._mul_sparse_matrixr   c             C   s   | j \}}|| ks||kr$tdtt| jd }tjt|t|d |t|d t	| j
d}||| j d | j d | j| j| j| |S )Nzk exceeds matrix dimensionsZ	_diagonalr   )r+   r	   )r.   rE   r   r   r3   r:   r{   ra   r9   r   r+   r@   r>   r=   )rI   kZrowscolsr   r   rP   rP   rQ   diagonal  s    
 
z_cs_matrix.diagonalc             C   s   t |r||rVtdtdd tj| jtj|jd}|j| | j	|}| j
||S | j  || jtj|}| j	|| j| jf|j| jd}|S n2t|r|| j |S t|r| j
||S tdd S )NzITaking maximum (minimum) with > 0 (< 0) number results to a dense matrix.r/   )r[   )r+   )r+   r.   zOperands not compatible.)r    r   r   r:   r{   r.   rF   r+   r|   rC   rq   rc   r=   r>   r@   r   rp   r   rE   )rI   rM   Znpopr}   Zdense_checkr~   Znew_datamatrP   rP   rQ   _maximum_minimum#  s&    

z_cs_matrix._maximum_minimumc             C   s   | j |tjddd S )NZ	_maximum_c             S   s   t j| dkS )Nr   )r:   rF   )rb   rP   rP   rQ   <lambda><  s    z$_cs_matrix.maximum.<locals>.<lambda>)r   r:   maximum)rI   rM   rP   rP   rQ   r   :  s    
z_cs_matrix.maximumc             C   s   | j |tjddd S )NZ	_minimum_c             S   s   t j| dk S )Nr   )r:   rF   )rb   rP   rP   rQ   r   B  s    z$_cs_matrix.minimum.<locals>.<lambda>)r   r:   minimum)rI   rM   rP   rP   rQ   r   @  s    
z_cs_matrix.minimumc             C   s   t | d r|| jdd krt| j}tjt| jd |d}| jtj	\}}|||< t
|}|d dkrr|j}|dk	r|j|jkrtd|jf ||dS tj| |||dS dS )z~Sum the matrix over the given axis.  If the axis is None, sum
        over both rows and columns, returning a scalar.
        	blocksizer	   r   r,   )r+   Nzdimensions do not match)rU   r+   outrR   r	   rR   r   r,   )r   r   )hasattrr?   r$   r+   r:   r;   rA   r@   _minor_reduceaddr'   r   r.   rE   sumr
   )rI   rU   r+   r   Z	res_dtyper   major_indexvaluerP   rP   rQ   r   J  s    
z_cs_matrix.sumc             C   s>   |dkr| 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
        N)r=   r:   ZflatnonzerorT   r@   Zreduceatr#   )rI   Zufuncr=   r   r   rP   rP   rQ   r   g  s    z_cs_matrix._minor_reducec       
      C   s\   | j | j\}}| j ||f\}}t||| j| j| j||d ||d 	\}}}	|	j| jdS )Nr	   )r+   )r?   r.   r   r@   r>   r=   r   r+   )
rI   rX   r   rJ   rK   majorminorr@   r>   r=   rP   rP   rQ   _get_intXint  s    z_cs_matrix._get_intXintc             C   sF   | j ||f\}}|jdkr6|jdkr6| j||ddS | j|j|S )Nr	   T)r0   )r	   N)r	   N)r?   step_get_submatrix_major_slice_minor_slice)rI   rX   r   r   r   rP   rP   rQ   _get_sliceXslice  s    z_cs_matrix._get_sliceXslicec       	   
   C   s   | j j}| j| j\}}| j||f\}}tj||d}tj||d}tj|j| jd}t||| j	| j | j
|j|j |j |	 |jdkrt|S | j|j|jS )N)r+   r	   )r>   r+   r?   r.   r:   rF   r{   r   r   r@   r=   r   r^   r'   rC   Zreshape)	rI   rX   r   rL   rJ   rK   r   r   valrP   rP   rQ   _get_arrayXarray  s    
z_cs_matrix._get_arrayXarrayc             C   s"   | j ||f\}}| j|j|S )N)r?   _major_index_fancy_minor_index_fancy)rI   rX   r   r   r   rP   rP   rQ   _get_columnXarray  s    z_cs_matrix._get_columnXarrayc             C   s   | j j}tj||dj }| j| j\}}t|}| j||f}|dkrR| j|S tj	| j
}| j j}tj|d |d}	tj|| |	dd d |	d }
tj|
|d}tj|
| jd}t||| j
| j | j|| | j|||	f|ddS )	zBIndex along the major axis where idx is an array of ints.
        )r+   r   r	   N)r   F)r.   r0   rR   )r>   r+   r:   rF   r   r?   r.   rA   rC   rT   r@   r;   cumsumr{   r   r=   )rI   idxrL   r>   rV   rK   rJ   	new_shaperow_nnz
res_indptrr`   res_indicesres_datarP   rP   rQ   r     s$    
z_cs_matrix._major_index_fancyc          	   C   sL  |t dkr|r| j S | S | j| j\}}|j|\}}}tt|||}| j||f}|dkrl| j|S tj	| j
}	| jj}
tj|d |
d}tj|	| |dd d |dkrt | j
| | j
| }tj| j| |d}tj| j| |d}nB|d	 }tj||
d}tj|| jd}t|||| j
| j| j|| | j|||f|ddS )
z@Index along the major axis where idx is a slice object.
        Nr   r	   )r+   )r   )r0   F)r.   r0   rR   )slicer0   r?   r.   r>   rA   r   rC   r:   rT   r@   r+   r;   r   rD   r=   r{   r   )rI   r   r0   rJ   rK   startstopr   r   r   rL   r   Zall_idxr   r   r`   rP   rP   rQ   r     s.    
z_cs_matrix._major_slicec          	   C   s   | j j}tj||dj }| j| j\}}t|}| j||f}|dkrR| j|S tj	||d}tj
| j}t||||| j| j || tj|j|dd}	|d }
tj|
|d}tj|
| jd}t|	|t| j | j | j|| | j|||f|ddS )zBIndex along the minor axis where idx is an array of ints.
        )r+   r   F)r0   r	   )r.   r0   rR   )r>   r+   r:   rF   r   r?   r.   rA   rC   r;   Z
empty_liker@   r   argsortZastyper{   r   r=   )rI   r   rL   rJ   rK   r   r   Zcol_offsetsr   Z	col_orderr`   r   r   rP   rP   rQ   r     s&    
z_cs_matrix._minor_index_fancyc             C   s   |t dkr|r| j S | S | j| j\}}|j|\}}}tt|||}|dkrh| j| j||fS |dkr~| j||dS | j	t
j|||S )z@Index along the minor axis where idx is a slice object.
        Nr   r	   )r   r0   )r   r0   r?   r.   r>   rA   r   rC   r   r   r:   r   )rI   r   r0   rJ   rK   r   r   r   rP   rP   rQ   r     s    z_cs_matrix._minor_slicec          
   C   s   | j | j\}}t||\}}t||\}}	|dkr\|dkr\||kr\|	|kr\|rX| j S | S t||| j| j| j||||		\}
}}| j || |	| f}| j|||
f|| j	ddS )zbReturn a submatrix of this matrix.

        major, minor: None, int, or slice with step 1
        r   F)r.   r+   r0   )
r?   r.   _process_slicer0   r   r@   r>   r=   rC   r+   )rI   r   r   r0   rJ   rK   i0i1Zj0Zj1r@   r>   r=   r.   rP   rP   rQ   r   	  s     "z_cs_matrix._get_submatrixc             C   s$   | j ||f\}}| j||| d S )N)r?   	_set_many)rI   rX   r   rb   rZ   jrP   rP   rQ   _set_intXint  s    z_cs_matrix._set_intXintc             C   s$   | j ||f\}}| j||| d S )N)r?   r   )rI   rX   r   rb   rZ   r   rP   rP   rQ   _set_arrayXarray   s    z_cs_matrix._set_arrayXarrayc             C   s  | j | j||f  |j\}}|dko2|jd dk}|dkoH|jd dk}|j|j }}	tj|j| jd}|rtj	tj
|t|}tj|	|}	tj||}|rtj	||}tjtj
|t|	}	tj	||}| j|||	f |||	f f\}
}| j|
|| d S )Nr	   r   )r+   )
_zero_manyr?   r.   rX   r   r:   rF   r=   r+   r   r   rA   r   r   )rI   rX   r   rb   rJ   rK   Zbroadcast_rowZbroadcast_colrcrZ   r   rP   rP   rQ   _set_arrayXarray_sparse$  s     
"z"_cs_matrix._set_arrayXarray_sparsec       	      C   s   d| j krd S | j \}}|jdk}|dk r|r>t|| |}nt|| |t|}tj|| jjd}tj|| jjd}||8 }nT|rt||| }nt||| t|}tj|| jjd}tj|| jjd}||7 }|s|d t| }|| ||f< d S )Nr   )r+   )r.   r^   ra   rA   r:   r   r>   r+   )	rI   valuesr   rJ   rK   	broadcastZ	max_indexrZ   r   rP   rP   rQ   _setdiag9  s(    



z_cs_matrix._setdiagc             C   sl   | j | j\}}dd }tj|| jjdddj }tj|| jjdddj }||| ||| ||||fS )Nc             S   sF   | j  }||kr td||f | j }|| k rBtd||f d S )Nzindex (%d) out of range (>= %d)zindex (%d) out of range (< -%d))r9   
IndexErrorra   )r>   Zboundr   rP   rP   rQ   check_boundsZ  s    
z1_cs_matrix._prepare_indices.<locals>.check_boundsFr	   )r+   r0   ndmin)r?   r.   r:   rD   r>   r+   r   )rI   rZ   r   rJ   rK   r   rP   rP   rQ   _prepare_indicesW  s    


z_cs_matrix._prepare_indicesc       
   	   C   s"  | j ||\}}}}tj|| jdddj }|j}tj|| jjd}t||| j	| j||||}|dkr| j
  t||| j	| j|||| d
|kr|| j|< dS tdj| jtdd |dk}	||	 | j||	 < |	 }	||	 }||d	k   |7  < ||	 }||d	k   |7  < | j||||	  dS )zSets value at each (i, j) to x

        Here (i,j) index major and minor respectively, and must not contain
        duplicate entries.
        Fr	   )r+   r0   r   )r+   NzZChanging the sparsity structure of a {}_matrix is expensive. lil_matrix is more efficient.r/   )r[   r   rR   rR   )r   r:   rD   r+   r   r   r{   r>   r   r@   rc   r=   r   r3   r   _insert_many)
rI   rZ   r   rb   rJ   rK   	n_samplesoffsetsr   maskrP   rP   rQ   r   j  s0    



z_cs_matrix._set_manyc          	   C   s   | j ||\}}}}t|}tj|| jjd}t||| j| j||||}|dkrr| j  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   NrR   )
r   rA   r:   r{   r>   r+   r   r@   rc   r=   )rI   rZ   r   rJ   rK   r   r   r   rP   rP   rQ   r     s    

z_cs_matrix._zero_manyc             C   s  t j|dd}|j|dd}|j|dd}|j|dd}| j}t| j| jf| jd |j d}t j| j|d| _t j| j|d| _t j||d}t j||d}g }g }t j	|dd	\}	}
t j
|
t|}
t j|
}d
}xtt|	|
|
dd D ]\}\}}}| j| }| j| }|j
| j||  |j
| j||  t j	||| ddd dd	\}}t||| kr|j
|||  |j
|||  nL|j
||| ddd |  |j
||| ddd |  t|||< |}qW | j| }|j
| j|d  |j
| j|d  t j|| _t j|| _t j| jj|d}|d
|d
< t j| j}||	  |7  < ||dd< t j||d| _|rd| _| j  | j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.
        Z	mergesort)r\   Zclip)moder	   )r)   )r+   T)Zreturn_indexr   N)r   F)r1   rR   rR   rR   rR   )r:   r   Ztakehas_sorted_indicesr"   r>   r@   r   rF   uniqueappendrA   rT   	enumerateizipr=   Zconcatenater{   r.   r   sort_indicesrH   )rI   rZ   r   rb   r   Zdo_sortrL   Zindices_partsZ
data_partsuiZ	ui_indptrZnew_nnzsprevr   iiZjsZjer   r   ZujZ	uj_indptrZnnzsZindptr_diffrP   rP   rQ   r     sZ    	
*

$  
z_cs_matrix._insert_manyc       	      C   sx   | j | j\}}| j}tjt|| jjd}tj|| j	| | j ||f\}}ddl
m} || j||ff| j|| jdS )N)r+   r	   )r-   )r0   r+   )r?   r.   r>   r:   r{   rA   r+   r   Z	expandptrr@   rB   r-   r=   )	rI   r0   rN   rO   Zminor_indicesZmajor_indicesrX   r   r-   rP   rP   rQ   r     s    z_cs_matrix.tocooc             C   s   |d kr|d kr| j dd }| j||}|jjp8|jjsBtd|jjrX| j }|}n| j }|j}|j |j	\}}t
|||j|j|j| |S )NZcfr   z&Output array must be C or F contiguous)r?   Z_process_toarray_argsr   r   f_contiguousrE   Ztocsrr   r   r.   r   r@   r>   r=   )rI   r   r   rb   r   rJ   rK   rP   rP   rQ   r     s    z_cs_matrix.toarrayc             C   s4   | j | j\}}tj||| j| j| j | j  dS )zURemove zero entries from the matrix

        This is an *in place* operation
        N)r?   r.   r   Zcsr_eliminate_zerosr@   r>   r=   r_   )rI   rJ   rK   rP   rP   rQ   re     s    z_cs_matrix.eliminate_zerosc             C   sB   t | ddsd| _n(t| ds<tjt| jd | j| j| _| jS )a^  Determine whether the 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   r   Zcsr_has_canonical_formatrA   r@   r>   has_canonical_format)rI   rP   rP   rQ   Z__get_has_canonical_format  s    
z%_cs_matrix.__get_has_canonical_formatc             C   s   t || _|rd| _d S )NT)boolr   r   )rI   r   rP   rP   rQ   Z__set_has_canonical_format4  s    
z%_cs_matrix.__set_has_canonical_format)fgetfsetc             C   sL   | j r
dS | j  | j| j\}}tj||| j| j| j | j	  d| _ dS )zkEliminate duplicate matrix entries by adding them together

        The is an *in place* operation
        NT)
r   r   r?   r.   r   Zcsr_sum_duplicatesr@   r>   r=   r_   )rI   rJ   rK   rP   rP   rQ   rc   <  s    z_cs_matrix.sum_duplicatesc             C   s.   t | ds(tjt| jd | j| j| _| jS )zDetermine whether the matrix has sorted indices

        Returns
            - True: if the indices of the matrix are in sorted order
            - False: otherwise

        r   r	   )r   r   Zcsr_has_sorted_indicesrA   r@   r>   r   )rI   rP   rP   rQ   Z__get_sortedL  s    

z_cs_matrix.__get_sortedc             C   s   t || _d S )N)r   r   )rI   r   rP   rP   rQ   Z__set_sorted[  s    z_cs_matrix.__set_sortedc             C   s   | j  }|j  |S )z9Return a copy of this matrix with sorted indices
        )r0   r   )rI   ArP   rP   rQ   sorted_indices`  s    z_cs_matrix.sorted_indicesc             C   s0   | j s,tjt| jd | j| j| j d| _ dS )z3Sort the indices of this matrix *in place*
        r	   TN)r   r   Zcsr_sort_indicesrA   r@   r>   r=   )rI   rP   rP   rQ   r   k  s    z_cs_matrix.sort_indicesc             C   s   | j | jd }t| j|d kr*tdt| j| jk rBtdt| j| jk rZt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)	r?   r.   rA   r@   rE   r>   r`   r=   r   )rI   rN   rP   rP   rQ   r_   t  s    z_cs_matrix.prunec             G   s  t |}t| drz| j\}}t|d |\}}t|d |\}}|sH|rZtd| j|f | jd | | jd |  }}	n| j|\}}| j| j\}}	||k r| jd | j|  | _| j	d | j|  | _	| jd |d  | _n<||krt
j| j|d | _| j|d 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d || _d S )Nr   r   r	   z.shape must be divisible into %s blocks. Got %s)r   )r%   r   r   divmodrE   r.   r?   r>   r@   r=   r:   resizer|   allr   r   r   r8   )rI   r.   ZbmZbnZnew_MZrmZnew_NZrnrJ   rK   r   r   r   rP   rP   rQ   r     s8    

 


z_cs_matrix.resizec             C   sL   |r*| j || jj | jj f| j|jdS | j || j| jf| j|jdS d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.   r+   N)rC   r>   r0   r@   r.   r+   )rI   r=   r0   rP   rP   rQ   rd     s    

z_cs_matrix._with_datac             C   s&  | j |}tt| j| | j }| j|j }t| j| j|j|jf|d}tj	| jj
|d}tj	||d}dddddg}||krtj	|tjd}	ntj	|t| j|jd}	|| j
d | j
d	 tj| j|dtj| j|d| jtj|j|dtj|j|d|j|||	 | j |	||f| j
d
}
|
j  |
S )z5apply the binary operation fn to two sparse matrices.)r)   )r+   ri   ry   rx   rv   rw   r   r	   )r.   )rC   r   r   r3   r`   r"   r@   r>   r:   r{   r.   rk   r   r+   rF   r=   r_   )rI   rM   rf   r   ZmaxnnzrL   r@   r>   Zbool_opsr=   r   rP   rP   rQ   rq     s.    



z_cs_matrix._binoptc             C   s   |j | j krtd| j|d}tj|jtjrtj| j | jd}|jtj	 |j
 \}}d|||f< |j }|j||j|jf< t|}n|}|S )z?
        Divide this matrix by a second sparse matrix.
        zinconsistent shapesZ_eldiv_)r+   r   )r.   rE   rq   r:   Z
issubdtyper+   Zinexactr{   r|   nanZnonzeror   r=   rX   r   r&   )rI   rM   r   r   rX   r   rP   rP   rQ   _divide_sparse  s    
z_cs_matrix._divide_sparse)NNF)N)F)T)r   )NNN)N)F)F)NNF)T)NN)T)A__name__
__module____qualname____doc__r2   rW   r
   r5   rH   rh   rt   ru   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   re   Z$_cs_matrix__get_has_canonical_formatZ$_cs_matrix__set_has_canonical_formatpropertyr   rc   Z_cs_matrix__get_sortedZ_cs_matrix__set_sortedr   r   r   r_   r   rd   rq   r   rP   rP   rP   rQ   r(      s   
P



F	!"
h'







 

'L




	"

"r(   c             C   s   | d krd| }}nt | trJ| j|\}}}|dkr>tdt||}nRt| r| dk rb| |7 } | | d  }}|dk s||krtd|||f ntd||fS )Nr   r	   z$slicing with step != 1 not supportedz'index out of bounds: 0 <= %d < %d <= %dzexpected slice or scalar)r6   r   r>   rE   ra   r!   r   	TypeError)slnumr   r   ZstriderP   rP   rQ   r     s     
r   )7r   
__future__r   r   r   __all__warningsr   rm   Znumpyr:   Zscipy._lib.sixr   r   r   Zscipy._lib._utilr   baser
   r   r   r=   r   r   Zdiar    r   r   r   r   r   r   r   r   r   _indexr   Zsputilsr   r   r   r   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r   rP   rP   rP   rQ   <module>   s2   (@         f