
\K]c           @` sj  d  Z  d d l m Z m Z m Z d d l Z d d l m Z d d l Z	 d d l
 Z
 d d l m Z m Z d d l m Z m Z m Z m Z d d l m Z d d l m Z m Z d d	 l m 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" d d l# m$ Z$ e j% d  Z& e& j'   Z( e( Z) e j% d  Z* e* j'   Z+ e j, Z, e, j'   Z- e	 j. Z/ e j. Z0 i d e j1 6d e j2 6d e j3 6d e j4 6Z5 d d  Z6 d   Z7 d   Z8 d   Z9 d dl d     YZ: d dm d     YZ; e j< d     Z= d!   Z> d"   Z? d#   Z@ d$   ZA d%   ZB d&   ZC d'   ZD d(   ZE d)   ZF eG d*  ZH e e	 jI e jJ e jJ  d+    ZK e$ re e
 jL e jJ e jJ  eK  n  e e	 jM e jJ e jJ  d,    ZM d-   ZN d.   ZO d/   ZP d0   ZQ e e	 jI e jJ e jJ e jJ  d1    ZR e jS   ZT e jU d2 eT  ZV e d3    ZW eX d4  ZY d5   ZZ e d6    Z[ e d7    Z\ e e	 j] j^  d8    Z_ e d9    Z` eX d:  Za e dn k rue e	 j] jb  d;    Zc e e	 j] jd  d<    Ze e e	 j] jf  d=    Zg e e	 j] jh  d>    Zi e e	 j] jj  d?    Zk e e	 j] jl  d d@   Zm n  e e	 j] jn  dA    Zo dB   Zp e ep  dC    Zq dD   Zr e er  dE    Zs dF   Zt e et  dG    Zu dH   Zv e ev  dI    Zw dJ   Zx e ex  dK    Zy dL   Zz e ez  dM    Z{ e e	 j] j|  dN dO   Z} dP   Z~ e e~  dQ    Z e e	 j] j  dR    Z e e	 j] j  dS dT   Z dU   Z e e	 j] j  dV    Z e e	 j] j  dW    Z dX   Z e e  dY    Z dZ   Z e e  d[    Z d\   Z e e	 j] j  d d]   Z e e	 j] j  d d^   Z e d_    Z e e	 j] j  d d`   Z e e	 j] j  da    Z e e	 j  d db   Z eX dc  Z dd   Z de   Z e do k r$e e	 j  d dg   Z n e e	 j  dh    Z di   Z dj   Z e e	 j  dk    Z d S(p   s.   
Implementation of linear algebra operations.
i    (   t   print_functiont   absolute_importt   divisionN(   t   ir(   t   typest   cgutils(   t   lower_builtint   impl_ret_borrowedt   impl_ret_new_reft   impl_ret_untracked(   t	   signature(   t   overloadt   register_jitable(   t   version(   R   (   t   numpy_supporti   (   t
   make_arrayt   _empty_nd_implt
   array_copyi   (   t   TypingError(   t   HAS_MATMUL_OPERATORi   i    t   st   dt   ct   zs   <BLAS function>c         C` s5   t  j |   } | d  k r1 t d | f   n  | S(   Ns   unsupported dtype for %s()(   t   _blas_kindst   gett   Nonet	   TypeError(   t   dtypet	   func_namet   kind(    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   get_blas_kind3   s    c          C` s4   y d d  l  }  Wn t k
 r/ t d   n Xd  S(   Ni    s*   scipy 0.16+ is required for linear algebra(   t   scipy.linalg.cython_blast   ImportError(   t   scipy(    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   ensure_blas:   s    c          C` s4   y d d  l  }  Wn t k
 r/ t d   n Xd  S(   Ni    s*   scipy 0.16+ is required for linear algebra(   t   scipy.linalg.cython_lapackR!   (   R"   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   ensure_lapackA   s    c         C` s%   |  j  | | |  } t j | |  S(   N(   t   get_constant_genericR   t   alloca_once_value(   t   contextt   buildert   tyt   valt   const(    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   make_constant_slotH   s    t   _BLASc           B` s5   e  Z d  Z d   Z e d    Z e d    Z RS(   sM   
    Functions to return type signatures for wrapped
    BLAS functions.
    c         C` s   t    d  S(   N(   R#   (   t   self(    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   __init__S   s    c         C` sX   t  | d |  } t j t j t j t j |  t j t j |   } t j d |  S(   Nt   underlying_floatt   numba_xxnrm2(   t   getattrR   t   intct   chart   intpt   CPointert   ExternalFunction(   t   clsR   t   rtypet   sig(    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyR2   V   s    c         C` s   t  j t  j t  j t  j t  j t  j t  j t  j |  t  j |  t  j t  j |  t  j t  j |  t  j |  t  j  } t  j d |  S(   Nt   numba_xxgemm(   R   R4   R5   R6   R7   R8   (   R9   R   R;   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyR<   a   s     (   t   __name__t
   __module__t   __doc__R0   t   classmethodR2   R<   (    (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyR.   M   s   	t   _LAPACKc           B` s   e  Z d  Z d   Z e d    Z e d    Z e d    Z e d    Z e d    Z	 e d    Z
 e d    Z e d	    Z e d
    Z e d    Z e d    Z RS(   sO   
    Functions to return type signatures for wrapped
    LAPACK functions.
    c         C` s   t    d  S(   N(   R%   (   R/   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyR0   |   s    c         C` sL   t  j t  j t  j t  j t  j |  t  j t  j t   } t  j d |  S(   Nt   numba_xxgetrf(   R   R4   R5   R6   R7   t   F_INT_nbtypeR8   (   R9   R   R;   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRB      s    c         C` sF   t  j t  j t  j t  j |  t  j t  j t   } t  j d |  S(   Nt   numba_ez_xxgetri(   R   R4   R5   R6   R7   RC   R8   (   R9   R   R;   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRD      s    c         C` s   t  j t  j t  j t  j t  j t  j |  t  j t  j |  t  j |  t  j |  t  j t  j |  t  j  } t  j d |  S(   Nt   numba_ez_rgeev(   R   R4   R5   R6   R7   R8   (   R9   R   R;   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRE      s    c         C` sv   t  j t  j t  j t  j t  j t  j |  t  j t  j |  t  j |  t  j t  j |  t  j  } t  j d |  S(   Nt   numba_ez_cgeev(   R   R4   R5   R6   R7   R8   (   R9   R   R;   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRF      s    c      	   C` sd   t  | d |  } t j t j t j t j t j t j |  t j t j |   } t j d |  S(   NR1   t   numba_ez_xxxevd(   R3   R   R4   R5   R6   R7   R8   (   R9   R   t   wtypeR;   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRG      s    c         C` s@   t  j t  j t  j t  j t  j |  t  j  } t  j d |  S(   Nt   numba_xxpotrf(   R   R4   R5   R6   R7   R8   (   R9   R   R;   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRI      s    c         C` s   t  | d |  } t j t j t j t j t j t j |  t j t j |  t j |  t j t j |  t j  } t j d |  S(   NR1   t   numba_ez_gesdd(   R3   R   R4   R5   R6   R7   R8   (   R9   R   t   stypeR;   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRJ      s    c         C` sL   t  j t  j t  j t  j t  j |  t  j t  j |   } t  j d |  S(   Nt   numba_ez_geqrf(   R   R4   R5   R6   R7   R8   (   R9   R   R;   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRL      s    c      	   C` sR   t  j t  j t  j t  j t  j t  j |  t  j t  j |   } t  j d |  S(   Nt   numba_ez_xxgqr(   R   R4   R5   R6   R7   R8   (   R9   R   R;   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRM      s    c         C` s   t  | d |  } t j t j t j t j t j t j |  t j t j |  t j t j |  t j t j t j   } t j d |  S(   NR1   t   numba_ez_gelsd(   R3   R   R4   R5   R6   R7   t   float64R8   (   R9   R   R:   R;   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRN      s    c      	   C` s^   t  j t  j t  j t  j t  j |  t  j t  j t  t  j |  t  j  } t  j d |  S(   Nt   numba_xgesv(   R   R4   R5   R6   R7   RC   R8   (   R9   R   R;   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRP   
  s    (   R=   R>   R?   R0   R@   RB   RD   RE   RF   RG   RI   RJ   RL   RM   RN   RP   (    (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRA   v   s   	

c         c` s  g  } g  } g  } x t  | j |  D] \ } } t | t j  sS | j d k rc | | }	 }
 nL | j d d  }	 t |	 |  } t |  | | | f  }
 | j	 |	 |
 f  | j	 |	  | j	 |
  q% Wt | j
 |  t |  f Vx* | D]" \ } } |  j j | | |  q Wd S(   s   
    Ensure that all array arguments are contiguous, if necessary by
    copying them.
    A new (sig, args) tuple is yielded.
    t   CFt   layoutt   CN(   t   zipt   argst
   isinstanceR   t   ArrayRR   t   copyR
   R   t   appendt   return_typet   tuplet   nrtt   decref(   R(   R)   R;   RU   t   newtyst   newargst   copiesR*   R+   t   newtyt   newvalt   copysig(    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   make_contiguous  s    "c         ` sA   d     f d   } |  j  | | t t j t j  | f  d S(   s.   
    Check whether *n* fits in a C `int`.
    i   i   i   c         ` s   |    k r t  d   n  d  S(   Ns$   array size too large to fit in C int(   t   OverflowError(   t   n(   t   _maxint(    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   impl8  s    NI       i(   t   compile_internalR
   R   t   noneR6   (   R(   R)   Rf   Rh   (    (   Rg   s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   check_c_int2  s    c         C` sR   | j  t j | |  d t + |  j |  } | j   | j d  Wd QXd S(   s[   
    Check the integer error return from one of the BLAS wrappers in
    _helperlib.c.
    t   likelys#   BLAS wrapper returned with an errorN(   t   if_thenR   t   is_not_nullt   Falset   get_python_apit
   gil_ensuret   fatal_error(   R(   R)   t   rest   pyapi(    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   check_blas_return@  s    "
c         C` sR   | j  t j | |  d t + |  j |  } | j   | j d  Wd QXd S(   s]   
    Check the integer error return from one of the LAPACK wrappers in
    _helperlib.c.
    Rl   s%   LAPACK wrapper returned with an errorN(   Rm   R   Rn   Ro   Rp   Rq   Rr   (   R(   R)   Rs   Rt   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   check_lapack_returnL  s    "
c      
   C` s   t  j t  j d  t t t t t t g  } | j j | d d }	 t |  }
 t  j	 t t
 |
   } t  j	 t t |   } | j |	 | | | | j | t  | j | t  | j | t  f  } t |  | |  d S(   sQ   
    Call the BLAS vector * vector product function for the given arguments.
    i    t   namet   numba_xxdotN(   R   t   FunctionTypet   IntTypet   ll_chart   intp_tt	   ll_void_pt   modulet   get_or_insert_functionR   t   Constantt   ordt   intt   callt   bitcastRu   (   R(   R)   t	   conjugateR   Rf   t   a_datat   b_datat   out_datat   fntyt   fnR   t   kind_valRs   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt
   call_xxdotX  s    	c         C` s  t  j t  j d  t t t t t t t t t t g
  } | j j | d d }	 | j }
 t	 |  | |
 d  } t	 |  | |
 d  } | j
 d k r | \ } } | d } n | \ } } | d } t |
  } t  j t t |   } t  j t | rt d	  n	 t d
   } | j |	 | | | | | j | t  | j | t  | | j | t  | j | t  | j | t  f
  } t |  | |  d S(   sQ   
    Call the BLAS matrix * vector product function for the given arguments.
    i    Rw   t   numba_xxgemvg      ?g        t   Fi    i   t   tRf   N(   R   Ry   Rz   R{   R|   R}   R~   R   R   R-   RR   R   R   R   R   R   Ru   (   R(   R)   t   do_transt   m_typet   m_shapest   m_datat   v_dataR   R   R   R   t   alphat   betat   mRf   t   ldaR   R   t   transRs   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   call_xxgemvn  s0    		
*c   !      ` s  t  j t  j d  t t t t t t t t t t t t t t g  }   j j | d d } | \ } } | \ } } | j } t	 |    | d  } t	 |    | d  } t  j
 t t d    t  j
 t t d         f d   } | | | |  \ } } } | | | |  \ } } } |  |	 |
  \ } } } t |  } t  j
 t t |   }   j | | | | | | |   j | t  | | | |   j | t  | | f  }  t |    |   d	 S(
   sQ   
    Call the BLAS matrix * matrix product function for the given arguments.
    i    Rw   R<   g      ?g        R   Rf   c         ` sN   |  j   j  k r  n  |  j  d k r4 | d n | d   j | t  f S(   NRS   i   i    (   RR   R   R}   (   R*   t   shapest   data(   R)   t   notranst   out_typeR   (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   get_array_param  s     N(   R   Ry   Rz   R{   R|   R}   R~   R   R   R-   R   R   R   R   R   Ru   (!   R(   R)   t   x_typet   x_shapest   x_datat   y_typet   y_shapest   y_dataR   t
   out_shapesR   R   R   R   t   kt   _kRf   R   R   R   R   t   transaR   t   data_at   transbt   ldbt   data_bt   _t   ldct   data_cR   R   Rs   (    (   R)   R   R   R   s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   call_xxgemm  s4    				
c         C` s7   d   } |  j  | | | |  } t |  | | j |  S(   s    
    np.dot(matrix, matrix)
    c         S` sL   |  j  \ } } | j  \ } } t j | | f |  j  } t j |  | |  S(   N(   t   shapet   npt   emptyR   t   dot(   t   at   bR   R   R   Rf   t   out(    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   dot_impl  s    (   Ri   R   RZ   (   R(   R)   R;   RU   R   Rs   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   dot_2_mm  s    	c         C` s7   d   } |  j  | | | |  } t |  | | j |  S(   s    
    np.dot(vector, matrix)
    c         S` sF   |  j  \ } | j  \ } } t j | f |  j  } t j |  | |  S(   N(   R   R   R   R   R   (   R   R   R   t   _mRf   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyR     s    (   Ri   R   RZ   (   R(   R)   R;   RU   R   Rs   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   dot_2_vm  s    	c         C` s7   d   } |  j  | | | |  } t |  | | j |  S(   s    
    np.dot(matrix, vector)
    c         S` sF   |  j  \ } } | j  \ } t j | f |  j  } t j |  | |  S(   N(   R   R   R   R   R   (   R   R   R   Rf   t   _nR   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyR     s    (   Ri   R   RZ   (   R(   R)   R;   RU   R   Rs   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   dot_2_mv  s    	c      	   C` s   | j  \ } } | j } t |  |  | | d  } t |  |  | | d  }	 t j | | j  \ }
 d   } |  j | | t t j	 | j   |  t
 |  | |
  t j | |  j |   } t |  | | | |
 | j |	 j |  | j |  S(   s<   
    np.dot(vector, vector)
    np.vdot(vector, vector)
    i    i   c         S` s7   |  j  \ } | j  \ } | | k r3 t d   n  d  S(   Ns;   incompatible array sizes for np.dot(a, b) (vector * vector)(   R   t
   ValueError(   R   R   R   Rf   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt
   check_args  s    (   RU   RZ   R   R   t   unpack_tupleR   Ri   R
   R   Rj   Rk   t   alloca_oncet   get_value_typeR   R   t   load(   R(   R)   R;   RU   R   t   atyt   btyR   R   R   Rf   R   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   dot_2_vv  s    		%c      	   C` s   t    t |  | | |   \ } } g  | j d  D] } | j ^ q3 } | d d g k rm t |  | | |  S| d d g k r t |  | | |  S| d d g k r t |  | | |  S| d d g k r t |  | | |  Sd s t  Wd QXd S(   s    
    np.dot(a, b)
    a @ b
    i   i   i    N(	   R#   Rd   RU   t   ndimR   R   R   R   t   AssertionError(   R(   R)   R;   RU   t   xt   ndims(    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   dot_2
  s    #c         C` sH   t    t |  | | |  & \ } } t |  | | | d t SWd QXd S(   s   
    np.vdot(a, b)
    R   N(   R#   Rd   R   t   True(   R(   R)   R;   RU   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   vdot#  s    c         C` s[   |  j  \ } | j  \ } } | | k r6 t d   n  | j  | f k rW t d   n  d  S(   Ns;   incompatible array sizes for np.dot(a, b) (vector * matrix)sF   incompatible output array size for np.dot(a, b, out) (vector * matrix)(   R   R   (   R   R   R   R   R   Rf   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   dot_3_vm_check_args.  s    c         C` s[   |  j  \ } } | j  \ } | | k r6 t d   n  | j  | f k rW t d   n  d  S(   Ns;   incompatible array sizes for np.dot(a, b) (matrix * vector)sF   incompatible output array size for np.dot(a, b, out) (matrix * vector)(   R   R   (   R   R   R   R   R   Rf   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   dot_3_mv_check_args9  s    c      	   C` s  | j  \ } } } | | j k s' t  | j } t |  |  | | d  } t |  |  | | d  }	 t |  |  | | d  }
 t j | | j  } t j | |	 j  } t j | |
 j  } | j | j k  r| } | } | j	 d k } |	 j
 | j
 } } t } n4 | } | } | j	 d k } | j
 |	 j
 } } t } |  j | | t t j | j   |  x | D] } t |  | |  qlWt |  | | | | | | |
 j
  t |  | | j |
 j    S(   sE   
    np.dot(vector, matrix, out)
    np.dot(matrix, vector, out)
    i    i   i   R   RS   (   RU   RZ   R   R   R   R   R   R   R   RR   R   R   R   Ri   R
   R   Rj   Rk   R   R   t	   _getvalue(   R(   R)   R;   RU   t   xtyt   ytyt   outtyR   R   t   yR   R   R   R   t   mtyR   R   R   R   R   R+   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   dot_3_vmC  s8    		c       !   C` s  | j  \ } } } | | j k s' t  | j } t |  |  | | d  } t |  |  | | d  }	 t |  |  | | d  }
 t j | | j  } t j | |	 j  } t j | |
 j  } | \ } } | \ } } | j d k s t  d   } |  j	 | | t
 t j | j   |  t |  | |  t |  | |  t |  | |  | j } |	 j } |
 j } t j t d  } | j d | |  } | j d | |  } | j |  @\ } } |  | j |  w \ } } | $ t |  | t | | | | |  Wd QX| 6 | j | j k } t |  | | | | | | |  Wd QXWd QXWd QX|  | j |   \ } } | 6 | j | j k } t |  | | | | | | |  Wd QX| - t |  | | | | | | | | | |  Wd QXWd QXWd QXWd QXt |  | | j |
 j    S(   s%   
    np.dot(matrix, matrix, out)
    i    i   i   RS   c         S` sa   |  j  \ } } | j  \ } } | | k r9 t d   n  | j  | | f k r] t d   n  d  S(   Ns;   incompatible array sizes for np.dot(a, b) (matrix * matrix)sF   incompatible output array size for np.dot(a, b, out) (matrix * matrix)(   R   R   (   R   R   R   R   R   R   Rf   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyR     s    s   ==N(   RU   RZ   R   R   R   R   R   R   RR   Ri   R
   R   Rj   Rk   R   R   R   R|   t   icmp_signedt   if_elseR   Ro   R   R   R   R   (    R(   R)   R;   RU   R   R   R   R   R   R   R   R   R   R   R   R   R   Rf   R   R   R   R   t   onet   is_left_vect   is_right_vect   r_vect   r_matt   v_vt   m_vR   t   v_mt   m_m(    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   dot_3_mmr  s^    		
			%			%c      	   C` s   t    t |  | | |   \ } } t d   | j d  D  } | t d g  k rj t |  | | |  S| t d d g  k r t |  | | |  Sd s t  Wd QXd S(   s   
    np.dot(a, b, out)
    c         s` s   |  ] } | j  Vq d  S(   N(   R   (   t   .0R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pys	   <genexpr>  s    i   i   i    N(   R#   Rd   t   setRU   R   R   R   (   R(   R)   R;   RU   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   dot_3  s    t   numba_fatal_errorc         C` sH   xA t  j |   D]0 } t  j | j    s t  j j d   q q Wd  S(   Ns$   Array must not contain infs or NaNs.(   R   t   nditert   isfinitet   itemt   linalgt   LinAlgError(   R   t   v(    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _check_finite_matrix  s    	c         C` s   | r d n d } | | f } t  |  t j  r< |  j }  n  t  |  t j  sm d | } t | d t  n  |  j d k s d | } t | d t  n  t  |  j t j	 t j
 f  s d | } t | d t  n  d  S(   Ns	   np.linalgR   s&   %s.%s() only supported for array typest   highlightingi   s%   %s.%s() only supported on 2-D arrays.s3   %s.%s() only supported on float and complex arrays.(   RV   R   t   Optionalt   typeRW   R   Ro   R   R   t   Floatt   Complex(   R   R   t	   la_prefixt   prefixt   interpt   msg(    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _check_linalg_matrix  s    

c         G` sT   | d j  } x@ | d D]4 } | j  | k r d |  } t | d t  q q Wd  S(   Ni    i   sA   np.linalg.%s() only supports inputs that have homogeneous dtypes.R   (   R   R   Ro   (   R   R   t   t0R   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _check_homogeneous_types  s
    
c         C` sV   |  d k rR |  d k  r. t    d s. t  n  |  d k rR t j j d   qR n  d  S(   Ni    s(   Matrix is singular to machine precision.(   t   fatal_error_funcR   R   R   R   (   t   r(    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _inv_err_handler  s    	c         C` s   |  d S(   sF   pass a list of variables to be preserved through dead code eliminationi    (    (   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _dummy_liveness_func  s    c         ` s   t    t |  d  t   j |  j   t   j |  j   t t |  j d    |  j d k        f d   } | S(   Nt   invR   c         ` s   |  j  d } |  j  d | k r; d } t j j |   n  t |     r] t j |   } n t j |   } | d k r| | St j | d t }   | | | j	 | | j	  } t
 |    | | j	 | | j	  } t
 |  t | j | j g  | S(   Niis.   Last 2 dimensions of the array must be square.i    R   (   R   R   R   R   R   RX   t   asfortranarrayR   t   F_INT_nptypet   ctypesR   R   t   size(   R   Rf   R   t   acpyt   ipivR   (   t   F_layoutR   RB   t   numba_xxgetri(    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   inv_impl  s"    
!

(	   R%   R   RA   RB   R   RD   R   R   RR   (   R   R  (    (   R  R   RB   R  s3   lib/python2.7/site-packages/numba/targets/linalg.pyR  	  s    c         C` sP   |  d k rL |  d k  r. t    d s. t  n  |  d k rL t d   qL n  d  S(   Ni    s&   Internal algorithm failed to converge.(   R   R   R   (   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt%   _handle_err_maybe_convergence_problem6  s    c         C` s   | r d n d } | | f } t  |  t j  sC t d |   n  |  j d k se t d |   n  t  |  j t j t j f  s t d |   n  d  S(   Ns	   np.linalgR   s'   %s.%s() only supported for array types i   s+   %s.%s() only supported on 1 and 2-D arrays s3   %s.%s() only supported on float and complex arrays.(   RV   R   RW   R   R   R   R   R   (   R   R   R   R   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _check_linalg_1_or_2d_matrix@  s    c         ` sr   t    t |  d  t   j |  j   t t |  j d    t d    t d  }     f d   } | S(   Nt   choleskyt   Ut   Lc         ` s   |  j  d } |  j  d | k r; d } t j j |   n  |  j   } | d k rW | S    | | j |  } | d k r | d k  r t   d s t  n  | d k r t j j d   q n  x* t |  D] } d | d  |  | f <q W| S(   Niis.   Last 2 dimensions of the array must be square.i    s    Matrix is not positive definite.(	   R   R   R   R   RX   R  R   R   t   range(   R   Rf   R   R   R   t   col(   t   UPR   RI   (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   cho_impl_  s$    	(   R%   R   RA   RI   R   R   R   (   R   t   LOR  (    (   R  R   RI   s3   lib/python2.7/site-packages/numba/targets/linalg.pyR  S  s    c         ` s   t    t |  d  t   j |  j   t   j |  j   t t |  j d    t d   t d   |  j d k         f d   }       f d   } t	 |  j t
 j j  r | S| Sd  S(   Nt   eigt   Nt   VR   c         ` s  |  j  d } |  j  d | k r; d } t j j |   n  t |     r] t j |   } n t j |   } d } | } t j | d |  j } t j | d |  j } t j | | f d |  j } t j | | f d |  j }	 | d k r | |	 j	 f S    | | j
 | | j
 | j
 | j
 | |	 j
 |  }
 t |
  t j |  rat d   n  t | j | j |	 j | j | j g  | |	 j	 f S(   s?   
            eig() implementation for real arrays.
            iis.   Last 2 dimensions of the array must be square.i   R   i    s.   eig() argument must not cause a domain change.(   R   R   R   R   R   RX   R   R   R   t   TR  R	  t   anyR   R   R  (   R   Rf   R   R  t   ldvlt   ldvrt   wrt   wit   vlt   vrR   (   R  t   JOBVLt   JOBVRR   RE   (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   real_eig_impl  sD    
	
(c   
      ` sT  |  j  d } |  j  d | k r; d } t j j |   n  t |     r] t j |   } n t j |   } d } | } t j | d |  j } t j | | f d |  j } t j | | f d |  j } | d k r | | j	 f S    | | j
 | | j
 | j
 | | j
 |  }	 t |	  t | j | j | j | j g  | | j	 f S(   sB   
            eig() implementation for complex arrays.
            iis.   Last 2 dimensions of the array must be square.i   R   i    (   R   R   R   R   R   RX   R   R   R   R  R  R	  R   R  (
   R   Rf   R   R  R  R  t   wR  R  R   (   R  R  R  R   RF   (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   cmplx_eig_impl  s:    
	
"(   R%   R   RA   RE   R   RF   R   R   RR   RV   R   t   scalarsR   (   R   R   R"  (    (   R  R  R  R   RF   RE   s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   eig_impl  s    ;+c         ` s   t    t |  d  t   j |  j   t   j |  j   t t |  j d    t d   t d   |  j d k         f d   }       f d   } t	 |  j t
 j j  r | S| Sd  S(   Nt   eigvalsR  R   c         ` sx  |  j  d } |  j  d | k r; d } t j j |   n  t |     r] t j |   } n t j |   } d } d } t j | d |  j } | d k r | St j | d |  j } t j d d |  j } t j d d |  j }	     | | j	 | | j	 | j	 | j	 | |	 j	 |  }
 t
 |
  t j |  rLt d   n  t | j | j |	 j | j | j g  | S(   sC   
            eigvals() implementation for real arrays.
            iis.   Last 2 dimensions of the array must be square.i   R   i    s2   eigvals() argument must not cause a domain change.(   R   R   R   R   R   RX   R   R   R   R  R	  R  R   R   R  (   R   Rf   R   R  R  R  R  R  R  R  R   (   R  R  R  R   RE   (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   real_eigvals_impl
  sD    
	
(c   
      ` s6  |  j  d } |  j  d | k r; d } t j j |   n  t |     r] t j |   } n t j |   } d } d } t j | d |  j } | d k r | St j d d |  j } t j d d |  j }     | | j	 | | j	 | j	 | | j	 |  }	 t
 |	  t | j | j | j | j g  | S(   sF   
            eigvals() implementation for complex arrays.
            iis.   Last 2 dimensions of the array must be square.i   R   i    (   R   R   R   R   R   RX   R   R   R   R  R	  R   R  (
   R   Rf   R   R  R  R  R!  R  R  R   (   R  R  R  R   RF   (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   cmplx_eigvals_implH  s:    
	
"(   R%   R   RA   RE   R   RF   R   R   RR   RV   R   R#  R   (   R   R&  R'  (    (   R  R  R  R   RF   RE   s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   eigvals_impl  s    >,c         ` s   t    t |  d  |  j d k   t |  j d |  j  } t j |   t   j |  j   t	 t
 |  j d    t	 d   t	 d          f d   } | S(   Nt   eighR   R1   R  R  c         ` s   |  j  d } |  j  d | k r; d } t j j |   n  t |     r] t j |   } n t j |   } t j | d  } | d k r | | f S    | | j | | j  } t	 |  t
 | j | j g  | | f S(   Niis.   Last 2 dimensions of the array must be square.R   i    (   R   R   R   R   R   RX   R   R   R  R	  R   R  (   R   Rf   R   R  R!  R   (   R  t   JOBZt   UPLOR   RG   t   w_dtype(    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt	   eigh_impl  s*    


(   R%   R   RR   R3   R   t
   np_supportt   as_dtypeRA   RG   R   R   (   R   t   w_typeR-  (    (   R  R*  R+  R   RG   R,  s3   lib/python2.7/site-packages/numba/targets/linalg.pyR-  y  s    !c         ` s   t    t |  d  |  j d k   t |  j d |  j  } t j |   t   j |  j   t	 t
 |  j d    t	 d   t	 d          f d   } | S(   Nt   eigvalshR   R1   R  R  c         ` s   |  j  d } |  j  d | k r; d } t j j |   n  t |     r] t j |   } n t j |   } t j | d  } | d k r | S    | | j | | j  } t	 |  t
 | j | j g  | S(   Niis.   Last 2 dimensions of the array must be square.R   i    (   R   R   R   R   R   RX   R   R   R  R	  R   R  (   R   Rf   R   R  R!  R   (   R  R*  R+  R   RG   R,  (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   eigvalsh_impl  s*    

(   R%   R   RR   R3   R   R.  R/  RA   RG   R   R   (   R   R0  R2  (    (   R  R*  R+  R   RG   R,  s3   lib/python2.7/site-packages/numba/targets/linalg.pyR2    s    !c         ` s   t    t |  d  |  j d k   t |  j d |  j  } t j |   t   j |  j   t	 t
 |  j d    t	 d   t	 d   d        f d  } | S(   Nt   svdR   R1   t   At   Si   c         ` s  |  j  d } |  j  d } | d k s2 | d k rG t j j d   n  t |     ri t j |   } n t j |   } | } t | |  } | r  } | } | }	 n  } | } | }	 t j | | f d |  j	 }
 t j | d  } t j | |	 f d |  j	 }   | | | | j
 | | j
 |
 j
 | | j
 |	  } t |  t | j | j |
 j | j g  |
 j | | j f S(   Niii    s   Arrays cannot be emptyR   (   R   R   R   R   R   RX   R   t   minR   R   R  R	  R   R  R  (   R   t   full_matricesRf   R   R  t   ldut   minmnR*  t   ucolt   ldvtt   uR   t   vtR   (   R  t   JOBZ_At   JOBZ_SR   RJ   t   s_dtype(    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   svd_impl  sF    
		
"(   R%   R   RR   R3   R   R.  R/  RA   RJ   R   R   (   R   R7  t   s_typeRA  (    (   R  R>  R?  R   RJ   R@  s3   lib/python2.7/site-packages/numba/targets/linalg.pyRA    s    !1c         ` s   t    t |  d  t   j |  j   t   j |  j   t t |  j d    |  j d k        f d   } | S(   Nt   qrR   c         ` s  |  j  d } |  j  d } | d k s2 | d k rG t j j d   n  t |     ri t j |   } n t j |   } | } t | |  } t j | d |  j	 }   | | | j
 | | j
  } | d k  r t   d s t  n  t j | | f d |  j	 j } xI t |  D]; }	 x2 t |	 d  D]  }
 | |
 |	 f | |
 |	 f <q-WqWxH t | |  D]7 }	 x. t |  D]  }
 | |
 |	 f | |
 |	 f <qxWqeW  | | | | j
 | | j
  } t |  t | j | j g  | d  d   d  |  f | f S(   Niii    s   Arrays cannot be emptyR   i   (   R   R   R   R   R   RX   R   R6  R   R   R  R   R   t   zerosR  R  R	  R   R  (   R   Rf   R   t   qR   R9  t   taut   retR   t   it   j(   R  R   RL   RM   (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   qr_impl?  sN    
!""
(	   R%   R   RA   RL   R   RM   R   R   RR   (   R   RJ  (    (   R  R   RL   RM   s3   lib/python2.7/site-packages/numba/targets/linalg.pyRJ  ,  s    <c         C` s
   t   d S(   s;   
    Correctly copy 'b' into the 'bcpy' scratch space.
    N(   t   NotImplementedError(   t   bcpyR   t   nrhs(    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _system_copy_in_b  s    c         C` s-   | j  d k r d   } | Sd   } | Sd  S(   Ni   c         S` s!   | |  d  | j  d  d f <d  S(   Nii    (   R   (   RL  R   RM  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt	   oneD_impl  s    c         S` s'   | |  d  | j  d  d  |  f <d  S(   Ni(   R   (   RL  R   RM  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt	   twoD_impl  s    (   R   (   RL  R   RM  RO  RP  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _system_copy_in_b_impl  s
    		c         C` s
   t   d S(   sK   
    Compute the number of right hand sides in the system of equations
    N(   RK  (   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _system_compute_nrhs  s    c         C` s-   |  j  d k r d   } | Sd   } | Sd  S(   Ni   c         S` s   d S(   Ni   (    (   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRO    s    c         S` s   |  j  d S(   Ni(   R   (   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRP    s    (   R   (   R   RO  RP  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _system_compute_nrhs_impl  s
    		c         C` s
   t   d S(   sD   
    Check that AX=B style system input is dimensionally valid.
    N(   RK  (   R   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt!   _system_check_dimensionally_valid  s    c         C` s3   | j  } | d k r" d   } | Sd   } | Sd  S(   Ni   c         S` s?   |  j  d } | j  d } | | k r; t j j d   n  d  S(   Niis<   Incompatible array sizes, system is not dimensionally valid.(   R   R   R   R   (   R   R   t   amt   bm(    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRO    s
    	c         S` s?   |  j  d } | j  d } | | k r; t j j d   n  d  S(   Nis<   Incompatible array sizes, system is not dimensionally valid.(   R   R   R   R   (   R   R   RU  RV  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRP    s
    	(   R   (   R   R   R   RO  RP  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt&   _system_check_dimensionally_valid_impl  s    			c         C` s
   t   d S(   s:   
    Check that AX=B style system input is not empty.
    N(   RK  (   R   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _system_check_non_empty  s    c         C` s3   | j  } | d k r" d   } | Sd   } | Sd  S(   Ni   c         S` sd   |  j  d } |  j  d } | j  d } | d k sK | d k sK | d k r` t j j d   n  d  S(   Niii    s   Arrays cannot be empty(   R   R   R   R   (   R   R   RU  t   anRV  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRO    s
    $c         S` s}   |  j  d } |  j  d } | j  d } | j  d } | d k sd | d k sd | d k sd | d k ry t j j d   n  d  S(   Niii    s   Arrays cannot be empty(   R   R   R   R   (   R   R   RU  RY  RV  t   bn(    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRP    s    0(   R   (   R   R   R   RO  RP  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _system_check_non_empty_impl  s    			c         C` s
   t   d S(   s:   
    Compute the residual from the 'b' scratch space.
    N(   RK  (   R   Rf   RM  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _lstsq_residual  s    c         ` s   |  j  } |  j } t j t | d |     | d k rt t | t j  r^   f d   } | S  f d   } | SnJ | d k s t  t | t j  r   f d   } | S  f d   } | Sd  S(   NR1   i   c         ` sI   t  j d d   } t  j t  j |  | d   d f  d  | d <| S(   Ni   R   i    i   (   i   (   R   R   t   sumt   abs(   R   Rf   RM  Rs   (   t
   real_dtype(    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt
   cmplx_impl  s    0c         ` s@   t  j d d   } t  j |  | d   d f d  | d <| S(   Ni   R   i    i   (   i   (   R   R   R]  (   R   Rf   RM  Rs   (   R_  (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt	   real_impl  s    'i   c         ` s`   t  j | d   } xD t |  D]6 } t  j t  j |  | d   | f  d  | | <q" W| S(   NR   i   (   R   R   R  R]  R^  (   R   Rf   RM  Rs   R   (   R_  (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyR`    s    4c         ` sW   t  j | d   } x; t |  D]- } t  j |  | d   | f d  | | <q" W| S(   NR   i   (   R   R   R  R]  (   R   Rf   RM  Rs   R   (   R_  (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRa    s    +(	   R   R   R.  R/  R3   RV   R   R   R   (   R   Rf   RM  R   R   R`  Ra  (    (   R_  s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _lstsq_residual_impl  s    		c         C` s
   t   d S(   s   
    Extract 'x' (the lstsq solution) from the 'bcpy' scratch space.
    Note 'b' is only used to check the system input dimension...
    N(   RK  (   R   RL  Rf   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _lstsq_solution  s    c         C` s-   |  j  d k r d   } | Sd   } | Sd  S(   Ni   c         S` s   | j  j   |  S(   N(   R  t   ravel(   R   RL  Rf   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRO    s    c         S` s    | d  |  d  d   f j    S(   N(   RX   (   R   RL  Rf   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRP    s    (   R   (   R   RL  Rf   RO  RP  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _lstsq_solution_impl  s
    		g      c         ` s   t    t |  d  t | d  |  j d k   | j d k } t d |  |  t j |  j   |  j } t | d |  } t j |   t	   j
 |  j   t t | d    d       f d  } | S(   Nt   lstsqR   R1   g      c         ` s  |  j  d } |  j  d } t |  } t |   t |  t |  |  t |  |  t | |  } t | |  }   r t j |   } n t j	 |   } t j
 | | f d  j }	 t |	 | |  t j
 | d  }
 t j
 d d t j }   | | | | j | |	 j | |
 j | | j  } t |  | d } | | k  sV| | k rnt j
 d d  } n t |	 | |  } t | |	 |  } t | j |	 j |
 j | j g  | | | |
 |  f S(   NiiR   i   i    (   R   RR  R   RX  RT  R6  t   maxR   RX   R   R   R  RN  t   int32R  R	  R\  Rc  R   R  (   R   R   t   rcondRf   R   RM  R9  t   maxmnR  RL  R   t   rank_ptrR   t   rankRs   R   (   t
   a_F_layoutR   t   np_dtRN   R_  (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt
   lstsq_implA  sH    



"(   R%   R   R
  RR   R   R.  R/  R   R3   RA   RN   R   R   (   R   R   Ri  t
   b_F_layoutt   nb_dtt   r_typeRo  (    (   Rm  R   Rn  RN   R_  s3   lib/python2.7/site-packages/numba/targets/linalg.pyRo  !  s    	Bc         C` s
   t   d S(   s   
    Extract 'x' (the solution) from the 'bcpy' scratch space.
    Note 'b' is only used to check the system input dimension...
    N(   RK  (   R   RL  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _solve_compute_return  s    c         C` s-   |  j  d k r d   } | Sd   } | Sd  S(   Ni   c         S` s   | j  j   S(   N(   R  Rd  (   R   RL  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRO    s    c         S` s   | S(   N(    (   R   RL  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRP    s    (   R   (   R   RL  RO  RP  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _solve_compute_return_impl  s
    		c         ` s   t    t |  d  t | d  |  j d k   | j d k } t d |  |  t j |  j   |  j } t   j	 |  j   t
 t | d         f d   } | S(   Nt   solveR   c      	   ` s  |  j  d } t |  } t |   t |  t |  |    rR t j |   } n t j |   } t j | | f d  j } | d k r t	 | |  St
 | | |  t j | d t }   | | | j | | j | j |  } t |  t | j | j | j g  t	 | |  S(   NiR   i    (   R   RR  R   RT  R   RX   R   R   R  Rs  RN  R  R  R   R   R  (   R   R   Rf   RM  R  RL  R  R   (   Rm  R   Rn  RP   (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt
   solve_impl  s2    

	
(   R%   R   R
  RR   R   R.  R/  R   RA   RP   R   R   (   R   R   Rp  Rq  Rv  (    (   Rm  R   Rn  RP   s3   lib/python2.7/site-packages/numba/targets/linalg.pyRv    s    	,gV瞯<c         ` s#  t    t |  d  t |  j d |  j  } t j |   t   j |  j   t   j	 |  j   |  j
 d k   t t |  j d    t d   t d   t d   t j |  j  } t j d g d | 	 t j d g d |  d	           	 f
 d
  } | S(   Nt   pinvR1   R   R5  RS   g        R   g      ?gV瞯<c         ` s  |  j  d } |  j  d } t |     r< t j |   } n t j |   } | d k sc | d k r | j j   j |  j   j St | |  } t j	 | | f d |  j
 } t j	 | d  } t j	 | | f d |  j
 }    | | | j | | j | j | | j |  }	 t |	  | d | }
 d } x? t |  D]1 } | | |
 k r@d | | | | <| } q@q@W| d 7} | | k rx t |  D]? } x6 t |  D]( } | | | f | | | | | f <qWqWnV xS t |  D]E } | | } x2 t |  D]$ } | | | f | | | | f <qWqW    | | |  j | j | | j | 	 j | j |  }	 t | j | j | j | j  j 	 j g  | j j   j |  j   j S(   Niii    R   g      ?i   (   R   R   R   RX   R   R  Rd  t   reshapeR6  R   R   R  R	  R  R   R  (   R   Ri  Rf   R   R  R9  R<  R   R=  R   t   cut_att   cut_idxR   RH  RI  t   s_local(
   R  t   JOBt   TRANSAt   TRANSBR   RJ   R<   R   R@  t   zero(    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt	   pinv_impl  st    '
	

-
&		
!(   R%   R   R3   R   R.  R/  RA   RJ   R.   R<   RR   R   R   R   t   array(   R   Ri  RB  t   dtR  (    (
   R  R|  R}  R~  R   RJ   R<   R   R@  R  s3   lib/python2.7/site-packages/numba/targets/linalg.pyR    s     -c         C` s?   t  |  j t j  r( t d    } | St d    } | Sd S(   s   
    Walks the diag of a LUP decomposed matrix
    uses that det(A) = prod(diag(lup(A)))
    and also that log(a)+log(b) = log(a*b)
    The return sign is adjusted based on the values found
    such that the log(value) stays in the real domain.
    c         S` su   | d } d } xX t  |   D]J } t j | | | f  } | | | | f | } | t j |  } q W| | f S(   Ny                g        (   R  R   R^  t   log(   Rf   R   t   sgnt   csgnt   accR   t   absel(    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   cmplx_diag_walker  s    
c         S` sk   d } xT t  |   D]F } | | | f } | d k  rF | } | } n  | t j |  } q W| d | f S(   Ng        (   R  R   R  (   Rf   R   R  R  R   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   real_diag_walker  s    
N(   RV   R   R   R   R   (   R   R  R  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _get_slogdet_diag_walker  s
    
c         ` s   t    t |  d  t   j |  j   t t |  j d    |  j d k   t |    |  j d   t	 |  j d |  j  d          f d   } | S(   Nt   slogdetR   i   R1   i    c         ` sP  |  j  d } |  j  d | k r; d } t j j |   n  | d k rQ   f St |     rs t j |   } n t j |   } t j | d t }   | | | j	 | | j	  } | d k r d t j
 f St |  d } x, t |  D] } | | | | d k } q W| d @} | d k r0d } n  t | j g   | | |  S(   Niis.   Last 2 dimensions of the array must be square.i    R   g        i   (   R   R   R   R   R   RX   R   R   R  R  t   infR   R  R   R  (   R   Rf   R   R  R  R   R  R   (   R  t   ONEt   ZEROt   diag_walkerR   RB   (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   slogdet_impl  s.    

!
	
	(
   R%   R   RA   RB   R   R   R   RR   R  R3   (   R   R  (    (   R  R  R  R  R   RB   s3   lib/python2.7/site-packages/numba/targets/linalg.pyR    s    ,c         C` s!   t    t |  d  d   } | S(   Nt   detc         S` s)   t  j j |   \ } } | t  j |  S(   N(   R   R   R  t   exp(   R   R  R  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   det_impl  s    (   R%   R   (   R   R  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyR    s    	c         C` s
   t   d S(   s)   
    Compute singular values of *a*.
    N(   RK  (   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _compute_singular_values  s    c         ` s   t    j |  j   t t |  j d    t d   t |  j d |  j  } t j |   t j |  j  } t j	 d d |  t j	 d	 d |  |  j
 d k           f d   } | S(
   s>   
    Returns a function to compute singular values of `a`
    R3  R  R1   i   R   R   c   
      ` s  |  j  d } |  j  d } | d k s2 | d k rG t j j d   n  t |   | } t | |  } d } d }   r t j |   } n t j |   } t j | d  }    | | | j	 | | j	  j	 |  j	 |  }	 t
 |	  t | j  j  j | j g  | S(   s+   
        Computes singular values.
        iii    s   Arrays cannot be emptyi   R   (   R   R   R   R   R   R6  RX   R   R   R  R	  R   R  (
   R   Rf   R   R8  R9  R:  R;  R  R   R   (   R  t   JOBZ_NR   t   np_ret_typeRJ   R<  R=  (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   sv_function  s8    
	
"(   i   i   (   i   i   (   RA   RJ   R   R   R   R3   R.  R/  R   R   RR   (   R   t   nb_ret_typet   np_dtypeR  (    (   R  R  R   R  RJ   R<  R=  s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _compute_singular_values_impl  s    !2c         C` s
   t   d S(   s.   
    Compute the L2-norm of 1D-array *a*.
    N(   RK  (   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _oneD_norm_2K  s    c         ` sm   t  |  j d |  j  } t j |   t   j |  j   t t |  j d         f d   } | S(   NR1   t   normc         ` s   t  |   } t j d d  } t |  j d |  j  }    | |  j | | j  } | d k  r{ t   d s{ t  n  t	 | j
 |  j
 g  | d S(   Ni   R   i    (   i   (   t   lenR   R   R   t   stridest   itemsizeR  R   R   R   R  (   R   Rf   RG  t   jmpR   (   R   R  t   xxnrm2(    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRh   [  s    (   R3   R   R.  R/  R.   R2   R   R   (   R   R  Rh   (    (   R   R  R  s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _oneD_norm_2_implR  s    c   	      ` sn  t  |  j d |  j  } t j |  } t j |  j  } t   j |  j  } t t |  j d   } |  j d k r | d  t
 j f k r d  d  } n d  d  } | S|  j d k r^| d  t
 j f k r3|  j d k r t d      n0 |  j d	 k rt d
      n t d      d    f d  } n' t j | j  j  d   f d  } | Sd sjt  d  S(   NR1   R  i   c         S` s
   t  |   S(   N(   R  (   R   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRO    s    c         S` s  t  |   } | d k r d S| d k r2 t |   S| t j k r t |  d  } x< t d |  D]+ } t |  |  } | | k ra | } qa qa W| S| t j k r t |  d  } x< t d |  D]+ } t |  |  } | | k  r | } q q W| S| d k rAd } x1 t |  D]# } |  | d k r| d 7} qqW| S| d k rd } x( t |  D] } | t |  |  7} q`W| Sd } x, t |  D] } | t |  |  | 7} qW| d | Sd  S(   Ni    g        i   i   g      ?(   R  R  R   R  R^  R  (   R   R   Rf   RG  R   R+   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRO    sD    
i   RS   c         S` s   |  S(   N(    (   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   array_prepare  s    R   c         S` s   |  j  S(   N(   R  (   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyR    s    c         S` s
   |  j    S(   N(   RX   (   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyR    s    c         ` s8   |  j  } | d k r d S  |   } t | j |   S(   Ni    g        (   R  R  Rx  (   R   R   Rf   t   a_c(   R  (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRP    s
    	c   	      ` s\  |  j  d } |  j  d } |  j d k r- d S| t j k r d } x` t |  D]R } d } x. t |  D]  } | t |  | | f  7} qh W| | k rO | } qO qO W| S| t j k r&  } x` t |  D]R } d } x. t |  D]  } | t |  | | f  7} q W| | k  r | } q q W| S| d k rd } x` t |  D]R } d } x. t |  D]  } | t |  | | f  7} q^W| | k rE| } qEqEW| S| d k r  } x` t |  D]R } d } x. t |  D]  } | t |  | | f  7} qW| | k  r| } qqW| S| d k r2t |   d S| d k rLt |   d St d   d  S(   Niii    g        i   i   s    Invalid norm order for matrices.(   R   R  R   R  R  R^  R  R   (	   R   R   Rf   R   t
   global_maxt   iit   tmpt   jjt
   global_min(   t   max_val(    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRP    sZ    i    (   R3   R   R.  R/  R.   R2   R   R   R   R   R   Rj   RR   R   R   t   finfoR   Rg  R   (	   R   t   ord_flagR  R  R  R  R   RO  RP  (    (   R  R  s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _get_norm_implv  s,    9	Ec         C` s!   t    t |  d  t |  |  S(   NR  (   R%   R
  R  (   R   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt	   norm_impl=	  s    c         C` s$   t    t |  d  d  d  } | S(   Nt   condc         S` s   | d k s$ | d k s$ | d  k r t |   } | d k sH | d  k re t j | d | d  } q t j | d | d  } n@ t j j |  |  } t j j t j j |   |  } | | } t j |  r t j S| Sd  S(   Ni   ii    i(	   R   R  R   t   divideR   R  R   t   isnanR  (   R   t   pR   R   t   norm_at
   norm_inv_a(    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRh   L	  s    $!
(   R%   R   R   (   R   R  Rh   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt	   cond_implF	  s    $c         C` sE   d } x8 t  t |    D]$ } |  | | k r< | d } q Pq W| S(   sJ   
    Gets rank from singular values with cut-off at a given tolerance
    i    i   (   R  R  (   t   svR   Rl  R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _get_rank_from_singular_valuess	  s    c         ` s9   t    t |  d  d       f d   } | |  |  S(   sh  
    Computes rank for matrices and vectors.
    The only issue that may arise is that because numpy uses double
    precision lapack calls whereas numba uses type specific lapack
    calls, some singular values may differ and therefore counting the
    number of them above a tolerance may lead to different counts,
    and therefore rank, in some cases.
    t   matrix_rankc         ` sx   | d  t j f k rd t |  j d |  j  } t j |  } t j |  j	   d    f d  } | Sd  d  } | Sd  S(   NR1   c         ` sT   t  |   } |  j d } |  j d } t | |  } | d |   } t | |  S(   Ni    i   (   R  R   Rg  R  (   R   t   tolR   R   R   t   lR   (   t   eps_val(    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _2d_tol_none_impl	  s    c         S` s   t  |   } t | |  S(   N(   R  R  (   R   R  R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _2d_tol_not_none_impl	  s    (
   R   R   Rj   R3   R   R.  R/  R   R  t   eps(   R   R  t   nb_typet   np_typeR  R  (    (   R  s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _2d_matrix_rank_impl	  s    c         ` sN   |  j  } | d k r% d  d  } | S| d k r>   |  |  Sd sJ t  d  S(   Ni   c         S` s5   x. t  t |    D] } |  | d k r d Sq Wd S(   Ng        i   i    (   R  R  (   R   R  R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _1d_matrix_rank_impl	  s    i   i    (   R   R   R   (   R   R  R   R  (   R  (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _get_matrix_rank_impl	  s    	(   R%   R
  (   R   R  R  (    (   R  s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   matrix_rank_impl	  s
    
	c         ` se   t  |  d  t j |  j    t | d |  } t | t j  sR t d   n    f d   } | S(   sL   
    Computes matrix power. Only integer powers are supported in numpy.
    t   matrix_powerR   s   Exponent must be an integer.c   
      ` s  | d k rV t  j |  j d   } x+ t |  j d  D] } d | | | f <q8 W| S|  j d |  j d } } | | k r t d   n  | d k r |  j   S| d k  r t  j j |   j   } | d k r | S| } n | d k r |  j   S|  } | d k  rO| d	 k r$t  j | |  S| d
 k rt  j t  j | |  |  Sny | } | } t	 } x` | d k r| d @r| r| }	 t
 } qt  j |	 |  }	 n  t  j | |  } | d ?} qdW|	 Sd  S(   Ni    R   g      ?iis   input must be a square arrayi   i   i   i   (   R   RD  R   R  R   RX   R   R   R   R   Ro   (
   R   Rf   R4  R   RU  RY  R  R  t   flagRG  (   R  (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   matrix_power_impl	  sF    



	(	   R   R.  R/  R   R3   RV   R   t   IntegerR   (   R   Rf   t   ntR  (    (   R  s3   lib/python2.7/site-packages/numba/targets/linalg.pyR  	  s    <c         C` sN   t  |  d d t t | t t j f  s> t d |   n  d d  } | S(   s)   
    Computes the trace of an array.
    t   traceR   s!   integer argument expected, got %si    c         S` s   |  j  \ } } | } | d k  r. | | } n  | d k rG | | } n  t t | |  d  } d } | d k r x^ t |  D] } | |  | | | f 7} q~ Wn/ x, t |  D] } | |  | | | f 7} q W| S(   Ni    (   R   Rg  R6  R  (   R   t   offsett   rowst   colsR   Rf   RG  RH  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   matrix_trace_impl
  s    (   R   Ro   RV   R   R   R  R   (   R   R  R  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyR  
  s
    c         C` s_   | r d n d } | | f } t  |  t j  r[ |  j d k s[ t d | d t  q[ n  d  S(   Ns	   np.linalgR   i   s+   %s.%s() only supported on 1 and 2-D arrays R   (   RV   R   RW   R   R   Ro   (   R   R   R   R   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _check_scalar_or_lt_2d_mat0
  s    c         C` s<   t  |  t j  s% t d    } | St d    } | Sd  S(   Nc         S` s   t  j |  f  S(   N(   R   R  (   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   asarray<
  s    c         S` s   |  S(   N(    (   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyR  A
  s    (   RV   R   RW   R   (   R   R  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _get_as_array:
  s
    c         ` si   t  |     t  |   | d  t j f k rI t    f d    } | St    f d    } | Sd  S(   Nc         ` sX     |   }  |  } t  j | j   j | j d f  | j   j d | j f   S(   Ni   (   R   t   multiplyRd  Rx  R  (   R   R   R   t   aat   bb(   t   a_arrt   b_arr(    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt
   outer_implL
  s    !c         ` s_     |   }  |  } t  j | j   j | j d f  | j   j d | j f  |  | S(   Ni   (   R   R  Rd  Rx  R  (   R   R   R   R  R  (   R  R  (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyR  T
  s    !(   R  R   R   Rj   R   (   R   R   R   R  (    (   R  R  s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _get_outer_implG
  s    i	   c         ` sN   t  |  d d t t  | d d t t |  | |    d    f d  } | S(   Nt   outerR   c         ` s     |  | |  S(   N(    (   R   R   R   (   Rh   (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyR  h
  s    (   R  Ro   R  R   (   R   R   R   R  (    (   Rh   s3   lib/python2.7/site-packages/numba/targets/linalg.pyR  `
  s
    c         ` sK   t  |  d d t t  | d d t t |  | d       f d   } | S(   NR  R   c         ` s     |  | d   S(   N(   R   (   R   R   (   Rh   (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyR  u
  s    (   R  Ro   R  R   (   R   R   R  (    (   Rh   s3   lib/python2.7/site-packages/numba/targets/linalg.pyR  m
  s
    c         C` s   t  |  t j  rt |  j d k r< t d j |  j    q |  j d k r^ t d    } | St d    } | Sn t d    } | Sd  S(	   NRS   R   s_   np.linalg.kron only supports 'C' or 'F' layout input arrays. Receieved an input of layout '{}'.i   c         S` s*   |  j  d } |  j  d } |  j | |  S(   Nii(   R   Rx  (   R   t   xnt   xm(    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt	   nrm_shape
  s    c         S` s   |  j  d } |  j d |  S(   Nii   (   R   Rx  (   R   R  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyR  
  s    c         S` s&   t  j d t |    } |  | d <| S(   Ni   i    (   i   i   (   R   R   R   (   R   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyR  
  s    
(   RS   R   (   RV   R   RW   RR   R   t   formatR   R   (   R   R  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _kron_normaliser_impl{
  s    	c         C` s   t  |  t j  } t  | t j  } | rw | rw |  j d k sN | j d k ra t d    } | St d    } | SnE | r t d    } | S| r t d    } | St d    } | Sd  S(   Ni   c         S` s   | S(   N(    (   R   R   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRG  
  s    c         S` s   | j  | j  S(   N(   Rx  R  (   R   R   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRG  
  s    c         S` s   | j  |  j  S(   N(   Rx  R   (   R   R   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRG  
  s    c         S` s   | j  | j  S(   N(   Rx  R   (   R   R   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRG  
  s    c         S` s   | d S(   Ni    (    (   R   R   R   (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyRG  
  s    (   RV   R   RW   R   R   (   R   R   t   a_is_arrt   b_is_arrRG  (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   _kron_return
  s     c         ` s{   t  |  d d t t  | d d t t |    t |   t |  |   t |  d |          f d   } | S(   Nt   kronR   R   c      	   ` s,   |   }  |  } | j  d } | j  d } | j  d } | j  d } | | } | | }	 t j | |	 f d   }
 x t |  D] } | | } x} t |  D]o } | | } | | d  d   f } xF t |  D]8 } | | } | | | f | |
 | | | |  f <q Wq Wq W |  | |
  S(   NiiR   (   R   R   R   R  (   R   R   R  R  RU  RY  RV  RZ  t   cmt   cnRS   RH  t   rjmpR   t   irjmpt   slcRI  t   cjmp(   R  t   fix_at   fix_bt   ret_c(    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt	   kron_impl
  s$    




4(   R  Ro   R  R  R3   (   R   R   R  (    (   R  R  R  R  s3   lib/python2.7/site-packages/numba/targets/linalg.pyR  
  s    ((    (    (   i   i   (   i   i	   (   R?   t
   __future__R    R   R   t
   contextlibt   llvmliteR   t   numpyR   t   operatort   numbaR   R   t   numba.targets.imputilsR   R   R   R	   t   numba.typingR
   t   numba.extendingR   R   t   numba.numpy_supportR   t   numpy_versionR   R.  t   arrayobjR   R   R   t   errorsR   t   utilsR   Rz   R{   t
   as_pointert	   ll_char_pR}   t   ll_intct	   ll_intc_pR|   t	   ll_intp_pRh  R  RC   t   float32RO   t	   complex64t
   complex128R   R   R#   R%   R-   R.   RA   t   contextmanagerRd   Rk   Ru   Rv   R   R   R   R   R   R   Ro   R   R   RW   R   t   matmulR   R   R   R   R   R   R4   t   fatal_error_sigR8   R   R   R   R   R   R   R   R   R   R  R	  R
  R  R  R  R$  R%  R(  R)  R-  R1  R2  R3  RA  RC  RJ  RN  RQ  RR  RS  RT  RW  RX  R[  R\  Rb  Rc  Re  Rf  Ro  Rs  Rt  Ru  Rv  Rw  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  (    (    (    s3   lib/python2.7/site-packages/numba/targets/linalg.pyt   <module>   s   "			


			)					%	2			$"$		
	/	M	
-
,{66FV					%	d	C	$@	L	$	,AN
				"