o
    h                     @   s   d Z g ZddlmZ ddlZddl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mZmZmZmZmZmZmZ dd
lmZ ddlmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z( G dd deeeZ)dd Z*dS )z>Base class for sparse matrix formats using compressed storage.    )warnN)_prune_array   )_spbaseissparseSparseEfficiencyWarning)_data_matrix_minmax_mixin)_sparsetools)get_csr_submatrixcsr_sample_offsetscsr_todensecsr_sample_valuescsr_row_indexcsr_row_slicecsr_column_index1csr_column_index2)
IndexMixin)upcastupcast_char	to_nativeisdenseisshapegetdtypeisscalarlike	isintlikedowncast_intp_indexget_sum_dtypecheck_shapeis_pydata_spmatrixc                   @   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_dzd6d7Zd8d9 Zd:d; Zd<d= Z d>d? Z!d@dA Z"d{dBdCZ#dDdE Z$d{dFdGZ%dydHdIZ&dJdK Z'dLdM Z(dNdO Z)dPdQ Z*dRdS Z+dTdU Z,dVdW Z-dXdY Z.d|dZd[Z/ej/je/_dd\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=_d|dsdtZ>dudv Z?dwdx Z@dS )
_cs_matrixzBbase matrix class for compressed row- and column-oriented matricesNFc              
   C   sr  t |  t|r"|j| jkr|r| }n|| j}| | nt|trt	|rbt
|| _| j\}}| jt||d}tdt|td| _td|| _tj| ||fd d |d| _nt|dkry| | j|||d}| | nmt|dkr|\}	}
}d }|d urt|}| j|
|f|d	d
}tj|
||d| _tj|||d| _tj|	||d| _n2td| jzt|}W n ty } z	td| j|d }~ww | | | j||d |d urt
|| _n3| jd u r#zt| jd }| j d }W n ty } ztd|d }~ww t
| ||f| _|d ur1| jj|dd| _| jdd d S )Nmaxvalr   )defaultr   dtype   shaper%      T)r"   check_contentscopyr%   z(unrecognized {}_matrix constructor usagez!unable to infer matrix dimensionsFr,   
full_check) r   __init__r   formatr,   asformat	_set_self
isinstancetupler   r   _shaper(   _get_index_dtypemaxnpzerosr   floatdataindices_swapindptrlen	__class___coo_containerarray
ValueErrorasarray	Exceptionastypecheck_format)selfarg1r(   r%   r,   MN	idx_dtypeotherr<   r=   r?   r"   e	major_dim	minor_dim rR   S/var/www/html/scripts/venv/lib/python3.10/site-packages/scipy/sparse/_compressed.pyr0      s   










z_cs_matrix.__init__c                 C   s   |d u rt | jd S |dk r|d7 }| |d| f\}}| | j\}}|dkr4tjt| j|dS |dkr>t| jS t	d)Nr   r&   r   )	minlengthzaxis out of bounds)
intr?   r>   r(   r9   bincountr   r=   diffrD   )rI   axis_rL   rR   rR   rS   _getnnzk   s   z_cs_matrix._getnnzc                 C   s4   |r|  }|j| _|j| _|j| _t|j| _dS )z:take the member variables of other and assign them to selfN)r,   r<   r=   r?   r   r(   r6   )rI   rN   r,   rR   rR   rS   r3   |   s   z_cs_matrix._set_selfTc                 C   s  |  d\}}|  | j\}}| jjjdkr"td| jjjdd | jjjdkr5td| jjjdd | 	| j| jf}t
j| j|d| _t
j| j|d| _t| j| _| jj| jj| jjfD ]
}|dkrktd	qat| j|d krtd
t| j|d | jd dkrtdt| jt| jkrtd| jd t| jkrtd|   |r| jdkr| j |krtd||| j dk rtd|t
| j dk rtddS dS 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 sizerT   zQLast 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)r>   r(   r?   r%   kindr   r1   namer=   r7   r9   rE   r   r<   ndimrD   r@   prunennzr8   minrX   )rI   r/   
major_name
minor_namerP   rQ   rM   xrR   rR   rS   rH      sX   

