ó
î&]\c           @` s4  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 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# m$ Z$ m% Z% m& Z& m' Z' d e e e# f d „  ƒ  YZ( d S(   s>   Base class for sparse matrix formats using compressed storage.i    (   t   divisiont   print_functiont   absolute_import(   t   warnN(   t   zip(   t   _prune_arrayi   (   t   spmatrixt
   isspmatrixt   SparseEfficiencyWarning(   t   _data_matrixt   _minmax_mixin(   t
   dia_matrix(   t   _sparsetools(   t   upcastt   upcast_chart	   to_nativet   isdenset   isshapet   getdtypet   isscalarliket
   IndexMixint   get_index_dtypet   downcast_intp_indext   get_sum_dtypet   check_shapet
   _cs_matrixc           B` s  e  Z d  Z d4 d4 e d „ Z d4 d „ Z e j j e _ e d „ Z e	 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 d „  Z d d „ Z e j j e _ d „  Z d „  Z e j j e _ d „  Z e j j e _ d4 d4 d4 d „ Z e j j e _ d4 d „ Z d „  Z  d „  Z! d „  Z" d „  Z# d „  Z$ d  „  Z% d! „  Z& d" „  Z' e	 d# „ Z( e j( j e( _ d4 d4 d$ „ Z) e j) j e) _ d% „  Z* d& „  Z+ d' „  Z, e- d( e+ d) e, ƒ Z. d* „  Z/ d+ „  Z0 d, „  Z1 e- d( e0 d) e1 ƒ Z2 d- „  Z3 d. „  Z4 d/ „  Z5 d0 „  Z6 e j6 j e6 _ e	 d1 „ Z7 d2 „  Z8 d3 „  Z9 RS(5   sA   base matrix class for compressed row and column oriented matricesc         C` s‡  t  j |  ƒ t | ƒ rb | j |  j k r@ | r@ | j ƒ  } n | j |  j ƒ } |  j | ƒ nOt | t ƒ r@t	 | ƒ rt
 | ƒ |  _ |  j \ } } t d t | | ƒ ƒ } t j d t | d t ƒƒ |  _ t j d | ƒ |  _ t j |  j | | f ƒ d d d | ƒ|  _ q±t | ƒ d k rhd d l m } |  j | | d | ƒƒ }	 |  j |	 ƒ q±t | ƒ d	 k r%| \ }
 } } d  } | d  k	 rªt | ƒ } n  t | | f d | d
 t ƒ} t j | d | d | ƒ|  _ t j | d | d | ƒ|  _ t j |
 d | d | ƒ|  _ q±t d j |  j ƒ ƒ ‚ nq y t j | ƒ } Wn) t  k
 r~t d j |  j ƒ ƒ ‚ n Xd d l m } |  j |  j | | d | ƒƒ ƒ | d  k	 rÏt
 | ƒ |  _ nz |  j d  k rIy* t |  j ƒ d } |  j j ƒ  d } Wn t  k
 r't d ƒ ‚ qIXt
 |  j | | f ƒ ƒ |  _ n  | d  k	 rst j |  j d | ƒ|  _ n  |  j! d t" ƒ d  S(   Nt   maxvali    t   defaulti   t   dtypei   (   t
   coo_matrixt   shapei   t   check_contentst   copys(   unrecognized {}_matrix constructor usages!   unable to infer matrix dimensionst
   full_check(#   R	   t   __init__R   t   formatR    t   asformatt	   _set_selft
   isinstancet   tupleR   R   t   _shapeR   R   t   maxt   npt   zerosR   t   floatt   datat   indicest   _swapt   indptrt   lent   cooR   t	   __class__t   Nonet   Truet   arrayt
   ValueErrort   asarrayt	   Exceptiont   check_formatt   False(   t   selft   arg1R   R   R    t   Mt   Nt	   idx_dtypeR   t   otherR-   R.   R0   R   t	   major_dimt	   minor_dim(    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyR"      sj    !#	!		"c         C` sÁ   | d  k r t |  j d ƒ S| d k  r6 | d 7} n  |  j | d | f ƒ \ } } |  j |  j ƒ \ } } | d k r• t j t |  j ƒ d | ƒS| d k r± t j	 |  j ƒ St
 d ƒ ‚ d  S(   Niÿÿÿÿi    i   i   t	   minlengths   axis out of bounds(   R4   t   intR0   R/   R   R*   t   bincountR   R.   t   diffR7   (   R<   t   axist   _R?   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   getnnzi   s    c         C` sO   | r | j  ƒ  } n  | j |  _ | j |  _ | j |  _ t | j ƒ |  _ d S(   s:   take the member variables of other and assign them to selfN(   R    R-   R.   R0   R   R   R(   (   R<   RA   R    (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyR%   z   s    c         C` s¶  |  j  d ƒ \ } } |  j  |  j ƒ \ } } |  j j j d k rg t d j |  j j j ƒ d d ƒn  |  j j j d k r¡ t d j |  j j j ƒ d d ƒn  t	 |  j |  j f ƒ } t
 j |  j d | ƒ|  _ t
 j |  j d | ƒ|  _ t |  j ƒ |  _ xD |  j j |  j j |  j j g D]! } | d	 k r#t d
 ƒ ‚ q#q#Wt |  j ƒ | d	 k r‰t d j t |  j ƒ | d	 ƒ ƒ ‚ n  |  j d d k r«t d ƒ ‚ n  t |  j ƒ t |  j ƒ k rØt d ƒ ‚ n  |  j d t |  j ƒ k rt d ƒ ‚ n  |  j ƒ  | r²|  j d k r²|  j j ƒ  | k rRt d j | | ƒ ƒ ‚ n  |  j j ƒ  d k  rt d j | ƒ ƒ ‚ n  t
 j |  j ƒ j ƒ  d k  r¯t d ƒ ‚ q¯q²n  d S(   s÷   check 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).
        t   rowt   columnt   is'   indptr array has non-integer dtype ({})t
   stackleveli   s(   indices array has non-integer dtype ({})R   i   s'   data, indices, and indptr should be 1-Ds&   index pointer size ({}) should be ({})i    s!   index pointer should start with 0s*   indices and data should have the same sizeiÿÿÿÿsQ   Last value of index pointer should be less than the size of index and data arrayss   {} index values must be < {}s   {} index values must be >= 0s8   index pointer values must form a non-decreasing sequenceN(   RK   RL   (   R/   R   R0   R   t   kindR   R#   t   nameR.   R   R*   R8   R   R-   t   ndimR7   R1   t   prunet   nnzR)   t   minRG   (   R<   R!   t
   major_namet
   minor_nameRB   RC   R@   t   x(    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyR:   …   sF    
		(	
		c         C` s9   |  j  ƒ  |  j | |  j | ƒ d t ƒ} | j ƒ  | S(   s‰   Scalar version of self._binopt, for cases in which no new nonzeros
        are added. Produces a new spmatrix in canonical form.
        R    (   t   sum_duplicatest
   _with_dataR-   R5   t   eliminate_zeros(   R<   RA   t   opt   res(    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   _scalar_binoptË   s    
!
c         C` sh  t  | ƒ rª t j | ƒ r4 |  j |  j d t j ƒS| d k r” t d t d d ƒ|  j t j |  j d t j ƒƒ } |  j	 | t
 j ƒ } | | S|  j	 | t
 j ƒ Snº t | ƒ rÆ |  j ƒ  | k St | ƒ r`t d t d d ƒ|  j | j k rû t S|  j | j k r"| j |  j ƒ } n  |  j | d ƒ } |  j t j |  j d t j ƒƒ } | | St Sd  S(   NR   i    sO   Comparing a sparse matrix with 0 using == is inefficient, try using != instead.RN   i   sH   Comparing sparse matrices using == is inefficient, try using != instead.t   _ne_(   R   R*   t   isnanR3   R   t   bool_R   R   t   onesR]   t   operatort   net   eqR   t   todenseR   R;   R#   R$   t   _binopt(   R<   RA   t   all_truet   invR\   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   __eq__Ô   s0    $$c         C` sI  t  | ƒ rÌ t j | ƒ rV t d t d d ƒ|  j t j |  j d t j ƒƒ } | S| d k r¶ t d t d d ƒ|  j t j |  j ƒ d t j ƒ} |  j	 | t
 j ƒ } | | S|  j	 | t
 j ƒ Sny t | ƒ rè |  j ƒ  | k St | ƒ rA|  j | j k r
