
\K]c           @` sT  d  d l  m Z m Z m Z d  d l Z d  d l m Z m Z d  d l Z d  d l	 Z	 d  d l
 Z d  d l Z d d l m Z m Z m Z m Z m Z m Z d d l m Z d d l m Z d	   Z e j d
  d e j f d     Y Z i e j e j 6e j e j 6e j  e j! 6Z" i e j# e j$ 6e j% e j& 6e j' e j( 6e j) e j* 6e j+ e j, 6e j- e j. 6e j/ e j0 6e j1 e j2 6e j3 e j4 6e j5 e j6 6e j7 e j8 6e j9 e j: 6Z; e j< se j) e; e j= <n  i e j> e j? 6e j@ e jA 6e jB e jC 6e jD e jE 6e jF e jG 6e jH e jI 6ZJ d   ZK e jL d    ZM d   ZN d S(   i    (   t   print_functiont   divisiont   absolute_importN(   t   defaultdictt   OrderedDicti   (   t   compilert   irt   typest   rewritest   sixt   utils(   t   npydecli   (   t   DUFuncc         C` s   t  |  t j t f  S(   N(   t
   isinstancet   npt   ufuncR   (   t   func(    (    s9   lib/python2.7/site-packages/numba/npyufunc/array_exprs.pyt	   _is_ufunc   s    s   after-inferencet   RewriteArrayExprsc           B` sh   e  Z d  Z d   Z d   Z d   Z d   Z d   Z d   Z d   Z	 d   Z
 d	   Z d
   Z RS(   s   The RewriteArrayExprs class is responsible for finding array
    expressions in Numba intermediate representation code, and
    rewriting those expressions to a single operation that will expand
    into something similar to a ufunc call.
    c         O` sH   t  t |   j | | |  |  j j j } d | k rD t | d <n  d  S(   Nt	   arrayexpr(   t   superR   t   __init__t   pipelinet	   targetctxt   special_opst   _lower_array_expr(   t   selfR   t   argst   kwsR   (    (    s9   lib/python2.7/site-packages/numba/npyufunc/array_exprs.pyR      s    c   	      C` s   t  |  d k r t S| |  _ | |  _ t   |  _ i  |  _ | j t j	  } x | D] } | j
 j } | j } t | t j  r t | j | d  t j  r |  j | | |  qV t | t j  rV | |  j | <qV qV Wt  |  j  d k S(   s   
        Using typing and a basic block, search the basic block for array
        expressions.
        Return True when one or more matches were found, False otherwise.
        i    N(   t   lent   Falset
   crnt_blockt   typemapR   t   array_assignst   const_assignst
   find_instsR   t   Assignt   targett   namet   valueR   t   Exprt   gett   NoneR   t   Arrayt   _match_array_exprt   Const(	   R   t   func_irt   blockR    t	   calltypest   assignmentst   instrt   target_namet   expr(    (    s9   lib/python2.7/site-packages/numba/npyufunc/array_exprs.pyt   match"   s     				c         C` s   | j  } |  j } | d k r= | j t j k r= | | | <n | d k r | j j |  j k r |  j | j j } t | t	 j
  r | j } t |  r |  j | |  s | | | <q q q n  d S(   s   
        Find whether the given assignment (*instr*) of an expression (*expr*)
        to variable *target_name* is an array expression.
        t   unaryt   binopt   callN(   R6   R7   (   t   opR!   t   fnR   t   supported_array_operatorsR   R&   R    R   R   t   Functiont
   typing_keyR   t   _has_explicit_output(   R   R2   R4   R3   t   expr_opR!   t	   func_typet   func_key(    (    s9   lib/python2.7/site-packages/numba/npyufunc/array_exprs.pyR,   C   s    		!	c         C` s<   t  | j  t  | j  } | j d k	 r/ t S| | j k S(   sr   
        Return whether the *expr* call to *func* (a ufunc) features an
        explicit output argument.
        N(   R   R   R   t   varargR*   t   Truet   nin(   R   R4   R   t   nargs(    (    s9   lib/python2.7/site-packages/numba/npyufunc/array_exprs.pyR>   ^   s    c         C` sU   | j  } | d k r | j S| d k r< |  j | j j j St d j |    d  S(   NR6   R7   R8   s:   Don't know how to find the operator for '{0}' expressions.(   R6   R7   (   R9   R:   R    R   R&   R=   t   NotImplementedErrort   format(   R   t   ir_exprt   ir_op(    (    s9   lib/python2.7/site-packages/numba/npyufunc/array_exprs.pyt   _get_array_operatorj   s    	c         C` sg   | j  } | d k r% | j | j f S| d k r; | j   S| d k rN | j St d j |    d S(   s{   Given a Numba IR expression, return the operands to the expression
        in order they appear in the expression.
        R7   R6   R8   s:   Don't know how to find the operands for '{0}' expressions.N(   R9   t   lhst   rhst	   list_varsR   RF   RG   (   R   RH   RI   (    (    s9   lib/python2.7/site-packages/numba/npyufunc/array_exprs.pyt   _get_operandst   s    	
c         C` sc   | j  } | d k r | j Sg  |  j |  D] } |  j j | j |  ^ q, } |  j |  | f S(   sZ   Translate the given expression from Numba IR to an array expression
        tree.
        R   (   R9   R4   RN   R"   R)   R&   RJ   (   R   RH   RI   t   op_vart   operands_or_args(    (    s9   lib/python2.7/site-packages/numba/npyufunc/array_exprs.pyt   _translate_expr   s    	1c         C` s  i  } t    } t t  } x|  j j   D]} | j } g  } |  j |  | f } t j d d d | j	 d | d |  j
 | j j  } t j | | j | j	  }	 |	 | | <|	 |  j | j j <x |  j |  D] }
 |
 j } | |  j k rz|  j | } | j } | j   } x! | D] }
 | |
 j c d 7<qW| j |  j |   | j j r| j | j j  d | | <qq | |  j k r| j |  j |  q | |
 j c d 7<| j |
  q Wq+ W| | | f S(   st   Iterate over the matches, trying to find which instructions should
        be rewritten, deleted, or moved.
        R9   R   t   locR4   t   tyi   N(   t   setR   t   intR!   t   valuesR'   RJ   R   R(   RR   R    R%   R&   R$   RN   RM   t   appendRQ   t   is_tempt   addR*   R"   (   R   t   replace_mapt	   dead_varst	   used_varsR2   R4   t   arr_inpst   arr_exprt   new_exprt	   new_instrt   operandt   operand_namet   child_assignt
   child_exprt   child_operands(    (    s9   lib/python2.7/site-packages/numba/npyufunc/array_exprs.pyt   _handle_matches   s>    			
		c         C` s+   | | } x | | k r& | | } q W| S(   s   Find the final replacement instruction for a given initial
        instruction by chasing instructions in a map from instructions
        to replacement instructions.
        (    (   R   t   replacement_mapR2   t   replacement(    (    s9   lib/python2.7/site-packages/numba/npyufunc/array_exprs.pyt   _get_final_replacement   s    
c         C` s  |  j    \ } } } |  j j   } | j   i  } xL|  j j D]>} t | t j  r| | k r |  j | |  } | r| j	 |  xk | j
 j   D]W } | j }	 |	 | k r | j	 | j |	   n  | |	 d k r | |	 c d 8<q q Wqq| j	 |  qA t | t j  rr| j
 }
 | |
 d k rS| |
 c d 8<| | |
 <q|
 | k r| j	 |  qqA | j	 |  qA W| rx$ | j   D] } | j |  qWn  | S(   s}   When we've found array expressions in a basic block, rewrite that
        block, returning a new, transformed block.
        i    i   (   Rf   R   t   copyt   cleart   bodyR   R   R$   Ri   RW   R'   RM   R&   t   popt   DelRV   t   insert_before_terminator(   R   RZ   R[   R\   t   resultt
   delete_mapR2   Rh   t   vart   var_namet   instr_value(    (    s9   lib/python2.7/site-packages/numba/npyufunc/array_exprs.pyt   apply   s<    
		(   t   __name__t
   __module__t   __doc__R   R5   R,   R>   RJ   RN   RQ   Rf   Ri   Ru   (    (    (    s9   lib/python2.7/site-packages/numba/npyufunc/array_exprs.pyR      s   		!			
			%	
c         C` sj  t  |  t  r|  \ } } g  } i  } x: | D]2 } t |  \ } } | j |  | j |  q. W| t j k r,t |  d k r | t k r t	 j
 | d t |   | d  | f S| t k r)t	 j | d t |   g | d g  | f Sq| t k st  t	 j t |   | d  | f SqSt |  rSd j t t |   j d d   } t	 j | t	 j    }	 | | | <t j d k rt	 j |	 | g   }
 n t	 j |	 | g  d d  }
 |
 | f Sn t  |  t j  r+t	 j |  j t	 j   d	 |  j j d
 |  j j  r|  j j  n d i  f St  |  t j!  rSt	 j" |  j#  i  f St$ d |  f   d S(   s[   Build a Python expression AST from an array expression built by
    RewriteArrayExprs.
    i   i    i   s   __ufunc_or_dufunc_{0}t   -t   _i   i   t   linenot
   col_offsets1   Don't know how to translate array expression '%r'N(   i   i   (%   R   t   tuplet   _arr_expr_to_astRW   t   updateR   R;   R   t   _binopst   astt   BinOpt   _cmpopst   Comparet	   _unaryopst   AssertionErrort   UnaryOpR   RG   t   hext   hasht   replacet   Namet   Loadt   syst   version_infot   CallR*   R   t   VarR&   RR   t   linet   colR-   t   NumR'   RF   (   R4   R9   t   arr_expr_argst   ast_argst   envt   argt   ast_argt	   child_envt   fn_namet   fn_ast_namet   ast_call(    (    s9   lib/python2.7/site-packages/numba/npyufunc/array_exprs.pyR~     sF    "+$!
%c         c` s   t    } x` |  D]X } | j } | j d d  j d d  } | | k sO t  | | f | | <| | _ q Wt |  } z	 | VWd x# | j   D] \ } } | | _ q WXd S(   sa   
    Legalize names in the variable list for use as a Python function's
    parameter names.
    t   $Rz   t   .N(   R   R&   R   R   t   listRV   (   t   var_listt   var_mapRr   t   old_namet   new_namet   param_names(    (    s9   lib/python2.7/site-packages/numba/npyufunc/array_exprs.pyt   _legalize_parameter_names6  s    			c      	   ` s  d t  t |   j d d  } | j j } | j   } t t |  d d   } g  | D] } | j ^ q\ } t	 |   } t
 t d  r g  | D] }	 t j |	 d  ^ q }
 n+ g  | D] }	 t j |	 t j    ^ q }
 t j d j |  | d  } t
 | d	  r$t | j  d
 k s*t  | j d } |
 | j _ t | j  \ | j d _ } t j |  Wd QXt | | d  } t j | |  | | }  j }  j   | j  f d   | D   } g  } xa | j D]V } t  | t! j"  r| j# } n  t  | t! j$  r+| j% | j&  q| j% |  qW| j' j& |    t( j)   } | j d d  | j*   |  d | d t+  d d l, m- } d | j. f     f d     Y} g  | D] }  j/ |  ^ q} | j0 |   | | | d t+ S(   s:   Lower an array expression built by RewriteArrayExprs.
    s   __numba_array_expr_%sRy   Rz   t   keyc         S` s   |  j  S(   N(   R&   (   Rr   (    (    s9   lib/python2.7/site-packages/numba/npyufunc/array_exprs.pyt   <lambda>V  t    R   s   def {0}(): returnt   execRl   i   i    Nc         3` s   |  ] }   j  |  Vq d  S(   N(   t   typeof(   t   .0R&   (   t   lowerer(    s9   lib/python2.7/site-packages/numba/npyufunc/array_exprs.pys	   <genexpr>{  s    t   error_modelt   numpyt   flagst   cachingi   (   t   npyimplt
   ExprKernelc           ` s   e  Z     f d    Z RS(   c         ` s   t  | |  j j  j  } g  | D]$ \ } } } |  j | | |  ^ q" } |  j j    j  |  } |  j |  j |  j j  S(   N(   t   zipt	   outer_sigR   t   castt   contextt   call_internalt   fndesct   return_type(   R   R   t   arg_zipt   valt   intyt   outtyt	   cast_argsRp   (   t   buildert   crest	   inner_sig(    s9   lib/python2.7/site-packages/numba/npyufunc/array_exprs.pyt   generate  s    .	(   Rv   Rw   R   (    (   R   R   R   (    s9   lib/python2.7/site-packages/numba/npyufunc/array_exprs.pyR     s   t   explicit_output(1   R   R   R   RR   t   filenameRM   t   sortedRT   R&   R   t   hasattrR   R   R*   R   t   Paramt   parseRG   R   Rl   R   R   R~   R4   R'   t   fix_missing_locationst   compileR	   t   exec_R   R   RS   R   R   t   Optionalt   typeR+   RW   t   dtypeR   R   t   Flagst   compile_subroutineR   t   targetsR   t   _Kernelt   loadvart   numpy_ufunc_kernel(   R   R4   t	   expr_namet   expr_filenamet   expr_var_listt   expr_var_uniqueRr   t	   expr_argst   expr_paramst
   param_nameR   t
   ast_modulet   ast_fnt	   namespacet   code_objt   implR   R   t   inner_sig_argst   argtyR   R   R   R&   R   (    (   R   R   R   R   s9   lib/python2.7/site-packages/numba/npyufunc/array_exprs.pyR   N  sR    "%(*
			%
"(O   t
   __future__R    R   R   R   t   collectionsR   R   t
   contextlibR   R   R   t   operatorR   R   R   R   R   R	   R
   t   typingR   t   dufuncR   R   t   register_rewritet   RewriteR   t   UAddt   post   USubt   negt   Invertt   invertR   t   AddRY   t   Subt   subt   Multt   mult   Divt   truedivt   Modt   modt   BitOrt   or_t   RShiftt   rshiftt   BitXort   xort   LShiftt   lshiftt   BitAndt   and_t   Powt   powt   FloorDivt   floordivR   t   IS_PY3t   divt   Eqt   eqt   NotEqt   net   Ltt   ltt   LtEt   let   Gtt   gtt   GtEt   geR   R~   t   contextmanagerR   R   (    (    (    s9   lib/python2.7/site-packages/numba/npyufunc/array_exprs.pyt   <module>   sR   .			+