z_cs_matrix.check_formatc                 C   s*   |    | j|| j|dd}|  |S )zScalar version of self._binopt, for cases in which no new nonzeros
        are added. Produces a new sparse array in canonical form.
        Tr-   )sum_duplicates
_with_datar<   eliminate_zeros)rI   rN   opresrR   rR   rS   _scalar_binopt   s   z_cs_matrix._scalar_binoptc                 C   s  t |r;t|r| j| jtjdS |dkr4tdtdd | tj| jtjd}| 	|t
j}|| S | 	|t
jS t|rE|  |kS t|rKtS t|rtdtdd | j|jkr^dS | j|jkrj|| j}| |d}| tj| jtjd}|| S dS )	Nr$   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   r9   isnanrA   r(   bool_r   r   onesro   operatorneeqr   todenser   NotImplementedr   r1   r2   _binopt)rI   rN   all_trueinvrn   rR   rR   rS   __eq__   s8   
z_cs_matrix.__eq__c                 C   s   t |rGt|rtdtdd | tj| jtjd}|S |dkr@tdtdd | jt| jtjd}| 	|t
j}|| S | 	|t
jS t|rQ|  |kS t|rWtS t|ru| j|jkrcdS | j|jkro|| j}| |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.Trp   )r   r9   rq   r   r   rA   rs   r(   rr   ro   rt   rv   ru   r   rw   r   rx   r   r1   r2   ry   )rI   rN   rz   r{   rR   rR   rS   __ne__   s4   
z_cs_matrix.__ne__c                 C   s  t |r;d|kr|dv rtd|d|r5t|t tj| jt|d}|| | 	|}| 
||S | ||S t|rF||  |S t|r| j|jkrTtd| j|jkr`|| j}|dvrj| 
||S tdt | 	tj| jtjd}| 
||dkrd	nd
}|| S td)Nr   )_le__ge_z >= and <= don't work with 0.r$   inconsistent shapes)r   r~   zUComparing sparse matrices using >= and <= is inefficient, using <, >, or !=, instead.r~   _gt__lt_zOperands could not be compared.)r   NotImplementedErrorr   r   r9   emptyr(   result_typefillrA   ry   ro   r   rw   r   rD   r1   r2   rs   rr   )rI   rN   rm   op_namebad_scalar_msg	other_arrrz   rn   rR   rR   rS   _inequality  s4   



z_cs_matrix._inequalityc                 C      |  |tjddS )Nr   zgComparing a sparse matrix with a scalar greater than zero using < is inefficient, try using >= instead.)r   rt   ltrI   rN   rR   rR   rS   __lt__>     z_cs_matrix.__lt__c                 C   r   )Nr   zdComparing a sparse matrix with a scalar less than zero using > is inefficient, try using <= instead.)r   rt   gtr   rR   rR   rS   __gt__D  r   z_cs_matrix.__gt__c                 C   r   )Nr~   zgComparing a sparse matrix with a scalar greater than zero using <= is inefficient, try using > instead.)r   rt   ler   rR   rR   rS   __le__J  r   z_cs_matrix.__le__c                 C   r   )Nr   zdComparing a sparse matrix with a scalar less than zero using >= is inefficient, try using < instead.)r   rt   ger   rR   rR   rS   __ge__P  r   z_cs_matrix.__ge__c                 C   s   |j | j krtd| j |j t| jj|jj}| dd }tj|||dd}| | j \}}|j	j
r7|n|j}t||| j| j| j| | j|ddS )NzIncompatible shapes ({} and {})CFr   T)r%   orderr,   Fr-   )r(   rD   r1   r   r%   charr>   r9   rC   flagsc_contiguousTr   r?   r=   r<   
_container)rI   rN   r%   r   resultrK   rL   yrR   rR   rS   
_add_denseZ  s   z_cs_matrix._add_densec                 C      |  |dS )N_plus_ry   r   rR   rR   rS   _add_sparsef     z_cs_matrix._add_sparsec                 C   r   )N_minus_r   r   rR   rR   rS   _sub_sparsei  r   z_cs_matrix._sub_sparsec                 C   s&  t |r	| |S t|r| j|jkr| |}| |dS |jdkr-| | d S | jdkr;||  d S | jd dkrP|jd dkrP| | S | jd dkre|jd dkre||  S |jd dkr| jd |jd kr| j	| 
 dgf|jd |jd fd}| |S | jd dkr| jd |jd kr| j	|  
 dgf| jd | jd fd}||S |jd dkr| jd |jd kr| j	| 
 dgf|jd |jd fd}|| S | jd dkr| jd |jd kr| j	|  
 dgf| jd | jd fd}||S tdt|}|jdkr.t|  |S |jdkr<| |jd S | jdkrLt|  d |S |  }| j|jkrft|j||j|jf }n"| jd dkr|jd dkr~t|j|}n|jd | jd krt|j|d	d	|jf }ntdtt|jd t|j}t|j|jd }| j|tj
 ||ff|jd | jd fd
dS | jd dkr@|jd dkrt|jd	d	d	f |}n |jd | jd kr	t|jd	d	d	f ||j }ntdt|j|jd }tt|jd t|j}| j|tj
 ||ff| jd |jd fd
dS |jd dkrd| jd |jd krdt|j|d	d	|jf 
 }n$|jd dkr| jd |jd krt|j||j 
 }ntd|tj
 |_|S )zPPoint-wise multiplication by another matrix, vector, or
        scalar.
        _elmul_)r   r   )r   r   r   r   r(   r   r&   NFr(   r,   )r   _mul_scalarr   r(   rA   ry   toarray_mul_sparse_matrixtocsc_dia_containerravelrD   r9   
atleast_2drc   multiplysizeflattocoor<   r\   colrepeataranger@   tilerB   viewndarray)rI   rN   r,   retr<   r\   r   rR   rR   rS   r   l  s   




"
"
"
&

"&"&z_cs_matrix.multiplyc                 C   sT   | j \}}tj|t| jj|jjd}tt| jd }|||| j	| j
| j|| |S )Nr$   _matvec)r(   r9   r:   r   r%   r   getattrr
   r1   r?   r=   r<   )rI   rN   rK   rL   r   fnrR   rR   rS   _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| |  |S )Nr   r$   _matvecs)r(   r9   r:   r   r%   r   r   r
   r1   r?   r=   r<   r   )rI   rN   rK   rL   n_vecsr   r   rR   rR   rS   _mul_multivector  s   


z_cs_matrix._mul_multivectorc                 C   sj  | j \}}|j \}}| ||fd }| |}| | j| j|j|jf}tt| jd }|||t	j
| j|dt	j
| j|dt	j
|j|dt	j
|j|d}	| j| j| j|j|jf|	d}t	j|d |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   _matmat_maxnnzr$   r!   r   _matmatr   )r(   r>   rA   r7   r?   r=   r   r
   r1   r9   rE   r   r   r%   r<   )rI   rN   rK   K1K2rL   
major_axisrM   r   re   r?   r=   r<   rR   rR   rS   r     s@   


z_cs_matrix._mul_sparse_matrixr   c                 C   s   | j \}}|| ks||krtjd| jjdS tt| jd }tjt|t|d |t	|d t
| jd}||| j d | j d | j| j| j| |S )Nr   r$   	_diagonalr   )r(   r9   r   r<   r%   r   r
   r1   rf   r8   r   r?   r=   )rI   krowscolsr   r   rR   rR   rS   diagonal  s   
 z_cs_matrix.diagonalc                 C   s   t |rI||r+tdtdd tj| jt|jd}|| | 	|}| 
||S |   || jt|}| j	|| j| jf|j| jd}|S t|rT||  |S t|r^| 
||S td)NzITaking maximum (minimum) with > 0 (< 0) number results to a dense matrix.r)   r_   r$   )r%   r(   zOperands not compatible.)r   r   r   r9   r   r(   rE   r%   r   rA   ry   rj   r<   r=   r?   r   rw   r   rD   )rI   rN   npopr   dense_checkr   new_datamatrR   rR   rS   _maximum_minimum/  s*   

z_cs_matrix._maximum_minimumc                 C      |  |tjddd S )N	_maximum_c                 S   s   t | dkS Nr   r9   rE   ri   rR   rR   rS   <lambda>H      z$_cs_matrix.maximum.<locals>.<lambda>)r   r9   maximumr   rR   rR   rS   r   F     
z_cs_matrix.maximumc                 C   r   )N	_minimum_c                 S   s   t | dk S r   r   r   rR   rR   rS   r   N  r   z$_cs_matrix.minimum.<locals>.<lambda>)r   r9   minimumr   rR   rR   rS   r   L  r   z_cs_matrix.minimumc                 C   s   t | dsO|| dd v rOt| j}tjt| jd |d}| tj	\}}|||< | 
|}|d dkr9|j}|durG|j|jkrGtd|jd	||d
S tj| |||d
S )z~Sum the matrix over the given axis.  If the axis is None, sum
        over both rows and columns, returning a scalar.
        	blocksize))r   rT   )r   r&   r   r   r$   r&   Nzdimensions do not matchrR   )rY   r%   out)hasattrr>   r   r%   r9   r:   r@   r?   _minor_reduceadd_ascontainerr   r(   rD   sumr   )rI   rY   r%   r   	res_dtyper   major_indexvaluerR   rR   rS   r   V  s   


z_cs_matrix.sumc                 C   s>   |du r| j }tt| 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<   r9   flatnonzerorX   r?   reduceatr   )rI   ufuncr<   r   r   rR   rR   rS   r   s  s   z_cs_matrix._minor_reducec           
      C   s\   |  | j\}}|  ||f\}}t||| j| j| j||d ||d 	\}}}	|	j| jdS )Nr   r$   )r>   r(   r   r?   r=   r<   r   r%   )
rI   r\   r   rK   rL   majorminorr?   r=   r<   rR   rR   rS   _get_intXint  s   
z_cs_matrix._get_intXintc                 C   sF   |  ||f\}}|jdv r|jdv r| j||ddS | ||S )N)r   NTr-   )r>   step_get_submatrix_major_slice_minor_slicerI   r\   r   r   r   rR   rR   rS   _get_sliceXslice  s   z_cs_matrix._get_sliceXslicec           	   
   C   s   | j j}| | j\}}| ||f\}}tj||d}tj||d}tj|j| jd}t||| j	| j | j
|j| | |	 |jdkrJ| |S | ||jS )Nr$   r   )r=   r%   r>   r(   r9   rE   r   r   r   r?   r<   r   rc   r   rA   reshape)	rI   r\   r   rM   rK   rL   r   r   valrR   rR   rS   _get_arrayXarray  s   

z_cs_matrix._get_arrayXarrayc                 C   s"   |  ||f\}}| ||S N)r>   _major_index_fancy_minor_index_fancyr   rR   rR   rS   _get_columnXarray  s   z_cs_matrix._get_columnXarrayc                 C   s   | j j}tj||d }| | j\}}t|}| ||f}|dkr,| j|| jdS | j	|d  | 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   rT   Fr   )r=   r%   r9   rE   r   r>   r(   r@   rA   r?   r:   cumsumr   r   r<   )rI   idxrM   r=   rZ   rL   rK   	new_shaperow_nnz
res_indptrre   res_indicesres_datarR   rR   rS   r     s(   z_cs_matrix._major_index_fancyc              	   C   s  |t dkr|r|  S | S | | j\}}||\}}}tt|||}| ||f}|dkr9| j|| jdS ||}	}
|dkrH|dkrHd}
|d |d }}| 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}n!|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$   rT   r   r   r-   Fr   )slicer,   r>   r(   r=   r@   rangerA   r%   r?   r9   r:   r   rC   r<   r   r   )rI   r   r,   rK   rL   startstopr   r   start0stop0start1stop1r   rM   r   all_idxr   r  re   rR   rR   rS   r     s>   
z_cs_matrix._major_slicec              	   C   s   | j j}tj||d }| | j\}}t|}| ||f}|dkr,| j|| jdS tj	||d}t
| j}t||||| j| j || t|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   Fr-   rT   r   )r=   r%   r9   rE   r   r>   r(   r@   rA   r:   
empty_liker?   r   argsortrG   r   r   r<   )rI   r   rM   rK   rL   r   r   col_offsetsr   	col_orderre   r   r  rR   rR   rS   r     s,   z_cs_matrix._minor_index_fancyc                 C   s   |t dkr|r|  S | S | | j\}}||\}}}tt|||}|dkr7| j| ||f| jdS |dkrB| j	||dS | 
t|||S )z@Index along the minor axis where idx is a slice object.
        Nr   r$   r   )r   r,   )r  r,   r>   r(   r=   r@   r  rA   r%   r   r   r9   r   )rI   r   r,   rK   rL   r  r  r   rR   rR   rS   r     s   z_cs_matrix._minor_slicec              
   C   s   |  | j\}}t||\}}t||\}}	|dkr.|dkr.||kr.|	|kr.|r,|  S | S t||| 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%   r,   )
r>   r(   _process_slicer,   r   r?   r=   r<   rA   r%   )rI   r   r   r,   rK   rL   i0i1j0j1r?   r=   r<   r(   rR   rR   rS   r     s    
z_cs_matrix._get_submatrixc                 C   $   |  ||f\}}| ||| d S r   r>   	_set_manyrI   r\   r   ri   r^   jrR   rR   rS   _set_intXint0     z_cs_matrix._set_intXintc                 C   r  r   r  r  rR   rR   rS   _set_arrayXarray4  r  z_cs_matrix._set_arrayXarrayc                 C   s  | j | ||f  |j\}}|dko|jd dk}|dko$|jd dk}|j|j}}	tj|j| jd}|j	dkr<d S |rUt
t|t|}t|	|}	t||}|rnt
||}tt|t|	}	t
||}| |||	f |||	f f\}
}| |
|| d S )Nr   r   r$   )
_zero_manyr>   r(   r\   r   r9   rE   r<   r%   r   r   r   r@   r   r  )rI   r\   r   ri   rK   rL   broadcast_rowbroadcast_colrcr^   r  rR   rR   rS   _set_arrayXarray_sparse8  s$   

"z"_cs_matrix._set_arrayXarray_sparsec           	      C   s   d| j v 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 }n*|rJt||| }n
t||| t|}tj|| jjd}tj|| jjd}||7 }|st|d t| }|| ||f< d S )Nr   r$   )r(   rc   rf   r@   r9   r   r=   r%   )	rI   valuesr   rK   rL   	broadcast	max_indexr^   r  rR   rR   rS   _setdiagQ  s(   



z_cs_matrix._setdiagc                 C   sl   |  | j\}}dd }tj|| jjddd }tj|| jjddd }||| ||| ||||fS )Nc                 S   sF   |   }||krtd||f |  }|| k r!td||f d S )Nzindex (%d) out of range (>= %d)zindex (%d) out of range (< -%d))r8   
IndexErrorrf   )r=   boundr   rR   rR   rS   check_boundsr  s   
z1_cs_matrix._prepare_indices.<locals>.check_boundsFr   r%   r,   ndmin)r>   r(   r9   rC   r=   r%   r   )rI   r^   r  rK   rL   r(  rR   rR   rS   _prepare_indiceso  s   


z_cs_matrix._prepare_indicesc           
   	   C   s"  |  ||\}}}}tj|| jddd }|j}tj|| jjd}t||| j	| j||||}|dkrD| 
  t||| j	| j|||| d|vrO|| j|< dS td| jtdd	 |dk}	||	 | j||	 < |	 }	||	 }||d
k   |7  < ||	 }||d
k   |7  < | ||||	  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)  r$   rT   NzZChanging the sparsity structure of a {}_matrix is expensive. lil_matrix is more efficient.r)   r_   r   )r+  r9   rC   r%   r   r   r   r=   r   r?   rj   r<   r   r1   r   _insert_many)
rI   r^   r  ri   rK   rL   	n_samplesoffsetsr   maskrR   rR   rS   r    s6   
z_cs_matrix._set_manyc              	   C   s   |  ||\}}}}t|}tj|| jjd}t||| j| j||||}|dkr9|   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   rT   N)
r+  r@   r9   r   r=   r%   r   r?   rj   r<   )rI   r^   r  rK   rL   r-  r.  r   rR   rR   rS   r    s   z_cs_matrix._zero_manyc                 C   s  t j|dd}|j|dd}|j|dd}|j|dd}| j}| j| 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 
|
t|}
t |
}d
}tt|	|
|
dd D ]z\}\}}}| j| }| j| }|
| j||  |
| j||  t j	||| ddd dd	\}}t||| kr|
|||  |
|||  n&|
||| ddd |  |
||| ddd |  t|||< |}qx| j| }|
| j|d  |
| j|d  t || _t || _t j| jj|d}|d
|d
< t | j}||	  |7  < ||dd< t j||d| _|rMd| _|   | 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.
        	mergesort)ra   clip)moderT   r!   r$   T)return_indexr   r   Nr   Fr.   )r9   r  takehas_sorted_indicesr7   r=   r?   r   rE   uniqueappendr@   rX   	enumeratezipr<   concatenater   r(   r   sort_indicesrH   )rI   r^   r  ri   r   do_sortrM   indices_parts
data_partsui	ui_indptrnew_nnzsprevr   iijsjer  r  uj	uj_indptrnnzsindptr_diffrR   rR   rS   r,    s\   	
&

$  
z_cs_matrix._insert_manyc                 C   sn   |  | j\}}| j}tjt|| jjd}t|| j	| |  ||f\}}| j
| j||ff| j|| jdS )Nr$   r+   )r>   r(   r=   r9   r   r@   r%   r
   	expandptrr?   rB   r<   )rI   r,   rP   rQ   minor_indicesmajor_indicesr\   r   rR   rR   rS   r   	  s   z_cs_matrix.tocooc                 C   s   |d u r|d u r|  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)r>   _process_toarray_argsr   r   f_contiguousrD   tocsrr   r   r(   r   r?   r=   r<   )rI   r   r   ri   r   rK   rL   rR   rR   rS   r     s   z_cs_matrix.toarrayc                 C   s4   |  | j\}}t||| j| j| j |   dS )zVRemove zero entries from the matrix

        This is an *in place* operation.
        N)r>   r(   r
   csr_eliminate_zerosr?   r=   r<   rd   rI   rK   rL   rR   rR   rS   rl   .  s
   z_cs_matrix.eliminate_zerosc                 C   sJ   t | ddsd| _| jS t| ds"tt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   rT  r   boolr
   csr_has_canonical_formatr@   r?   r=   has_canonical_formatrI   rR   rR   rS   __get_has_canonical_format8  s   
z%_cs_matrix.__get_has_canonical_formatc                 C   s   t || _|rd| _d S d S )NT)rU  rT  r5  rI   r   rR   rR   rS   __set_has_canonical_formatN  s   

z%_cs_matrix.__set_has_canonical_format)fgetfsetc                 C   sL   | j rdS |   | | j\}}t||| j| j| j | 	  d| _ dS )zmEliminate duplicate matrix entries by adding them together

        This is an *in place* operation.
        NT)
rW  r;  r>   r(   r
   csr_sum_duplicatesr?   r=   r<   rd   rR  rR   rR   rS   rj   V  s   
z_cs_matrix.sum_duplicatesc                 C   s2   t | dstt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

        rS  r   )r   rU  r
   csr_has_sorted_indicesr@   r?   r=   rS  rX  rR   rR   rS   __get_sortedf  s   

z_cs_matrix.__get_sortedc                 C   s   t || _d S r   )rU  rS  rZ  rR   rR   rS   __set_sortedv  s   z_cs_matrix.__set_sortedc                 C   s   |   }|  |S )z9Return a copy of this matrix with sorted indices
        )r,   r;  )rI   ArR   rR   rS   sorted_indices{  s   z_cs_matrix.sorted_indicesc                 C   s4   | j stt| jd | j| j| j d| _ dS dS )z3Sort the indices of this matrix *in place*
        r   TN)r5  r
   csr_sort_indicesr@   r?   r=   r<   rX  rR   rR   rS   r;    s   
z_cs_matrix.sort_indicesc                 C   s   |  | jd }t| j|d 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)	r>   r(   r@   r?   rD   r=   re   r<   r   )rI   rP   rR   rR   rS   rd     s   z_cs_matrix.prunec                 G   s  t |}t| dr=| j\}}t|d |\}}t|d |\}}|s$|r-td| j|| jd | | jd | }}	n| |\}}| | j\}}	||k rq| jd | j	|  | _| j
d | j	|  | _
| j	d |d  | _	n||krt| j	|d | _	| j	|d d  | j	|  ||	k r| j|k }
t|
s| j|
 | _| j
|
 | _
| tj|
\}}| j	d || j	dd  |< tj| j	| j	d || _d S )Nr   r   r   z.shape must be divisible into {} blocks. Got {}r   )r   r   r   divmodrD   r1   r(   r>   r=   r?   r<   r9   resizer   allr   r   r   r6   )rI   r(   bmbnnew_Mrmnew_NrnrK   rL   r/  r   r   rR   rR   rS   rf    s:   


 


z_cs_matrix.resizec                 C   sH   |r| j || j | j f| j|jdS | j || j| jf| j|j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'   )rA   r=   r,   r?   r(   r%   )rI   r<   r,   rR   rR   rS   rk     s   z_cs_matrix._with_datac                 C   s"  |  |}tt| j| | j }| j|j }| j| j| j|j|jf|d}tj	| jj
|d}tj	||d}g d}||v rFt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}
|
  |
S )z5apply the binary operation fn to two sparse matrices.r!   r$   )rp   r   r   r~   r   r   r   r   )rA   r   r
   r1   re   r7   r?   r=   r9   r   r(   rr   r   r%   rE   r<   rd   )rI   rN   rm   r   maxnnzrM   r?   r=   bool_opsr<   rb  rR   rR   rS   ry     s4   
	z_cs_matrix._binoptc                 C   s   |j | j kr
td| |d}t|jtjrGtj| j | jd}|tj	 |
 \}}d|||f< | }|j||j|jf< | |}|S |}|S )z?
        Divide this matrix by a second sparse matrix.
        r   _eldiv_r$   r   )r(   rD   ry   r9   
issubdtyper%   inexactr   r   nannonzeror   r<   r\   r   r   )rI   rN   r  r   r\   r   rR   rR   rS   _divide_sparse  s   
z_cs_matrix._divide_sparse)NNFr   )F)T)r   )NNN)NN)A__name__
__module____qualname____doc__r0   r[   r   r3   rH   ro   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,  r   r   rl   $_cs_matrix__get_has_canonical_format$_cs_matrix__set_has_canonical_formatpropertyrW  rj   _cs_matrix__get_sorted_cs_matrix__set_sortedr5  rc  r;  rd   rf  rk   ry   ru  rR   rR   rR   rS   r       s    

R


F	$""
s
$






(

'
L



	
"
"r    c                 C   s   | d u rd|}}||fS t | tr+| |\}}}|dkr"tdt||}||fS t| rS| dk r7| |7 } | | d }}|dk sF||krOtd|||f ||fS td)Nr   r   z$slicing with step != 1 not supportedz'index out of bounds: 0 <= %d < %d <= %dzexpected slice or scalar)r4   r  r=   rD   rf   r   r&  	TypeError)slnumr  r  striderR   rR   rS   r    s&   


r  )+ry  __all__warningsr   rt   numpyr9   scipy._lib._utilr   _baser   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  rR   rR   rR   rS   <module>   s0    (8          