t S|  j | j k r1| j |  j ƒ } n  |  j | d ƒ St Sd  S(   Ns:   Comparing a sparse matrix with nan using != is inefficientRN   i   R   i    s^   Comparing a sparse matrix with a nonzero scalar using != is inefficient, try using == instead.R^   (   R   R*   R_   R   R   R3   Ra   R   R`   R]   Rb   Rd   Rc   R   Re   R   R5   R#   R$   Rf   (   R<   RA   Rg   Rh   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   __ne__õ   s,    $$c         C` s«  t  | ƒ r¯ d | k r3 | d k r3 t d ƒ ‚ q§| d | ƒ rœ t | t ƒ t j |  j d t j | ƒ ƒ} | j | ƒ |  j	 | ƒ } |  j
 | | ƒ S|  j | | ƒ Snø t | ƒ rÎ | |  j ƒ  | ƒ St | ƒ r›|  j | j k rû t d ƒ ‚ n' |  j | j k r"| j |  j ƒ } n  | d k r>|  j
 | | ƒ St d t ƒ |  j	 t j |  j d t j ƒƒ } |  j
 | | d k rŠd n d	 ƒ } | | St d
 ƒ ‚ d  S(   Ni    t   _le_t   _ge_s    >= and <= don't work with 0.R   s   inconsistent shapessU   Comparing sparse matrices using >= and <= is inefficient, using <, >, or !=, instead.t   _gt_t   _lt_s   Operands could not be compared.(   Rk   Rl   (   Rl   Rk   (   R   t   NotImplementedErrorR   R   R*   t   emptyR   t   result_typet   fillR3   Rf   R]   R   Re   R   R7   R#   R$   Ra   R`   (   R<   RA   R[   t   op_namet   bad_scalar_msgt	   other_arrRg   R\   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   _inequality  s2    !$$c         C` s   |  j  | t j d d ƒ S(   NRn   sg   Comparing a sparse matrix with a scalar greater than zero using < is inefficient, try using >= instead.(   Rv   Rb   t   lt(   R<   RA   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   __lt__6  s    c         C` s   |  j  | t j d d ƒ S(   NRm   sd   Comparing a sparse matrix with a scalar less than zero using > is inefficient, try using <= instead.(   Rv   Rb   t   gt(   R<   RA   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   __gt__<  s    c         C` s   |  j  | t j d d ƒ S(   NRk   sg   Comparing a sparse matrix with a scalar greater than zero using <= is inefficient, try using > instead.(   Rv   Rb   t   le(   R<   RA   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   __le__B  s    c         C` s   |  j  | t j d d ƒ S(   NRl   sd   Comparing a sparse matrix with a scalar less than zero using >= is inefficient, try using < instead.(   Rv   Rb   t   ge(   R<   RA   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   __ge__H  s    c         C` sÛ   | j  |  j  k r! t d ƒ ‚ n  t |  j j | j j ƒ } |  j d ƒ d } t j | d | d | d t ƒ} |  j |  j  ƒ \ } } | j	 j
 rš | n | j } t j | | |  j |  j |  j | ƒ t j | d t ƒS(   Ns   Incompatible shapes.t   CFi    R   t   orderR    (   R   R7   R   R   t   charR/   R*   R6   R5   t   flagst   c_contiguoust   TR   t   csr_todenseR0   R.   R-   t   matrixR;   (   R<   RA   R   R€   t   resultR>   R?   t   y(    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt
   _add_denseR  s    !%c         C` s   |  j  | d ƒ S(   Nt   _plus_(   Rf   (   R<   RA   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   _add_sparse]  s    c         C` s   |  j  | d ƒ S(   Nt   _minus_(   Rf   (   R<   RA   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   _sub_sparse`  s    c         C` sø  t  | ƒ r |  j | ƒ St | ƒ r÷|  j | j k rV |  j | ƒ } |  j | d ƒ S| j d
 k r| |  j | j ƒ  d ƒ S|  j d k r¢ | 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 d | j d | j d f ƒ} |  j | ƒ S|  j d d k rþ|  j d | j d k rþt	 |  j ƒ  j
 ƒ  d g f d |  j d |  j d f ƒ} | j | ƒ S| j d d k rs|  j d | j d k rst	 | j ƒ  j
 ƒ  d g f d | j d | j d f ƒ} | j |  ƒ S|  j d d k rè|  j d | j d k rèt	 |  j ƒ  j
 ƒ  d g f d |  j d |  j d f ƒ} | j | ƒ St d ƒ ‚ n  t j | ƒ } | j d k r+t j |  j ƒ  | ƒ S| j d k rN|  j | j d ƒ S|  j d k rwt j |  j ƒ  d | ƒ Sd d l m } |  j ƒ  } |  j | j k rÍt j | j | | j | j f ƒ } n|  j d d k rë| j d d k rt j | j | ƒ } nQ | j d |  j d k rP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 d | j d |  j d f d	 t ƒS|  j d d k r| j d d k r9t j | j d d … d f | ƒ } nU | 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 d |  j d | j d f d	 t ƒS| j d d k r{|  j d | j d k r{t j | j | d d … | j f j
 ƒ  ƒ } n^ | j d d k rÍ|  j d | j d k rÍt j | j | | j j
 ƒ  ƒ } n t d ƒ ‚ | j t j ƒ j
 ƒ  | _ | S(   sP   Point-wise multiplication by another matrix, vector, or
        scalar.
        t   _elmul_i   i    R   s   inconsistent shapesi   (   R   NR    (   i   i   (   i    i    (   i   i   (   i    i    (   i   i   (   i    i    (    R   t   _mul_scalarR   R   R3   Rf   t   toarrayt   _mul_sparse_matrixt   tocscR   t   ravelR7   R*   t
   atleast_2dRQ   t   multiplyt   sizet   flatR2   R   t   tocooR-   RK   t   colt   repeatt   arangeR1   t   tilet   viewt   ndarrayR;   R4   (   R<   RA   R    R   t   retR-   RK   R™   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyR•   c  sŽ    &&----(++'(/+'-1-%c         C` sx   |  j  \ } } t j | d t |  j j | j j ƒ ƒ} t t |  j d ƒ } | | | |  j	 |  j
 |  j | | ƒ | S(   NR   t   _matvec(   R   R*   R+   R   R   R   t   getattrR   R#   R0   R.   R-   (   R<   RA   R>   R?   R‡   t   fn(    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   _mul_vectorË  s    %c      	   C` sš   |  j  \ } } | j  d } t j | | f d t |  j j | j j ƒ ƒ} t t |  j d ƒ } | | | | |  j	 |  j
 |  j | j ƒ  | j ƒ  ƒ | S(   Ni   R   t   _matvecs(   R   R*   R+   R   R   R   R¡   R   R#   R0   R.   R-   R“   (   R<   RA   R>   R?   t   n_vecsR‡   R¢   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   _mul_multivectorØ  s    c         C` s7  |  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 |
 d t |  j | j ƒ ƒ} t t	 |  j
 d ƒ }	 |	 | | t j |  j d | ƒt j |  j d | ƒ|  j t j | j d | ƒt j | j d | ƒ| j | | | ƒ |  j | | | f d | | f ƒS(	   Ni    R   i   R   t   _matmat_pass1iÿÿÿÿt   _matmat_pass2R   (   R   R/   R3   R   R0   R.   R*   Rp   R¡   R   R#   R8   R   R   R-   (   R<   RA   R>   t   K1t   K2R?   t
   major_axisR@   R0   R¢   RS   R.   R-   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyR‘   æ  s>    	
	$i    c         C` sÅ   |  j  \ } } | | k s( | | k r7 t d ƒ ‚ n  t t |  j d ƒ } t j t | t | d ƒ | t | d ƒ ƒ d t	 |  j
 ƒ ƒ} | | |  j  d |  j  d |  j |  j |  j | ƒ | S(   Ns   k exceeds matrix dimensionst	   _diagonali    R   i   (   R   R7   R¡   R   R#   R*   Rp   RT   R)   R   R   R0   R.   R-   (   R<   t   kt   rowst   colsR¢   Rˆ   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   diagonal  s    /&c         C` s"  t  | ƒ r× | | ƒ r{ t d t d d ƒt j |  j d t j | ƒ j ƒ} | j | ƒ |  j	 | ƒ } |  j
 | | ƒ S|  j ƒ  | |  j t j | ƒ ƒ } |  j	 | |  j |  j f d | j d |  j ƒ} | SnG t | ƒ rö | |  j ƒ  | ƒ St | ƒ r|  j
 | | ƒ St d ƒ ‚ d  S(   NsI   Taking maximum (minimum) with > 0 (< 0) number results to a dense matrix.RN   i   R   R   s   Operands not compatible.(   R   R   R   R*   Rp   R   R8   R   Rr   R3   Rf   RX   R-   R.   R0   R   Re   R   R7   (   R<   RA   t   npopRs   t   dense_checkRu   t   new_datat   mat(    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   _maximum_minimum  s&    $
c         C` s   |  j  | t j d d „  ƒ S(   Nt	   _maximum_c         S` s   t  j |  ƒ d k S(   Ni    (   R*   R8   (   RW   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   <lambda>7  s    (   Rµ   R*   t   maximum(   R<   RA   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyR¸   5  s    c         C` s   |  j  | t j d d „  ƒ S(   Nt	   _minimum_c         S` s   t  j |  ƒ d k  S(   Ni    (   R*   R8   (   RW   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyR·   =  s    (   Rµ   R*   t   minimum(   R<   RA   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyRº   ;  s    c         C` s  t  |  d ƒ rö | |  j d d f ƒ d k rö t |  j ƒ } t j t |  j ƒ d d | ƒ} |  j t j	 ƒ \ } } | | | <t j
 | ƒ } | d d k r­ | j } n  | d
 k	 rÚ | j | j k rÚ t d ƒ ‚ n  | j d d d | d	 | ƒ St j |  d | d | d	 | ƒSd
 S(   s~   Sum the matrix over the given axis.  If the axis is None, sum
        over both rows and columns, returning a scalar.
        t	   blocksizei   iÿÿÿÿi    i   R   s   dimensions do not matchRH   t   outN(   i   iÿÿÿÿ(   i    i   (    (   t   hasattrR/   R   R   R*   R+   R1   R0   t   _minor_reducet   addt   asmatrixR„   R4   R   R7   t   sumR   (   R<   RH   R   R¼   t	   res_dtypeRŸ   t   major_indext   value(    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyRÁ   E  s    "
c         C` s\   | d k r |  j } n  t j t j |  j ƒ ƒ } | j | t |  j | ƒ ƒ } | | f S(   s›  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(   R4   R-   R*   t   flatnonzeroRG   R0   t   reduceatR   (   R<   t   ufuncR-   RÃ   RÄ   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyR¾   b  s    	c         C` sì  |  j  | ƒ \ } } |  j | | ƒ \ } } t | ƒ r>| j d d k o\ | j d d k } | j d d k o‚ | j d d k } | s¥ | j d | j d k oÂ | pÂ | j d | j d k sÔ t d ƒ ‚ n  |  j | j ƒ  | j ƒ  f ƒ \ } } |  j | | ƒ | j d t	 ƒ } | j
 ƒ  | j | j }	 }
 t j | j d |  j ƒ} | r¸t j t j | j d ƒ t |	 ƒ ƒ }	 t j |
 | j d ƒ }
 t j | | j d ƒ } n  | rt j |	 | j d ƒ }	 t j t j | j d ƒ t |
 ƒ ƒ }
 t j | | j d ƒ } n  | |	 |
 f } | |	 |
 f } nQ t j | d |  j ƒ} t j | | ƒ \ } } | j | j k rt d ƒ ‚ n  t j | ƒ d k r¨d  S|  j | j ƒ  | j ƒ  f ƒ \ } } |  j | | | j ƒ  ƒ d  S(   Ni    i   s   shape mismatch in assignmentR    R   (   t   _unpack_indext   _index_to_arraysR   R   R7   R/   R“   t
   _zero_manyR˜   R5   RX   RK   R™   R*   R8   R-   R   Rš   R›   R1   Rœ   t   broadcast_arraysR–   t	   _set_many(   R<   t   indexRW   RM   t   jt   broadcast_rowt   broadcast_colt   cit   cjt   rt   cRI   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   __setitem__|  s@    &&  '
(('c   	      C` s]  d |  j  k r d  S|  j  \ } } | j d k } | d k  r¸ | rY t | | | ƒ } n t | | | t | ƒ ƒ } t j | d |  j j ƒ} t j | d |  j j ƒ} | | 8} nx | rÔ t | | | ƒ } n t | | | t | ƒ ƒ } t j | d |  j j ƒ} t j | d |  j j ƒ} | | 7} | sI| t | ƒ  } n  | |  | | f <d  S(   Ni    R   (   R   RQ   RT   R1   R*   R›   R.   R   (	   R<   t   valuesR­   R>   R?   t	   broadcastt	   max_indexRM   RÎ   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   _setdiag¨  s(    
c         C` s   |  j  |  j ƒ \ } } d „  } | | | ƒ | | | ƒ t j | d |  j j ƒ} t j | d |  j j ƒ} | | | | f S(   Nc         S` sg   |  j  ƒ  } | | k r1 t d | | f ƒ ‚ n  |  j ƒ  } | | k  rc t d | | f ƒ ‚ n  d  S(   Ns   index (%d) out of range (>= %d)s   index (%d) out of range (< -%d)(   R)   t
   IndexErrorRT   (   R.   t   boundt   idx(    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   check_boundsÉ  s    R   (   R/   R   R*   R8   R.   R   (   R<   RM   RÎ   R>   R?   RÝ   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   _prepare_indicesÆ  s    	
c   
   	   C` so  |  j  | | ƒ \ } } } } t | ƒ } t j | d |  j j ƒ} t j | | |  j |  j | | | | ƒ } | d k r° |  j	 ƒ  t j | | |  j |  j | | | | ƒ n  d | k rÍ | |  j
 | <d St d j |  j ƒ t d d ƒ| d k }	 | |	 |  j
 | |	 <|	 }	 | |	 } | | d k  c | 7<| |	 } | | d k  c | 7<|  j | | | |	 ƒ d S(	   s   Sets value at each (i, j) to x

        Here (i,j) index major and minor respectively, and must not contain
        duplicate entries.
        R   i   iÿÿÿÿNsZ   Changing the sparsity structure of a {}_matrix is expensive. lil_matrix is more efficient.RN   i   i    (   RÞ   R1   R*   Rp   R.   R   R   t   csr_sample_offsetsR0   RX   R-   R   R#   R   t   _insert_many(
   R<   RM   RÎ   RW   R>   R?   t	   n_samplest   offsetsRŸ   t   mask(    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyRÌ   Ú  s0    

		

c      	   C` sË   |  j  | | ƒ \ } } } } t | ƒ } t j | d |  j j ƒ} t j | | |  j |  j | | | | ƒ } | d k r° |  j	 ƒ  t j | | |  j |  j | | | | ƒ n  d |  j
 | | d k <d S(   s‚   Sets value at each (i, j) to zero, preserving sparsity structure.

        Here (i,j) index major and minor respectively.
        R   i   i    iÿÿÿÿN(   RÞ   R1   R*   Rp   R.   R   R   Rß   R0   RX   R-   (   R<   RM   RÎ   R>   R?   Rá   Râ   RŸ   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyRÊ     s    

c         C` sƒ  t  j | d d ƒ} | j | d d ƒ} | j | d d ƒ} | j | d d ƒ} |  j } t |  j |  j f d |  j d | j ƒ} t  j |  j d | ƒ|  _ t  j |  j d | ƒ|  _ t  j | d | ƒ} t  j | d | ƒ} g  } g  } t  j	 | d t
 ƒ\ }	 }
 t  j |
 t | ƒ ƒ }
 t  j |
 ƒ } d	 } xKt t |	 |
 |
 d
 ƒ ƒ D]-\ } \ } } } |  j | } |  j | } | j |  j | | !ƒ | j |  j | | !ƒ t  j	 | | | !d d d … d t
 ƒ\ } } t | ƒ | | k r'| j | | | !ƒ | j | | | !ƒ nZ | j | | | !d d d … | ƒ | j | | | !d d d … | ƒ t | ƒ | | <| } qZW|  j | } | j |  j | ƒ | j |  j | ƒ t  j | ƒ |  _ t  j | ƒ |  _ t  j |  j j d | ƒ} | d	 ƒ | d	 <t  j |  j ƒ } | |	 c | 7<| | d
 )t  j | d | ƒ|  _ | rot |  _ |  j ƒ  n  |  j d t ƒ d S(   s:  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.
        RO   t	   mergesortt   modet   clipR   iÿÿÿÿR   t   return_indexi    i   NR¼   R!   (   R*   t   argsortt   taket   has_sorted_indicesR   R.   R0   R–   R8   t   uniqueR5   t   appendR1   RG   t	   enumeratet   izipR-   t   concatenateRp   R   t   cumsumR;   t   sort_indicesR:   (   R<   RM   RÎ   RW   R€   t   do_sortR@   t   indices_partst
   data_partst   uit	   ui_indptrt   new_nnzst   prevRÔ   t   iit   jst   jet   startt   stopt   ujt	   uj_indptrt   nnzst   indptr_diff(    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyRà     sZ    		2/%%

	c         C` s›  |  j  \ } } | d k  r( | | 7} n  | d k  rA | | 7} n  d | k oX | k  n s{ d | k ou | k  n rš t d | | | | f ƒ ‚ n  |  j | | f ƒ \ } } |  j | } |  j | d } |  j r^|  j j j | ƒ } |  j | | !}	 t j	 |	 | d d ƒ}
 |
 t j	 |	 |
 | d d ƒ} |  j
 | |
 | | !j d |  j ƒ St j | |  j | | !k |  j
 | | !ƒ j d |  j ƒ Sd  S(   Ni    s'   index out of bounds: 0<=%d<%d, 0<=%d<%di   t   sidet   leftt   rightR   (   R   RÚ   R/   R0   Rê   R.   R   t   typeR*   t   searchsortedR-   RÁ   t   compress(   R<   RK   R™   R>   R?   RÃ   t   minor_indexRü   t   endt   minor_indicest   insert_pos_leftt   insert_pos_right(    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   _get_single_element^  s,    :		c      
   C` s  |  j  | | f ƒ \ } } |  j  |  j ƒ \ } } d „  } d „  } | | | ƒ \ } } | | | ƒ \ }	 }
 | | | | ƒ | |	 |
 | ƒ t j | | |  j |  j |  j | | |	 |
 ƒ	 } | d | d | d } } } |  j  | | |
 |	 f ƒ } |  j | | | f d | ƒS(   s:   Return a submatrix of this matrix (new matrix is created).c         S` sÔ   t  |  t ƒ rˆ |  j |  j } } | d  k r7 d } n | d k  rP | | } n  | d  k re | } n | d k  r~ | | } n  | | f St j |  ƒ r¾ |  d k  r° |  | 7}  n  |  |  d f S|  d |  d f Sd  S(   Ni    i   (   R&   t   sliceRü   Rý   R4   R*   t   isscalar(   t   slt   numt   i0t   i1(    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   _process_slice  s     		
c         S` sr   d |  k o | k  n sG d | k  o4 | k n sG |  | k  rn t  d j d |  d | d | ƒ ƒ ‚ n  d  S(   Ni    s<   index out of bounds: 0<={i0}<{num}, 0<={i1}<{num}, {i0}<{i1}R  R  R  (   RÚ   R#   (   R  R  R  (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt
   _in_bounds™  s    Gi   i   i    R   (   R/   R   R   t   get_csr_submatrixR0   R.   R-   R3   (   R<   t   slice0t   slice1t   shape0t   shape1R  R  R  R  t   j0t   j1t   auxR-   R.   R0   R   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   _get_submatrix{  s    		 c   	      C` s±   |  j  |  j ƒ \ } } |  j } t j t | ƒ d |  j j ƒ} t j | |  j	 | ƒ |  j  | | f ƒ \ } } d d l
 m } | |  j | | f f |  j d | d |  j ƒS(   NR   i   (   R   R    (   R/   R   R.   R*   Rp   R1   R   R   t	   expandptrR0   R2   R   R-   (	   R<   R    RB   RC   R
  t   major_indicesRK   R™   R   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyR˜   ²  s    	!$c         C` sÞ   | d  k r. | d  k r. |  j d ƒ d } n  |  j | | ƒ } | j j pU | j j sg t d ƒ ‚ n  | j j rˆ |  j ƒ  } | } n |  j ƒ  } | j	 } | j | j
 ƒ \ } } t j | | | j | j | j | ƒ | S(   Nt   cfi    s&   Output array must be C or F contiguous(   R4   R/   t   _process_toarray_argsR‚   Rƒ   t   f_contiguousR7   t   tocsrR’   R„   R   R   R…   R0   R.   R-   (   R<   R€   R¼   RW   Rˆ   R>   R?   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyR   ¿  s    		%c         C` sH   |  j  |  j ƒ \ } } t j | | |  j |  j |  j ƒ |  j ƒ  d S(   sU   Remove zero entries from the matrix

        This is an *in place* operation
        N(   R/   R   R   t   csr_eliminate_zerosR0   R.   R-   RR   (   R<   R>   R?   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyRZ   Ö  s    
c         C` sb   t  |  d t ƒ s t |  _ n= t |  d ƒ s[ t j t |  j ƒ d |  j |  j	 ƒ |  _
 n  |  j S(   s^  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.
        t   _has_sorted_indicest   _has_canonical_formati   (   R¡   R5   R;   R'  R½   R   t   csr_has_canonical_formatR1   R0   R.   t   has_canonical_format(   R<   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   __get_has_canonical_formatà  s    (c         C` s%   t  | ƒ |  _ | r! t |  _ n  d  S(   N(   t   boolR'  R5   Rê   (   R<   t   val(    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   __set_has_canonical_formatõ  s    t   fgett   fsetc         C` sh   |  j  r d S|  j ƒ  |  j |  j ƒ \ } } t j | | |  j |  j |  j ƒ |  j	 ƒ  t
 |  _  d S(   sk   Eliminate duplicate matrix entries by adding them together

        The is an *in place* operation
        N(   R)  Rñ   R/   R   R   t   csr_sum_duplicatesR0   R.   R-   RR   R5   (   R<   R>   R?   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyRX   ý  s    	


c         C` sD   t  |  d ƒ s= t j t |  j ƒ d |  j |  j ƒ |  _ n  |  j S(   s®   Determine whether the matrix has sorted indices

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

        R&  i   (   R½   R   t   csr_has_sorted_indicesR1   R0   R.   R&  (   R<   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   __get_sorted  s    
(c         C` s   t  | ƒ |  _ d  S(   N(   R+  R&  (   R<   R,  (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   __set_sorted  s    c         C` s   |  j  ƒ  } | j ƒ  | S(   s9   Return a copy of this matrix with sorted indices
        (   R    Rñ   (   R<   t   A(    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   sorted_indices!  s    
c         C` sE   |  j  sA t j t |  j ƒ d |  j |  j |  j ƒ t |  _  n  d S(   s3   Sort the indices of this matrix *in place*
        i   N(   Rê   R   t   csr_sort_indicesR1   R0   R.   R-   R5   (   R<   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyRñ   ,  s    	c         C` sÂ   |  j  |  j ƒ d } t |  j ƒ | d k r> t d ƒ ‚ n  t |  j ƒ |  j k  re t d ƒ ‚ n  t |  j ƒ |  j k  rŒ t d ƒ ‚ n  t |  j |  j  ƒ |  _ t |  j |  j  ƒ |  _ d S(   s8   Remove empty space after all non-zero elements.
        i    i   s    index pointer has invalid lengths)   indices array has fewer than nnz elementss&   data array has fewer than nnz elementsN(	   R/   R   R1   R0   R7   R.   RS   R-   R   (   R<   RB   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyRR   5  s    c         G` s$  t  | ƒ } t |  d ƒ rª |  j \ } } t | d | ƒ \ } } t | d | ƒ \ } } | sh | r„ t d |  j | f ƒ ‚ n  |  j d | |  j d | } }	 n- |  j | ƒ \ } } |  j |  j ƒ \ } }	 | | k  r(|  j |  j |  |  _ |  j	 |  j |  |  _	 |  j | d  |  _ nJ | | k rrt
 j |  j | d ƒ |  _ |  j | d j |  j | ƒ n  | |	 k  r|  j | k  }
 t
 j |
 ƒ s|  j |
 |  _ |  j	 |
 |  _	 |  j t
 j |
 ƒ \ } } |  j j d ƒ | |  j d | <t
 j |  j d |  j ƒqn  | |  _ d  S(   NR»   i    i   s.   shape must be divisible into %s blocks. Got %sR¼   (   R   R½   R»   t   divmodR7   R   R/   R.   R0   R-   R*   t   resizeRr   t   allR¾   R¿   Rð   R(   (   R<   R   t   bmt   bnt   new_Mt   rmt   new_Nt   rnR>   R?   Rã   RÃ   R,  (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyR8  D  s8    &"c         C` sr   | r@ |  j  | |  j j ƒ  |  j j ƒ  f d |  j d | j ƒS|  j  | |  j |  j f d |  j d | j ƒSd S(   sµ   Returns 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(   R3   R.   R    R0   R   R   (   R<   R-   R    (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyRY   m  s    	
c         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 rÒ t j	 | d t j ƒ}	 n$ t j	 | d t |  j | j ƒ ƒ}	 | |  j
 d |  j
 d	 t j |  j d | ƒt j |  j d | ƒ|  j t j | j d | ƒt j | j d | ƒ| j | | |	 ƒ |  j  |	 | | f d
 |  j
 ƒ}
 |
 j ƒ  |
 S(   s5   apply the binary operation fn to two sparse matrices.R   R   R^   Rn   Rm   Rk   Rl   i    i   R   (   R3   R¡   R   R#   RS   R   R0   R.   R*   Rp   R   R`   R   R   R8   R-   RR   (   R<   RA   R[   R¢   t   maxnnzR@   R0   R.   t   bool_opsR-   R4  (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyRf   {  s.    	$!
c         C` sÙ   | j  |  j  k r! t d ƒ ‚ n  |  j | d ƒ } t j | j t j ƒ rÏ t j |  j  d |  j ƒ} | j t j	 ƒ | j
 ƒ  \ } } d | | | f <| j ƒ  } | j | | j | j f <t j | ƒ } n | } | S(   s?   
        Divide this matrix by a second sparse matrix.
        s   inconsistent shapest   _eldiv_R   i    (   R   R7   Rf   R*   t
   issubdtypeR   t   inexactRp   Rr   t   nant   nonzeroR˜   R-   RK   R™   R†   (   R<   RA   RÓ   R¼   RK   R™   (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   _divide_sparse  s    N(:   t   __name__t
   __module__t   __doc__R4   R;   R"   RJ   R   R%   R5   R:   R]   Ri   Rj   Rv   Rx   Rz   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   RZ   t$   _cs_matrix__get_has_canonical_formatt$   _cs_matrix__set_has_canonical_formatt   propertyR)  RX   t   _cs_matrix__get_sortedt   _cs_matrix__set_sortedRê   R5  Rñ   RR   R8  RY   Rf   RG  (    (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyR      sx   PF			!		"				
				h			'				,			'		H		7	
											"	"()   RJ  t
   __future__R    R   R   t   __all__t   warningsR   Rb   t   numpyR*   t   scipy._lib.sixR   Rî   t   scipy._lib._utilR   t   baseR   R   R   R-   R	   R
   t   diaR   t    R   t   sputilsR   R   R   R   R   R   R   R   R   R   R   R   R   (    (    (    s6   lib/python2.7/site-packages/scipy/sparse/compressed.pyt   <module>   s   R