
    xKg                        d dl Z d dlZd dlmZmZmZmZ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mZmZmZ d dlmZ d dlmZmZ d dlZd dlmZ d dl Z dZ!d Z"e jF                  gZ$i Z%g dZ&d	d
gZ'g dZ(g dZ)g dZ*e'e(z   e)z   e*z   ddgz   Z+ed        Z,d Z-ed        Z. G d de/      Z0 G d de0      Z1 G d de1      Z2 G d de/      Z3 G d de/      Z4 e5ejl                  jn                  jq                               ejr                  gz   Z:ejv                  jn                  jq                         Z<ejz                  jn                  jq                         Z>ej~                  D  cg c]  } | j                   c} ZAyc c} w )    N)typesirconfigcgutilserrors)mk_unique_varfind_topo_orderdprint_func_irget_global_func_typguardrequireget_definitionfind_callnamefind_build_sequence
find_constis_namedtuple_classbuild_definitionsfind_potential_aliasesget_canonical_aliasGuardException)compute_cfg_from_blocks)npydecl	signature)	intrinsic)emptyzerosonesfullrandrandn)ranfrandom_samplesamplerandomstandard_normal)	chisquareweibullpower	geometricexponentialpoissonrayleigh)normaluniformbetabinomialfgamma	lognormallaplacerandint
triangularc                    t        t        |t        j                  j                               t        t        |t        j                  j                               |j
                  rt        j                  nt        j                  |j
                  rt        j                  nt        j                  fd}t        ||      |fS )a  
    Calculate index value "idx" relative to a size "size" value as
    (idx % size), where "size" is known to be positive.
    Note that we use the mod(%) operation here instead of
    (idx < 0 ? idx + size : idx) because we may have situations
    where idx > size due to the way indices are calculated
    during slice/range analysis.

    Both idx and size have to be Integer types.
    size should be from the array size vars that array_analysis
    adds and the bitwidth should match the platform maximum.
    c                    | j                        }| j                        }j                  r|j                  |d   |      }n|j                  |d   |      }j                  r|j                  |d   |      }n|j                  |d   |      }|j	                  |      }t
        j                  j                  |d      }	|j                  d||	      }
|j                  d||      }|j                  d||      }|j                  |||      }|j                  ||	|j                  ||            }|j                  |
||      }|S )Nr      <z>=z<=)get_data_typesignedsextzextnegllvmliter   Constanticmp_signedselectadd)contextbuildersigargsll_idx_unified_tyll_unified_tyidxsizeneg_sizezeroidx_negativepos_oversizeneg_oversizepos_resneg_resmodidx_unified
unified_tys                   `/home/alanp/www/video.onchill/myenv/lib/python3.12/site-packages/numba/parfors/array_analysis.pycodegenzwrap_index.<locals>.codegenf   s0   #11+>--j9,,tAw(9:C,,tAw(9:C<<Q7D<<Q7D;;t${{##M15 **3T:**4d;**4h?..tS9..tW[[d5KLnn\7G<
    )	r   
isinstancer   scalarsIntegerr=   intpuintpr   )	typingctxrL   rM   rY   rV   rW   s       @@rX   
wrap_indexra   Q   s~     JsEMM1123JtU]]2234  ${{J #

%**K0 Zd+W44rZ   c                 6    | dk  r| | k  ry| |z   S | |k\  r|S | S Nr    )rL   rM   s     rX   wrap_index_literalre      s0    
Qw4%<:$;KJrZ   c                 L   t        |      dkD  rt        j                  |      f}t        |d         dkD  sJ t        d |d   dd D              sJ t	        |d   d   t        j
                        st        j                  d      d }t        t        j                  g| |fS )z
    A function that asserts the inputs are of equivalent size,
    and throws runtime error when they are not. The input is
    a vararg that contains an error message, followed by a set
    of objects of either array, tuple or integer.
    r:   r   c              3      K   | ]L  }t        |t        j                  t        j                  t        j                  t        j
                  f       N y wN)r[   r   ArrayCompatible	BaseTuple	SliceTyper]   ).0as     rX   	<genexpr>zassert_equiv.<locals>.<genexpr>   sF       A 	1!!OOOOMM	
 	 s   AANz&first argument must be a StringLiteralc           	         	
 t        |      dk(  sJ t        j                  |d         }|j                  d   }|j                  d   d   j                  	 fd
 	
fd}t        dt        |      dz
        D ]  } |||   ||   ||dz      ||dz             !  j                  t        j                  d       }|S )Nr:   r   c                    t        |t        j                        r9 j                  |      |       }t	        j
                  |j                        S t        |t        j                        rt	        j
                  |       S | gS rh   )r[   r   ri   
make_arrayr   unpack_tupleshaperj   )rm   atyaryrG   rF   s      rX   unpack_shapesz4assert_equiv.<locals>.codegen.<locals>.unpack_shapes   sm    #u445-g((-gwB++GSYY??C1++GQ77s
rZ   c                     | |      } ||      }t        |      t        |      k(  sJ t        ||      D ]n  \  }}j                  d||      }j                  |      5 \  }	}
|	5  	 d d d        |
5  j                  j                  t        f       d d d        d d d        p y # 1 sw Y   AxY w# 1 sw Y    xY w# 1 sw Y   xY w)Nz==)lenzipicmp_unsignedif_else	call_convreturn_user_excAssertionError)rm   rt   bbtyashapesbshapesmnm_eq_nthenorelserG   rF   msgrv   s              rX   pairwisez/assert_equiv.<locals>.codegen.<locals>.pairwise   s    #As+G#As+Gw<3w<///gw/A ..tQ:__V,v ))99#^cV   -, 0  -,s<   #C)B++
C5#B7C+B40C7C <CC	)	rx   r   rr   rI   literal_valuerangeget_constant_genericr   NoneType)rF   rG   rH   rI   tuptup_typer   irr   rv   s   ``       @@rX   rY   zassert_equiv.<locals>.codegen   s    4yA~~""7DG488A;hhqk!n**		 q#h-!+,ASVXa[#a!e*hq1uoF -((%..$GrZ   )
rx   r   StarArgTupleallr[   StringLiteralr   TypingErrorr   none)r`   valrY   s      rX   assert_equivr      s     3x!| !!#&(s1v;??  Q    c!fQi!4!45  !IJJ D UZZ&#&//rZ   c                   `    e Zd ZdZd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y)EquivSetzPEquivSet keeps track of equivalence relations between
    a set of objects.
    Nc                 >    |r|ni | _         |r|ni | _        || _        y)zdCreate a new EquivSet object. Optional keyword arguments are for
        internal use only.
        N)
obj_to_ind
ind_to_objnext_ind)selfr   r   r   s       rX   __init__zEquivSet.__init__   s#     )3*(2* !rZ   c                     t               S )z)Return an empty EquivSet object.
        )r   r   s    rX   r   zEquivSet.empty   s     zrZ   c                     t        t        j                  | j                        t        j                  | j                        | j
                        S )Return a new copy.
        )r   r   next_id)r   copydeepcopyr   r   r   r   s    rX   clonezEquivSet.clone   s8     }}T__5}}T__5MM
 	
rZ   c                 8    dj                  | j                        S )NzEquivSet({}))formatr   r   s    rX   __repr__zEquivSet.__repr__   s    $$T__55rZ   c                      | j                   i k(  S )z=Return true if the set is empty, or false otherwise.
        )r   r   s    rX   is_emptyzEquivSet.is_empty   s     "$$rZ   c                 :    | j                   j                  |d      S )zkReturn the internal index (greater or equal to 0) of the given
        object, or -1 if not found.
        r   )r   get)r   xs     rX   _get_indzEquivSet._get_ind   s     ""1b))rZ   c                     || j                   v r| j                   |   }|S | j                  }| xj                  dz  c_        |S )zyReturn the internal index (greater or equal to 0) of the given
        object, or create a new one if not found.
        r:   )r   r   )r   r   r   s      rX   _get_or_add_indzEquivSet._get_or_add_ind   sC     "A  AMMQMrZ   c                     t        |      dkD  sJ t         fd|D              }t        |      }t        j                  dk\  rt        d||       | j                  vrg  j                  |<   t        ||      D ]  \  }}||k(  r@| j                  |   vs j                  |   j                  |       | j                  |<   K| j                  v rO j                  |   D ]/  }| j                  |<    j                  |   j                  |       1  j                  |= | j                  |<    j                  |   j                  |        y)zXBase method that inserts a set of equivalent objects by modifying
        self.
        r:   c              3   @   K   | ]  }j                  |        y wrh   )r   rl   r   r   s     rX   rn   z#EquivSet._insert.<locals>.<genexpr>  s     ;dT))!,d      z_insert:N)
rx   tupleminr   DEBUG_ARRAY_OPTprintr   ry   appendr   )r   objsindsindr   objr   s   `      rX   _insertzEquivSet._insert
  s,    4y1}};d;;$i!!Q&*dD)t&#%DOOC $oFAsCxts33OOC(//4+.DOOC('!__Q/-0*,33A6 0 * ,/DOOC(OOC(//4 &rZ   c                     |D cg c]  }| j                  |       }}t        |      dk7  rt        fd|D              S t        |D cg c]
  }||d   k(   c}      S c c}w c c}w )zfTry to derive if given objects are equivalent, return true
        if so, or false otherwise.
        r   c              3   (   K   | ]	  }|k(    y wrh   rd   )rl   r   r   s     rX   rn   z$EquivSet.is_equiv.<locals>.<genexpr>1  s     .AqCx   r   )r   maxr   )r   r   r   r   r   s       @rX   is_equivzEquivSet.is_equiv*  so     +//$Qa $/$i"9....d3dT!Wd344 0
 4s   A#A(c                     | j                  |      }|dk\  r*| j                  |   }|D ]  }t        |t              s|c S  y)zvCheck if obj is equivalent to some int constant, and return
        the constant if found, or None otherwise.
        r   N)r   r   r[   int)r   r   r   r   r   s        rX   get_equiv_constzEquivSet.get_equiv_const5  sE     mmC !8??3'Da%H  rZ   c                 r    | j                  |      }|dk\  rt        | j                  |         S t               S ).Return the set of equivalent objects.
        r   )r   setr   )r   r   r   s      rX   get_equiv_setzEquivSet.get_equiv_setA  s4     mmC !8ts+,,urZ   c                 $    | j                  |      S )zInsert a set of equivalent objects by modifying self. This
        method can be overloaded to transform object type before insertion.
        )r   )r   r   s     rX   insert_equivzEquivSet.insert_equivI  s     ||D!!rZ   c                      j                         } j                  |_        |j                  j                         D ]  }t	         fd|D              }i }t        ||      D ]*  \  }}||v r||   j                  |       |dk\  s%|g||<   , |j                         D ]"  }t        |      dkD  s|j                  |       $  |S )z Return the intersection of self and the given equiv_set,
        without modifying either of them. The result will also keep
        old equivalence indices unchanged.
        c              3   @   K   | ]  }j                  |        y wrh   r   r   s     rX   rn   z%EquivSet.intersect.<locals>.<genexpr>X  s     84aq)4r   r   r:   )	r   r   r   valuesr   ry   r   rx   r   )	r   	equiv_setnew_setr   r   r   r   r   vs	   `        rX   	intersectzEquivSet.intersectO  s    
 **,==((//1D8488DJD$1
?qM((+!V%&CJqM	 (  &&(q6A:OOA& ) 2 rZ   )NNr   )__name__
__module____qualname____doc__r   r   r   r   r   r   r   r   r   r   r   r   r   rd   rZ   rX   r   r      sI    !

6%
*	5@	5
"rZ   r   c                        e Zd ZdZ	 	 	 	 	 	 d fd	Zd Zd Zd Zd Z fdZ	 fdZ
d	 Z fd
Z fdZ fdZd Zd Zd Zd Z fdZd Zd Z xZS )ShapeEquivSetad  Just like EquivSet, except that it accepts only numba IR variables
    and constants as objects, guided by their types. Arrays are considered
    equivalent as long as their shapes are equivalent. Scalars are
    equivalent only when they are equal in value. Tuples are equivalent
    when they are of the same size, and their elements are equivalent.
    c                     || _         |r|ni | _        |r|ni | _        |r|ni | _        t        t
        |   |||       y)zCreate a new ShapeEquivSet object, where typemap is a dictionary
        that maps variable names to their types, and it will not be modified.
        Optional keyword arguments are for internal use only.
        N)typemapdefs
ind_to_varind_to_constsuperr   r   )	r   r   r   r   r   r   r   r   	__class__s	           rX   r   zShapeEquivSet.__init__q  sE      !Db	 )3*,8LbmT+J
GLrZ   c                 .    t        | j                  i       S )z'Return an empty ShapeEquivSet.
        )r   r   r   s    rX   r   zShapeEquivSet.empty  s     T\\2..rZ   c                 p   t        | j                  t        j                  | j                        t        j                  | j                        t        j
                  | j                        t        j
                  | j                        | j                  t        j
                  | j                              S )r   )r   r   r   r   r   r   )
r   r   r   r   r   r   r   r   r   ind_toconstr   s    rX   r   zShapeEquivSet.clone  sq     LL499%yy1}}T__5}}T__5MMt'7'78
 	
rZ   c                 d    dj                  | j                  | j                  | j                        S )Nz1ShapeEquivSet({}, ind_to_var={}, ind_to_const={}))r   r   r   r   r   s    rX   r   zShapeEquivSet.__repr__  s*    BIIOOT__d.?.?
 	
rZ   c                 H    t        |t        j                        st        |t              rt        |t              r|n|j                   j
                  vrfS  j
                     }t        |t        j                  t        j                  f      rVt        |t        j                        r|j                  n
t        |      }|dk(  rfS t        fdt        |      D              S fS t        |t        j                        r3t        |j                  t              r|j                  S |j                  fS t        |t              r fdt        fd|D              S t        |t              r|fS t         j"                  dk\  rt%        dt'        |       d       y)	zReturn a set of names for the given obj, where array and tuples
        are broken down to their individual shapes or elements. This is
        safe because both Numba array shapes and Python tuples are immutable.
        r   c              3   B   K   | ]  }d j                  |        yw)z{}#{}N)r   )rl   r   names     rX   rn   z+ShapeEquivSet._get_names.<locals>.<genexpr>  s      N+Qa!8+s   c                 P    j                  |       }t        |      dk7  r|d   S |S rc   )
_get_namesrx   )r   namesr   s     rX   	get_namesz+ShapeEquivSet._get_names.<locals>.get_names  s*    *u:? 8OrZ   c              3   .   K   | ]  } |        y wrh   rd   )rl   r   r   s     rX   rn   z+ShapeEquivSet._get_names.<locals>.<genexpr>  s     3s!1ss   r:   zIgnoring untracked object type z in ShapeEquivSetrd   )r[   r   Varstrr   r   r   rj   ri   ndimrx   r   r   Constvaluer   r   r   r   type)r   r   typr   r   r   s   `   @@rX   r   zShapeEquivSet._get_names  sK   
 c266"jc&:$S#.3CHHD4<<'w,,t$C#1F1FGH%c5+@+@A  X  19 7N  N%+ NNNwRXX&#))U+yy 		|#U# 3s333S!6M!!Q&1$s)<MNPrZ   c                    t        |      dkD  sJ |D cg c]  }| j                  |       }}|D cg c]
  }|dk7  s	| }}t        |      dk  ry|D cg c]  }t        |       }}|d   t        fd|D              s.t        j                  dk\  rt        dj                  |             yt              D ]&  }|D cg c]  }||   	 }}t        t        | *  | r& y yc c}w c c}w c c}w c c}w )zWOverload EquivSet.is_equiv to handle Numba IR variables and
        constants.
        r:   rd   Fr   c              3   (   K   | ]	  }|k(    y wrh   rd   rl   r   r   s     rX   rn   z)ShapeEquivSet.is_equiv.<locals>.<genexpr>  s     ,e419er   z#is_equiv: Dimension mismatch for {}T)rx   r   r   r   r   r   r   r   r   r   r   )
r   r   r   	obj_namesr   ndimsr   obj_namer   r   s
           @rX   r   zShapeEquivSet.is_equiv  s     4y1}}156AT__Q'	6 )5	1Q"WQ		5y>Q)23U3Qx,e,,%%*;BB4HItA1:;XXa[E;6>   75 4 <s   C)
C. C.C3C8c                 p    | j                  |      }t        |      dk7  ryt        t        |   |d         S )ztIf the given object is equivalent to a constant scalar,
        return the scalar value, or None otherwise.
        r:   Nr   )r   rx   r   r   r   r   r   r   r   s      rX   r   zShapeEquivSet.get_equiv_const  s7     $u:?]D9%(CCrZ   c                     | j                  |      }t        |      dk7  ry| j                  |d         }| j                  j	                  |g       }|g k7  r|d   S dS )ztIf the given object is equivalent to some defined variable,
        return the variable, or None otherwise.
        r:   Nr   )r   rx   r   r   r   )r   r   r   r   vss        rX   get_equiv_varzShapeEquivSet.get_equiv_var  s]     $u:?mmE!H%__  b)br!u*d*rZ   c                 p    | j                  |      }t        |      dk7  ryt        t        |   |d         S )r   r:   Nr   )r   rx   r   r   r   r   s      rX   r   zShapeEquivSet.get_equiv_set  s7     $u:?]D7aAArZ   c                    g }|D ]/  }|| j                   v s|j                  | j                   |          1 g }d}t               }t        |      D ]  }|| j                  v rO| j                  |   D ]=  }|j
                  |vs|j                  |       |j                  |j
                         ? || j                  v so|J | j                  |   } t        t        | +  |       | j                   |d      }	t        |      D ]  }|| j                  v s| j                  |=   || j                  |	<   ||| j                  |	<   yy)zCOverload EquivSet._insert to manage ind_to_var dictionary.
        Nr   )r   r   r   sortedr   r   rE   r   r   r   r   )r   r   r   r   varlistconstvalr   r   r   new_indr   s             rX   r   zShapeEquivSet._insert   s<    Cdoo%DOOC01  ADOO#+AFFeOq)		!&&) , D%%%''',,Q/  	mT*40//$q'*TADOO#OOA&  $+ )1Dg&  rZ   c                    t        |      dkD  sJ |D cg c]  }| j                  |       }}|D cg c]
  }|dk7  s	| }}t        |      dk  ryt        |D cg c]  }t        |       c}g       }|D cg c]  }t        |       }}|d   t	        fd|D              sJ dj                  |             g }g }|D ]  }t        |t              s|f}|D ]  }	t        |	t        j                        rJ|	j                  |vr<|	j                  | j                  v r|j                  d|	       n|j                  |	       t        |	t        j                        s|	j                  |vs|j                  |	j                           |D ]  }|j                  }
|
|v s|
| j                   vs#|
g| j"                  | j$                  <   | j$                  | j                   |
<   |g| j&                  | j$                  <   | xj$                  dz  c_         |D ]w  }||v s|| j                   vs|g| j"                  | j$                  <   | j$                  | j                   |<   || j(                  | j$                  <   | xj$                  dz  c_        y d}t+              D ]*  }|D cg c]  }||   	 }}t-        t.        | b  | }|xs |}, |S c c}w c c}w c c}w c c}w c c}w )zOverload EquivSet.insert_equiv to handle Numba IR variables and
        constants. Input objs are either variable or constant, and at least
        one of them must be variable.
        r:   rd   Nr   c              3   (   K   | ]	  }|k(    y wrh   rd   r   s     rX   rn   z-ShapeEquivSet.insert_equiv.<locals>.<genexpr>)  s      
$!DAIur   zDimension mismatch for {}F)rx   r   sumlistr   r   r[   r   r   r   r   r   insertr   r   r   r   r   r   r   r   r   r   r   r   )r   r   r   r   r   r   r  	constlistr   varr   constsome_changer   r   ie_resr   r   s                   @rX   r   zShapeEquivSet.insert_equiv  s   
 4y1}}156AT__Q'	6 )5	1Q"WQ		5y>Qi0iT!Wi0"5!*+AQ+Qx 
$
 
 	4&--d3	4 
 	Cc5)fc266*CHH4Gxx499,q#.s+c288,cii96L$$SYY/   C88Du}ddoo&=26.(,%25."  E~u'?27.)-&38!!$--0"  tA1:;XXa[E;=$<eDF%/K 
 c 75 1+P <s"   K
K KK<K&K"c                 (    | j                  |      duS )zEReturn true if the shape of the given variable is available.
        N)	get_shaper   r   s     rX   	has_shapezShapeEquivSet.has_shapeU  s     ~~d#4//rZ   c                 .    t        | j                  |      S )ztReturn a tuple of variables that corresponds to the shape
        of the given array, or None if not found.
        )r   
_get_shaper  s     rX   r  zShapeEquivSet.get_shapeZ  s     T__d++rZ   c                 V   | j                  |      }t        |dk7         g }|D ]y  }t        || j                  v        | j                  |   }|g k7  r|j                  |d          Ct        || j                  v        | j                  |   }|j                  |       { t        |      S )zReturn a tuple of variables that corresponds to the shape
        of the given array, or raise GuardException if not found.
        rd   r   )get_shape_classesr   r   r   r   r   )r   r   r   rs   r   r  s         rX   r  zShapeEquivSet._get_shape`  s     %%d+
AA()#BRxRU#T.../&&q)R   U|rZ   c                     t        |t        j                        r|j                  }| j                  v r j                  |   nd}t        |t
        j                  t
        j                  t
        j                  f      sg S t        |t
        j                        r|j                  dk(  rg S  j                  |      }t         fd|D              }|S )zInstead of the shape tuple, return tuple of int, where
        each int is the corresponding class index of the size object.
        Unknown shapes are given class index -1. Return empty tuple
        if the input name is a scalar variable.
        Nr   c              3   @   K   | ]  }j                  |        y wrh   r   )rl   r   r   s     rX   rn   z2ShapeEquivSet.get_shape_classes.<locals>.<genexpr>  s     ;UTT]]4(Ur   )r[   r   r   r   r   r   rj   rk   ri   r   r   r   )r   r   r   r   r   s   `    rX   r  zShapeEquivSet.get_shape_classesr  s     dBFF#99D$(DLL$8dll4 ds%2G2G  Ic5001chh!mI%;U;;rZ   c                 6   t         t        |   |      }i }|j                  j	                         D ]  \  }}t        |      dkD  sJ |d   }|| j                  v sJ ||j                  v sJ | j                  |   }|j                  |   }|| j                  v sJ ||j                  v sJ g }	|j                  |   D 
cg c]  }
|
j                   }}
| j                  |   D ]"  }
|
j                  |v s|	j                  |
       $ |	||<    ||_        |S c c}
w )z<Overload the intersect method to handle ind_to_var.
        r   )
r   r   r   r   itemsrx   r   r   r   r   )r   r   newsetr   r   r   r   jkr  r   r   r   s               rX   r   zShapeEquivSet.intersect  s.    }d5i@
((..0GAtt9q= =q'C$//)))).....$A$$S)A'''	,,,,,G%.%9%9!%<=%<QVV%<E=__Q'66U?NN1% ( $JqM 1 ' >s   =Dc                 r   t        |t        j                        r|j                  }|| j                  v rn| j                  |xx   dz  cc<   t        | j                  |            }|D ]6  }|| j                  v s|j                  |       | j                  |   }| j                  |= | j                  |   j                  |       | j                  |   g k(  r| j                  |= || j                  v sJ | j                  |   D cg c]  }|j                   }}||v s|j                  |      }| j                  |   |= | j                  |   g k(  s| j                  |= || j                  v s	| j                  |   D ]  }	| j                  |	=  | j                  |= 9 yd| j                  |<   yc c}w )a  Increment the internal count of how many times a variable is being
        defined. Most variables in Numba IR are SSA, i.e., defined only once,
        but not all of them. When a variable is being re-defined, it must
        be removed from the equivalence relation and added to the redefined
        set but only if that redefinition is not known to have the same
        equivalence classes. Those variables redefined are removed from all
        the blocks' equivalence sets later.

        Arrays passed to define() use their whole name but these do not
        appear in the equivalence sets since they are stored there per
        dimension. Calling _get_names() here converts array names to
        dimensional names.

        This function would previously invalidate if there were any multiple
        definitions of a variable.  However, we realized that this behavior
        is overly restrictive.  You need only invalidate on multiple
        definitions if they are not known to be equivalent. So, the
        equivalence insertion functions now return True if some change was
        made (meaning the definition was not equivalent) and False
        otherwise. If no change was made, then define() need not be
        called. For no change to have been made, the variable must
        already be present. If the new definition of the var has the
        case where lhs and rhs are in the same equivalence class then
        again, no change will be made and define() need not be called
        or the variable invalidated.
        r:   N)r[   r   r   r   r   r  r   r   rE   r   remover   index)
r   r   	redefinedname_resone_namer   r   r   r!  r   s
             rX   definezShapeEquivSet.define  s   6 dBFF#99D499IIdOq ODOOD12H$ t.MM  1A1OOA&--h7q)R/ OOA.///-1__Q-?@-?QVV-?E@u}!KK- OOA.q1??1-3 $ 2 DOO3+/??1+=C(,(< ,>$(OOA$61 %4  DIIdO As   F4c                 d    |j                         D ]  \  }}|dkD  s| j                  ||        y)zUnion with the given defs dictionary. This is meant to handle
        branch join-point, where a variable may have been defined in more
        than one branches.
        r   N)r  r)  )r   r   r&  r"  r   s        rX   
union_defszShapeEquivSet.union_defs  s-    
 JJLDAq1uAy) !rZ   )NNNNr   N)r   r   r   r   r   r   r   r   r   r   r   r  r   r   r   r  r  r  r  r   r)  r+  __classcell__r   s   @rX   r   r   h  s|     M8/



)V*D	+B287r0
,$,.: x*rZ   r   c                   ~     e Zd ZdZ	 	 	 	 	 	 	 	 d fd	Zd Zd Zd Zd Zd fd	Z	d fd	Z
 fd	Zd
 Z fdZ xZS )SymbolicEquivSeta/  Just like ShapeEquivSet, except that it also reasons about variable
    equivalence symbolically by using their arithmetic definitions.
    The goal is to automatically derive the equivalence of array ranges
    (slicing). For instance, a[1:m] and a[0:m-1] shall be considered
    size-equivalence.
    c
                     |r|ni | _         |r|ni | _        |r|ni | _        i | _        i | _        t
        t        |   ||||||	       y)zCreate a new SymbolicEquivSet object, where typemap is a dictionary
        that maps variable names to their types, and it will not be modified.
        Optional keyword arguments are for internal use only.
        N)def_byref_by
ext_shapesrel_mapwrap_mapr   r/  r   )r   r   r1  r2  r3  r   r   r   r   r   r   s             rX   r   zSymbolicEquivSet.__init__  sY    & !'fB
 !'fB )3*
  .T:z:w	
rZ   c                 ,    t        | j                        S )z*Return an empty SymbolicEquivSet.
        )r/  r   r   s    rX   r   zSymbolicEquivSet.empty  s      --rZ   c                     dj                  | j                  | j                  | j                  | j                  | j
                        S )NzHSymbolicEquivSet({}, ind_to_var={}, def_by={}, ref_by={}, ext_shapes={}))r   r   r   r1  r2  r3  r   s    rX   r   zSymbolicEquivSet.__repr__   s9    ((.)		
rZ   c                    t        | j                  t        j                  | j                        t        j                  | j                        t        j                  | j
                        t        j                  | j                        t        j                  | j                        t        j                  | j                        t        j                  | j                        | j                  	      S )r   )r1  r2  r3  r   r   r   r   r   )r/  r   r   r1  r2  r3  r   r   r   r   r   r   r   s    rX   r   zSymbolicEquivSet.clone,  s      LL99T[[)99T[[)yy1499%yy1}}T__5}}T__5MM

 
	
rZ   c                 .    t        | j                  |      S )zjRetrieve a definition pair for the given variable,
        or return None if it is not available.
        )r   _get_or_set_relr  s     rX   get_relzSymbolicEquivSet.get_rel;  s     T))400rZ   c                     t        |t        j                        r|j                  }t	         j
                  j                  |d      dk(         | j                  v r j                  |   S t	        |du       d fdt        ||      }|df}t        |t        j                        rO|j                  dk(  rt        || j                        \  }}|dk(  r_|d	k(  rYt         fd
|j                  D              }d|v ry j                  j                  |g       }|j!                  |       t#        |      dkD  r j%                  |       | j                  |<   n|j                  dk(  rˉ j'                  |j(                  |      }	 j'                  |j*                  |      }
|	|
y|j,                  t.        j0                  k(  r
 |	|
      }ng|j,                  t.        j2                  k(  rJ |	|
      }n@t        |t        j4                        r&t        |j6                  t8              r|j6                  }t	        |du       | j                  |<   t        |t8              s t        |t              r|d   |k7  s|d   dk7  rt        |t              r|\  }}| j:                  vrg  j:                  |<    j:                  |   j!                  || f        j=                  |      }|dk\  rs j>                  |   }g }|D ]<  }| j:                  v s| j:                  |   D cg c]  \  }}|| k(  r| c}}z  }> t#        |      dkD  rt@        tB         K  |       |S c c}}w )zRetrieve a definition pair for the given variable,
        and if it is not already available, try to look it up
        in the given func_ir, and remember it for future use.
        r   r:   Nc                     t        | t              }t        |t              }|r|r| |z   S |\  }}|| |z   fS | \  }}|r|||z   fS y rh   r[   r   )r   y
x_is_const
y_is_constr  offsets         rX   plusz.SymbolicEquivSet._get_or_set_rel.<locals>.plusN  s_    '3/
'3/
! 1u()f #QZ00$%MS&! #QZ00#rZ   c                     t        |t              r
 | |       S t        | t              r*t        |t              r| d   |d   k(  r | d   |d         S y Nr   r:   )r[   r   r   )r   r?  minusrC  s     rX   rF  z/SymbolicEquivSet._get_or_set_rel.<locals>.minus^  sV    a%A2;&q%("1e,!! 1qt,,rZ   callr   ra   znumba.parfors.array_analysisc              3   j   K   | ]*  }j                   j                  |j                  d        , yw)r   N)r   r   r   r   s     rX   rn   z3SymbolicEquivSet._get_or_set_rel.<locals>.<genexpr>u  s*      &ENDOO//;Ys   03r   binop)"r[   r   r   r   r   r   r   r1  r   Expropr   r   r   rI   r3  r   rx   r   r:  lhsrhsfnoperatorrE   subr   r   r   r2  r   r   r   r/  )r   r   func_irexprr   fnamemod_namer%  r   rM  rN  r  rB  r   r   r   r   r   rF  rC  r   s   `                 @@rX   r:  z SymbolicEquivSet._get_or_set_relA  s   
 dBFF#99D		dA&!+,4;;;;t$$G4'($ 
  "'40D1IE$(77f$&3t||'OE8 -$(FF % &EIYY& ! ;#' $ 3 3E2 >T*u:> LL/16.WW'..txxAC..txxAC {ck#HLL0 $S#HLL0 %c3D"((+
4::s0K

E%& %DKK%%5%(1X%qQ eU+$)MS&4;;.+-C(KK$++TF7O<--,Cax#s3 "#'C"dkk1 %26++c2B*"2BA'(VG| %&2B*" !" $( u:>!"2DA%HL*"s   -M*
c                    t        |t        j                        r|j                  }n|}t        t
        |   ||       |r| j                  j                  |d      dk(  rt        |t        j                        rt        | j                  ||      }t        |t              r| j                  ||g       t        |t        j                        r{| j                  |      }|| j                   vr|g| j                   |<   || j"                  |<   || j$                  v r| j$                  |   j'                  |       y|g| j$                  |<   yyyy)af  Besides incrementing the definition count of the given variable
        name, it will also retrieve and simplify its definition from func_ir,
        and remember the result for later equivalence comparison. Supported
        operations are:
          1. arithmetic plus and minus with constants
          2. wrap_index (relative to some given size)
        r   r:   TN)r[   r   r   r   r   r/  r)  r   r   r   Numberr   r:  r   r   r   r   r   r   r   )	r   r  r&  rR  r   r   r   r   r   s	           rX   r)  zSymbolicEquivSet.define  s    c266"88DD,T9=		dA&!+3-$..g>E%%dE]+#rvv&**40t.,06DOOC(,/DOOD)$//)OOC(//4  -05DOOC( . , rZ   c                 n   t               }t               }|D ]Q  }| j                  |      }|dk(  r|j                  |       +||vs0|j                  |       |j                  |       S t        |      dk  ryt	        |      }t
        t        |   |       | j                  | j                  |d            }i }d }|D ]  }|| j                  v r~| j                  |   }t        |t              r_|\  }	}
 |||
       j                  |	       |	| j                  v r3| j                  |	   D ]!  \  }} |||
|z          j                  |       # || j                  v s| j                  |   D ]  \  }	}
 |||
      j                  |	         |j                         D ]  }| j                  |        y)zOverload _insert method to handle ind changes between relative
        objects.  Returns True if some change is made, false otherwise.
        r   r:   Fr   c                 *    || v r| |   }|S g }|| |<   |S rh   rd   )dr"  r   s      rX   
get_or_setz,SymbolicEquivSet._insert.<locals>.get_or_set  s.    AvaD H !HrZ   T)r   r   rE   rx   r  r   r/  r   r   r1  r[   r   r   r2  r   )r   r   indsetuniqsr   r   offset_dictr[  r   r   rB  r   r   r   r   s                 rX   r   zSymbolicEquivSet._insert  s    C--$Cby		#Vm		#

3  u:?U-e4t}}U1X67 	 Cdkk!C(eU+%*NT6{VG4;;DAt{{*&*kk$&7FQ&{fqjMBII!L '8dkk!&*kk#&6NT6{F3::4@ '7  !'')ELL *rZ   c                 z    t        |t        j                  t        j                  f      sJ || j                  |<   y)z-remember shapes of SetItem IR nodes.
        N)r[   r   StaticSetItemSetItemr3  )r   r   rs   s      rX   set_shape_setitemz"SymbolicEquivSet.set_shape_setitem  s1     # 0 0"**=>>>$rZ   c                 n   t        |t        j                  t        j                  f      r&t	        || j
                  v        | j
                  |   S t        |t        j                        sJ | j                  |j                     }t        |t        j                        r|fS t        t        | 7  |      S )zGOverload _get_shape to retrieve the shape of SetItem IR nodes.
        )r[   r   r`  ra  r   r3  r   r   r   r   rk   r   r/  r  )r   r   r   r   s      rX   r  zSymbolicEquivSet._get_shape  s     cB,,bjj9:C4??*+??3''c266***,,sxx(C#u/v-t?DDrZ   )NNNNNNNr   rh   NN)r   r   r   r   r   r   r   r   r;  r:  r)  r   rb  r  r,  r-  s   @rX   r/  r/    s`     +
Z.



1kZB,\%E ErZ   r/  c                       e Zd ZdZd Zy)WrapIndexMetaa  
      Array analysis should be able to analyze all the function
      calls that it adds to the IR.  That way, array analysis can
      be run as often as needed and you should get the same
      equivalencies.  One modification to the IR that array analysis
      makes is the insertion of wrap_index calls.  Thus, repeated
      array analysis passes should be able to analyze these wrap_index
      calls.  The difficulty of these calls is that the equivalence
      class of the left-hand side of the assignment is not present in
      the arguments to wrap_index in the right-hand side.  Instead,
      the equivalence class of the wrap_index output is a combination
      of the wrap_index args.  The important thing to
      note is that if the equivalence classes of the slice size
      and the dimension's size are the same for two wrap index
      calls then we can be assured of the answer being the same.
      So, we maintain the wrap_map dict that maps from a tuple
      of equivalence class ids for the slice and dimension size
      to some new equivalence class id for the output size.
      However, when we are analyzing the first such wrap_index
      call we don't have a variable there to associate to the
      size since we're in the process of analyzing the instruction
      that creates that mapping.  So, instead we return an object
      of this special class and analyze_inst will establish the
      connection between a tuple of the parts of this object
      below and the left-hand side variable.
    c                      || _         || _        y rh   )
slice_sizedim_size)r   rh  ri  s      rX   r   zWrapIndexMeta.__init__/  s    $ rZ   N)r   r   r   r   r   rd   rZ   rX   rf  rf    s    6!rZ   rf  c                   `   e Zd ZdZ	 d Zd Zd ZdbdZd Zd Z	d	 Z
d
 Zd Z G d de      Zd Zd Zd Zd Zd Z	 dcd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# Z$d$ Z%d% Z&d& Z'd' Z(d( Z)d) Z*d* Z+d+ Z,d, Z-d- Z.d. Z/d/ Z0d0 Z1d1 Z2d2 Z3d3 Z4d4 Z5d5 Z6d6 Z7d7 Z8d8 Z9d9 Z:d: Z;d; Z<d< Z=d= Z>d> Z?d? Z@d@ ZAdA ZBdB ZCdC ZDdD ZEdE ZFdF ZGdG ZHdH ZIdI ZJdJ ZKdK ZLdL ZMdM ZNdN ZOdO ZPdP ZQdQ ZRdR ZSdS ZTdT ZUdU ZVdV ZWdW ZXdX ZYdY ZZdZ Z[d[ Z\ddd\Z]ddd]Z^d^ Z_d_ Z`d` Zada Zby)eArrayAnalysisr   c                     || _         || _        || _        || _        i | _        i | _        i | _        i | _        i | _        y rh   )	rF   rR  r   	calltypes
equiv_setsarray_attr_callsobject_attrsprependspruned_predecessors)r   rF   rR  r   rm  s        rX   r   zArrayAnalysis.__init__>  sF    "  "#% rZ   c                      | j                   |   S )zAReturn the equiv_set object of an block given its label.
        )rn  )r   block_labels     rX   r   zArrayAnalysis.get_equiv_setO  s     {++rZ   c                     t               }|D ]4  }| j                  D ]#  }| j                  |   }|j                  ||       % 6 y)zTake a set of variables in redefineds and go through all
        the currently existing equivalence sets (created in topo order)
        and remove that variable from all of them since it is multiply
        defined within the function.
        N)r   rn  r)  )r   
redefinedsunusedr   eslabeless         rX   remove_redefinedszArrayAnalysis.remove_redefinedsT  s?     A??__W-		!V$ + rZ   Nc                 F   || j                   j                  }t        | j                   j                        | j                   _        |t	        | j
                        }n|}t        || j                   j                  | j
                  | j                         \  | _        | _	        t        j                  }t        xj                  dz  c_        t        j                  dk\  rt        d|       t        | j                   d|       t        j                  dk\  rCt        dt!        | j
                  j#                                      t        d| j$                         t'        |      }t)        ||      }| j+                  ||||       t        j                  dk\  rS| j-                          t        dt!        | j
                  j#                                      t        d	| j$                         t        | j                   d
|       t        j                  dk\  rt        d|       yy)zrun array shape analysis on the given IR blocks, resulting in
        modified IR and finalized EquivSet for each block.
        Nr:   zStarting ArrayAnalysis:zbefore array analysiszArrayAnalysis variable types: zArrayAnalysis call types: )cfgz#ArrayAnalysis post variable types: zArrayAnalysis post call types: zafter array analysiszEnding ArrayAnalysis:)rR  blocksr   _definitionsr/  r   r   	arg_names	alias_maparg_aliasesrk  aa_countr   r   r   r
   r  r  rm  r   r	   _run_on_blocksdump)r   r}  r   init_equiv_setaa_count_saver|  
topo_orders          rX   runzArrayAnalysis.run`  s    >\\((F$5dll6I6I$J!-dll;N&N+ALL""LLLL	,
(( &..!#!!Q&+];t||%<fE!!Q&0&9K9K9M2N .?%f-$V5
J^D!!Q&IIK5t||))+, 3T^^Dt||%;VD!!Q&)=9 'rZ   c                     |D ]Y  }t         j                  dk\  rt        d|       ||   }|j                  }| j	                  |||||      }| j                  ||       [ y )Nr   zProcessing block:)r   r   r   scope_determine_transform_combine_to_new_block)	r   r  r}  r|  r  labelblockr  pending_transformss	            rX   r  zArrayAnalysis._run_on_blocks  sf    E%%*)515MEKKE!%!:!:UE5." &&u.@A  rZ   c                     g }|D ]G  \  }}}|D ]  }|j                  |        |j                  |       |D ]  }|j                  |        I ||_        y)zWCombine the new instructions from previous pass into a new block
        body.
        N)r   body)r   r  r  new_bodyinstprepostinstrs           rX   r  z#ArrayAnalysis._combine_to_new_block  sZ     1OD#t& OOD!& 	  2 
rZ   c           	         d}|j                  |      }|| j                  v r| j                  |   }ng }t        j                  dk\  rt	        d|       |D ]  \  }	}
t        j                  dk\  rt	        d|	|
       |	|v r,|	| j
                  v s;| j
                  |	   j                         }t        j                  dk\  rt	        d|       |	|f| j                  v rH| j                  |	|f   }|D ]2  }t               }| j                  |||||       | j                  |       4 ||}|j                  |      }t               }|j                  |j                  |       | j                  |        ||}|| j
                  |<   g }|j                  D ]W  }t               }| j                  |||||      \  }}t        |      dkD  r| j                  |       |j!                  |||f       Y |S )zGDetermine the transformation for each instruction in the block
        Nr   zpreds:zp, q:zp in equiv_setsr   )predecessorsrr  r   r   r   rn  r   rq  r   _analyze_instrz  r   r+  r   r  rx   r   )r   r|  r  r  r  r  r   predsprunedpqfrom_setinstrsr  r&  r  r  r  s                     rX   r  z"ArrayAnalysis._determine_transform  s    	  'D,,,--e4FF !!Q&(E"FQ%%*gq!$F{DOO#??1-335))Q.+X6u:.!]]Au:6F &$'E	**!5(D) ..y9 !' $ (I ) 3 3H =I #I((	B **95; @ &I!*  JJDI**uiyIC
 9~!&&y1%%tS$&78  "!rZ   c                 0    t        d| j                         y)z@dump per-block equivalence sets for debugging purposes.
        zArray Analysis: N)r   rn  r   s    rX   r  zArrayAnalysis.dump  s     	 $//2rZ   c                     || j                   |j                  <   |g| j                  j                  |j                  <   t	               }|j                  ||| j                  |       y rh   )r   r   rR  r~  r   r)  )r   r   r  r   r   rv  s         rX   _definezArrayAnalysis._define  sM    !$SXX/4g!!#((+U
j$,,<rZ   c                       e Zd Zd Zy)ArrayAnalysis.AnalyzeResultc                     || _         y rh   )kwargs)r   r  s     rX   r   z$ArrayAnalysis.AnalyzeResult.__init__  s	     DKrZ   N)r   r   r   r   rd   rZ   rX   AnalyzeResultr    s    	!rZ   r  c           
      x   &' g }g }t         j                  dk\  rt        d       t        t        j
                        r@j                  } j                  |j                     }	d }
t        |	t        j                        r|	j                  dk(  rd}
nt        j                  t        j                        rމ j                  j                  |      }|rgt        t        |t         j"                               d|j$                  v r|j$                  d   }
d|j$                  v r|j'                  |j$                  d          d|j$                  v r|j'                  |j$                  d          d|j$                  v r|j$                  d   _        nt        j                  t        j(                  t        j*                  f      rj                  }
nht        j                  t        j,                        rPj                  j                  }t        |t.              rt1        d	 |D              r|}
nt        |t2              r|f}
nt        j                  t        j4                        rt        |	t        j6                  j8                        r1t        |	j:                  t        j<                        rj                  }
n{t        |	t        j6                  j>                        rWt1        |	j                  D cg c],  }t        |t        j<                  t        j@                  f      . c}      rj                  }
t        |
t        j*                        rft        |
j                  t.              r+|
jB                  't/        'fd
|
j                  D              }
nt        |
j                  t2              r|
f}
nd }
nt        |
t        j(                        r5t         j                  |
j                     t        j<                        r|
f}
nxt        |
tD              rh	 jG                  || jH                  |	       jK                  |j                        }|dk7  r%|jL                  |
jN                  |
jP                  f<   ||fS t        |	t        j                        r|
Wt        |
t        j(                        r=t         j                  |
j                     t        j6                  jR                        rnK|
=t        |
t.              s-t        |
t        j(                        rjU                  |
      s jW                  ||	j                  |
|      }
nt        |	t        j8                        rE|
rt        |	j:                  t        j<                        r jW                  |tY        |	      |
|      }
nt        |	t        j6                  j>                        rit1        |	j                  D cg c],  }t        |t        j<                  t        j@                  f      . c}      r jW                  |tY        |	      |
|      }
	 d}|
j[                  ||
      }|rjG                  || jH                  |	       ||fS t        t        j\                  t        j^                  f      rt        t        j^                        rj`                  njb                  }te         jf                  j                  |      }|sg g fS |d   6t        t        j\                  t        j^                  f      sJ |d   _0        |d   }|j$                  d   }d|j$                  v r|j$                  d   }ji                  j                        }|dk(  rjk                  |       |g fS | j                  j                  j                     }t        t        |t        j                               |j                  }||g}j                  j                  j                  j                  g} jm                  jB                  ||      }t        d|j$                  v        t        d|j$                  v        |j$                  d   }
|j$                  d   }tY        |
      }||k\  sJ jk                  |
       ||z   g fS |g fS t        t        jn                        r& fd}jp                  &te        tr         jH                  &      }|s#ju                  &      }g }|D ]  }t        |tv              rf| j                  v rXte        tr         jH                  |d      }t        |t        j(                        r|j                  }|sg|jy                  |       y|jy                  |        t{        t}        d |            } t{        |      j                  |       }!tY        |!      dk(  rt        |!      d   }n5tY        |       dk(  r'te        tr         jH                  t        |       d         }t        |t        j                        r|j                  dk(  r ||       ||fS t        |t        j                        r|j                  dk(  rte        tr         jH                  |j                        }"|"*|"j                  t        u rtY        |j                        dk(  rte        tr         jH                  |j                  d         }#|#t        |#t        j                        r|#j                  dk(  r ||#       ||fS t        |t        j*                        r|j                  }t        |t2              st        |t              rZ|rj                  nj                  }$|$ j                  v r" j                  |$   jy                         ||fS g j                  |$<   ||fS t              t        v r*t        t                 }% |% j                         \  }}||fS c c}w c c}w )Nr   zanalyze_inst:r   rd   rs   r  r  rN  c              3   <   K   | ]  }t        |t                y wrh   r>  )rl   r   s     rX   rn   z.ArrayAnalysis._analyze_inst.<locals>.<genexpr>  s     CFq
1c 2Fs   c              3   J   K   | ]  }t        j                  |        y wrh   )r   r   )rl   r   locs     rX   rn   z.ArrayAnalysis._analyze_inst.<locals>.<genexpr>2  s     !HKq"((1c"2Ks    #r   Tr:   c                    d }| j                   t        j                  k(  rj                  }j                  }d}n7| j                   t        j
                  k(  rj                  }j                  }d}j                  | j                  j                     }j                  | j                  j                     }|,t        |t        j                        rt        |t        j                        s4t        |t        j                        rt        |t        j                        rj                  }| j                  | j                  f}j                  |
|      }|j!                  t#        j$                  t#        j&                  |      	|             |j(                  |f<   t#        j$                  t#        j&                  d|z
  |      	|      gj(                  f<   y y y y )Nr:   r   )rO  rP  eqtruebrfalsebrner   rM  r   rN  r[   r   r]   rj   r  _make_assert_equivr   r   Assignr   rq  )cond_defbrotherbrcond_vallhs_typrhs_typr  rI   assertscond_varr   r  r  r  r   s            rX   handle_call_binopz6ArrayAnalysis._analyze_inst.<locals>.handle_call_binop  s|   ;;(++-B"llG H[[HKK/B"kkG H,,x||'8'89,,x||'8'89>"7EMM:&w> #7EOO<&w@ ((C$LL(,,7D"55sItG NN		"((8S"98SI 29DMM5"+.		"((1x<"=xM7DMM5'"23 A = "rZ   )lhs_onlyc                 "    t        | t              S rh   )r[   r   )r   s    rX   <lambda>z-ArrayAnalysis._analyze_inst.<locals>.<lambda>  s    z!S/ArZ   rJ  rG  )Jr   r   r   r[   r   r  targetr   r   r   ri   r   r   rK  _analyze_exprr   rk  r  r  extendr   r   Globalr   r   r   Arg
containersUniTupledtyper]   TupleIntegerLiteralr  rf  r)  rR  r   r5  rh  ri  rj   r  _gen_shape_callrx   r   r`  ra  r%  	index_varr   _index_to_shaper  rb  _broadcast_assert_shapesBranchcondr   r   r   r   r   filter
differencer  rL  funcboolrI   r  r  rr  r   array_analysis_extensions)(r   r  r  r   r  r&  r  r  rM  r   rs   resultgvaluer   lhs_indneeds_definer%  target_shapevalue_shape
target_typtarget_ndimshapesr   broadcast_resultr  r   r  r  equivsr   r   var_defdefvars	defconsts	glbl_bool	condition	pruned_brr2   r  r  s(   `````                                 @@rX   r  zArrayAnalysis._analyze_inst  s	   !!Q&/4(dBII&++C,,sxx(CE#u445#((a-DJJ0++E9djj#NJv}/J/JKL&--/ &g 6-

6==#78.FMM&$9:-%+]]5%9
DJJ(:;

DJJ		2)) vu-CFCC"E,#IEDJJ/sE$4$4$=$=>"399emm< JJEsE$4$4$:$:;!$,!*A ("]]E,@,@AC!*, 
 !JJE%*ekk51))C!!HEKK!HHES1"HE EE266*zUZZ(%--0 E=1   isC#,,SXX6b=   &&))5>>: Dy #u445%"5"&&1"UZZ0%2B2B2L2L M!%/"5"&&1 ) 3 3E : !00!3%E C0Z		5==A 00!3C%E 3 0 0 6 67 YY(& $A(<(<=?&( 
 ,,sCHeT  L (55c5A  isCH DyG r//<=(rzz:

  $$eYUF 2vay$!$)9)92::(FGGG#AY
AYF!==1L%mmE*#--djj9Kb ++D,?Bw(!\\$++*:*:;

:u/D/DEF(oo&4))4::??;#'#@#@9dhh$  #3#:#::;!1!8!889(//8*11%8J"a'''++D%8W}b((Bwbii(! !F yyH^T\\8DH"00:"D!$,1E"'*DLL$# &grvv6&-llG" KK0D) # f%A4HII009	y>Q&#Iq1H\Q&$&d7mA6F H (BGG,1G!(+8 Dy7 Hbgg.8;;&3H!.$,,N	(Y__-D8==)Q.$).$,,*2--*:%<	%1&y"'': ) 7-i8" Dy h1'~~Hh,
8T0J08dkkI D$<$<<00;BB5I Dy @Eg00; Dy $Z44)$t*5A$	4<<>ICDy{,|(s   1p251p7c                     dj                  |j                        }	 t        | |      }t	        |||||      S # t        $ r Y y w xY w)Nz_analyze_op_{})r   rL  getattrAttributeErrorr   )r   r  r   rS  rM  rT  rO  s          rX   r  zArrayAnalysis._analyze_expr  sP     ''0	u%B R	455  		s   8 	AAc                    |j                   dk(  rO| j                  |j                  j                        r*| j	                  |||j
                  |j                  gi       S |j                   dk(  r1|j                  |j                        }t        j                  |      S |j                   dv rE| j                  |j                  j                        r t        j                  |j                        S | j                  |j                        rt        |j                  j                  | j                        }||j                   f| j                  v r/t        j                  | j                  ||j                   f         S | j                  |j                     }g }| j                  |||j                  d |      }|| j                  ||j                   f<   t        j                  ||      S y )NTrs   rs   )realimag)rs   r  )attr_isarrayr   r    _analyze_op_call_numpy_transposer  r  rk  r  r   r  rp  r   r  r   )	r   r  r   rS  rM  rs   canonical_valuer   r  s	            rX   _analyze_op_getattrz!ArrayAnalysis._analyze_op_getattr  s   99djjoo >88y$((TZZL"  YY'!''

3E ..U.;;YY**t}}TZZ__/M !..TZZ.@@]]388$1

O  +t/@/@@$22++_dii,HI 3   ll388,,,sCHHdD CH!!?DII">?$22T2JJrZ   c                 B    t         j                  |j                        S Nr  )rk  r  r   r   r  r   rS  rM  s        rX   _analyze_op_castzArrayAnalysis._analyze_op_cast/  s    ***<<rZ   c                 $   |j                   }| j                  |j                     }t        |t        j
                        rQt        t        |      |j                  k(         t        |j                  |             t        j                  |      S y r  )r   r   r   r[   r   rj   r   rx   countr  rk  r  )r   r  r   rS  rM  r  r   s          rX   _analyze_op_exhaust_iterz&ArrayAnalysis._analyze_op_exhaust_iter2  sj    jjll388$c5??+CH

*+I'',- ..S.99rZ   c                    t        j                  |t        |      |      }t        j                  ||      }t	        j
                  |      }	|j                  t        j                  |||             | j                  |||	|       ||	fS )Nr   r  r  )	r   r   r   r   r   r  r   r  r  )
r   arg_valr  r  stmtsr   r   static_literal_slice_part_varstatic_literal_slice_part_valstatic_literal_slice_part_typs
             rX   gen_literal_slice_partz$ArrayAnalysis.gen_literal_slice_part;  s     )+umD6I3(O%(*#(>%(-(<(<W(E%II34	
 	)))		
 -.KKKrZ   c                 >    | j                  ||z
  ||||d      ^}}|S )Nstatic_slice_size)r   )r   )	r   lhs_relrhs_relr  r  r  r   the_var_s	            rX   gen_static_slice_sizez#ArrayAnalysis.gen_static_slice_sizeX  s;     11g$ 2 
! rZ   c
                    t        |t              rJ t        j                  |t	        d      |      }
t        j
                  j                  t        j                  |||      }t        j                  }t        |||      | j                  |<   |j                  t        j                  ||
|             | j                  |	|
||       |
|fS )Nexplicit_negr  r  )r[   r   r   r   r   rK  rJ  rP  rE   r   r^   r   rm  r   r  r  )r   argarg_relarg_typsize_typr  r  dsizer  r   explicit_neg_varexplicit_neg_valexplicit_neg_typs                rX   gen_explicit_negzArrayAnalysis.gen_explicit_nege  s     h,,,66%~)FL77==ucs=K !::+4h,
'( 	II,5E3O	
 	')9;K	
  !111rZ   c                    d}t        |t              r[|dk(  rd}nRt        |t              rd}t        ||      }||k7  r.t        j                  dk\  rt        d       d}| j                  |||	|
|      \  }}|dk(  s|dk(  sJ |dk(  r||j                  d   f|_        n|j                  d   |f|_        |j                  |   }|}|j                  |      }n|dk  rd}t        j                  dk\  rt        d       | j                  ||||||	||
|	      \  }}|dk(  r||j                  d   f|_        n|j                  d   |f|_        |j                  |   }|}|j                  |      }||||||fS )NFr   Tr   z.Replacing slice to hard-code known slice size.r:   z,Replacing slice due to known negative index.)
r[   r   re   r   r   r   r   rI   r;  r  )r   rM  r  r  	dsize_relreplacement_sliceslice_indexneed_replacementr  r  r  r   r  r  knownwilliteral_varliteral_typr  r  s                       rX   update_replacement_slicez&ArrayAnalysis.update_replacement_slice  s   $ gs# !|Is+()< '>--2NO'+$/3/J/JS%	0,K '!+{a/???"a''-22152). .2215'2).
 ,00=C)G'//4G1#' ))Q.HI595J5J
62 "2 !#()..q1.%* *..q1(.%*
 (,,[9*#++C0
 	
rZ   c                    -./ |j                   -t         j                  |      }t         j                  | j                        \  }}t        |dk(  xr |dv        t        t        |j                        dk(         |j                  d   }	|j                  d   }
 j                  j                     } j                  |	j                     } j                  |
j                     }t        j                  dk\  r#t        d| d d	| d
|	 d|
 d| d| d|        t        j                  |      }d}t        |t        j                         rt#        j$                  t'        d      -      }t#        j(                  d-      }|j+                  t#        j,                  ||-              j/                  |t        j0                  d      |       |}	t        j0                  d      }|	|j                  d   f|_        d}t        j                  dk\  rt        d       t        |t        j                         r:}
|}|j                  d   |
f|_        d}t        j                  dk\  rt        d       j3                  |	      }j3                  |
      }j3                        }t        j                  dk\  rt        d|d|d|        j5                  |	||||d|-||      \  }	}}}}} j5                  |
||||d|-||      \  }
}}}}}t        j                  dk\  rt        d|       t        d|       |sd}nt#        j$                  t'        d      -      }t        j6                  t        j6                  f} j                  |j8                  j                     j;                   j<                  |i       }| j>                  |<   |j+                  t#        j,                  ||-              j                  |j                      j                  |j                  <   t        j                  dk\  rt        dd|d|       |r8|r6t        j                  dk\  rt        d        jA                  ||-|      |fS |dk(  r1t        |tB              r!jE                  |d         r|d   dk(  rdfS t        j6                  }|}t#        j$                  t'        d      -      }t"        jF                  jI                  tJ        jL                  |
|	-      }tO        |||       j>                  |<    j/                  |||       j3                  |      }t        j                  dk\  rt        d|tQ        |             t#        j$                  t'        d       -      /t#        jR                  d!tT        -      }tW        tT              }  j<                  jY                  | ||fi       . j/                  /| |       - ./fd"}! |!|	||      \  }"}#}$ |!|
||      \  }%}&}'|j+                  t#        j,                  ||-             |j+                  t#        j,                  |/-             |$'|j+                  t#        j,                  |$|"-             |''|j+                  t#        j,                  |'|%-             t#        j$                  t'        d#      -      }(t"        jF                  jI                  tJ        jL                  |%|"-      })tO        ||&|#       j>                  |)<    j/                  |(||)       |j+                  t#        j,                  |)|(-             t        |tB              rt        j                  dk\  rt        d$jZ                         d}*jZ                  j]                         D ]-  \  }+},|+d   |d   k(  sjE                  |+d   |d         s+|,}* n |*Mt        j                  dk\  rt        d%|*       j_                  ||*d          j_                  |(|*d          |(|fS ||(fjZ                  |<   |(|fS )&a  Reason about the size of a slice represented by the "index"
        variable, and return a variable that has this size data, or
        raise GuardException if it cannot reason about it.

        The computation takes care of negative values used in the slice
        with respect to the given dimensional size ("dsize").

        Extra statements required to produce the result are appended
        to parent function's stmts list.
        rH  slicebuiltinsr   r   r:   zslice_size index=z dsize=z index_def=z lhs=z rhs=z
 size_typ=z	 lhs_typ=z	 rhs_typ=FrO   r  Tz$Replacing slice because lhs is None.r  r  r  z
lhs_known:z
rhs_known:Nr  zafter rewriting negativesz'lhs and rhs known so return static sizerh  r
  size_relwrapra   c                 
   |s|t        j                  	t        d            }t        j                  }t         j
                  j                  | gi       }
j                  |||       
j                  |<   |||fS | |d fS )Nr  )	r   r   r   r   r^   rK  rG  r  rm  )r   val_typr  r  var_typ	new_valuer  r   r  r  r   rH   wrap_vars         rX   gen_wrap_if_not_knownz7ArrayAnalysis.slice_size.<locals>.gen_wrap_if_not_known  s~    ffUM%$8#>**GGLLC<SI	 YWi@,/y)Wi00Wd++rZ   post_wrap_slice_sizezsize_rel is tuplezestablishing equivalence to)0r  r   rR  r   r   r   rx   rI   r   r   r   r   r   r   r[   r   r   r   r   r   r   r   r  r  r  r;  r  r^   r  get_call_typerF   rm  r  r   r   rK  rJ  rP  rQ  r   r   r  ra   r   resolve_function_typer4  r  r   )0r   r%  r  r   r  r  	index_defrT  rU  rM  rN  r  r  r  r  r  zero_varrO   r  r  r  	lhs_known	rhs_knownreplacement_slice_varnew_arg_typsrs_calltype	slice_typorig_slice_typsize_varsize_valr!  wrap_deffntyr(  var1var1_typvalue1var2var2_typvalue2post_wrap_size_varpost_wrap_size_valrel_map_entryrme	rme_tupler  rH   r'  s0   ` ```                                        @@@rX   rh  zArrayAnalysis.slice_size  s    ii"4<<7	'LL)T\\
x 	 =X*%=>INN#q()nnQnnQ<<

+,,sxx(,,sxx(!!Q&%eWGE7 ;(kse5 >&Zy	7)M N !MM)4  gu~~.vve]6%:C@H88As#DLLhCHILLHe.B.B1.EtLC**1-G&)+<+A+A!+D%E"#%%*<= gu~~.CG&7&<&<Q&?%E"#%%*<=##C(##C(%%e,	!!Q&7IwY ))
	
. ))
	
  !!Q&,	*,	*  $(! %'FF}%893%! "JJ

3L,,y~~':':;IIlBK 1<DNN,-LL		+0 8<||EJJ7ODLL.334!!Q&+ %%*?@**Wc5% &	  qL7E*""5'!*5
a$;JJ	"66%|!<cB77==sCS=A#,Y#Ix Y)X>$$X.!!Q&*hX766%v!6<99\:3?":.ll00>8,b
 	Y$9	, 	, "7sGY!Oh!6sGY!OhRYYXhCHIRYYXhCHILL#FGLL#FGVV=!78#
  WW]]8<<+/+//2 + 4 .7x.
)* 	)96H	
 	II(1C	
 h&%%*)9+<+<= M"+"3"3"9"9";Yq6Xa[(Y-?-?FHQK. %.M #< ( ))Q.7G&&xq1AB&&'9=;KL "#888 089K.L	!!(+!#888rZ   c                 \     j                   |j                     }t        t        |t        j
                                j                   |j                     }j                  |      }j                  |      }t        |t        j                        r|f}	|f}
n^t        t        |t        j                               t         j                  |      \  }
}t        |dk(         t         fd|
D              }	t        t        |      t        |	      cxk(  xr t        |      k(  nc        g  fd}g }g }d}t        |	|||
      D ]L  \  }}}} ||||      \  }}|j                  |       |d}|j                  |       <|j                  |       N |rt        |      dkD  rt        j                   t#        d      |d	   j$                        }t        j&                  j)                  ||d	   j$                        }j                  t        j*                  |||d	   j$                  
             | j                   |j                  <   n|d	   }nd}t        |      }t        t-        d |D                      t        d |D              }|t.        j1                  |      fS )a  For indexing like var[index] (either write or read), see if
        the index corresponds to a range/slice shape.
        Returns a 2-tuple where the first item is either None or a ir.Var
        to be used to replace the index variable in the outer getitem or
        setitem instruction.  The second item is also a tuple returning
        the shape and prepending instructions.
        build_tuplec              3   P   K   | ]  }j                   |j                       y wrh   )r   r   r   s     rX   rn   z0ArrayAnalysis._index_to_shape.<locals>.<genexpr>  s     ?3aT\\!&&13s   #&c                     t        | t        j                        rj                  ||      S t        | t        j                        ryt        d       y )Nrd  F)r[   r   rk   rh  rW  r   )r   r%  r  r   r  r   r  s      rX   to_shapez/ArrayAnalysis._index_to_shape.<locals>.to_shape  sB    #u/ueYuMMC.! rZ   FNTr:   replacement_build_tupler   r  c              3   $   K   | ]  }|d u  
 y wrh   rd   rl   r   s     rX   rn   z0ArrayAnalysis._index_to_shape.<locals>.<genexpr>?  s     15aT	5s   c              3   &   K   | ]	  }||  y wrh   rd   rK  s     rX   rn   z0ArrayAnalysis._index_to_shape.<locals>.<genexpr>@  s     8A!-as   rs   r  )r   r   r   r[   r   ri   r  rk   rj   r   rR  r   rx   ry   r   r   r   r   r  rK  rE  r  r   rk  r  )r   r  r   r  ind_varr   ind_typ	ind_shape	var_shapeseq_typsseqrL  rH  
shape_listindex_var_listreplace_indexrM   r  orig_ind
shape_partindex_var_partreplacement_build_tuple_varnew_build_tuplers   r  s   ```                     @rX   r  zArrayAnalysis._index_to_shape  sn    ll388$
3 5 567,,w||,((1	((-	gu/zH*CJw89)$,,@GCB-'(?3??HI#h-A3y>AB	 
,/090903-5(S$x
 *2#tU)C&Jj)
 ) $%%n5%%h/!-5( >"Q&.0ff!";<aL$$/+ #%''"5"5"IaL$4$4# II-:%aL,, BI8==>.<Q.?+*.'j!C151112888+++%U+CE 	ErZ   c                 z    | j                  |||j                  |j                        }|d   
|d   |_        |d   S rE  )r  r   r%  )r   r  r   rS  rM  r  s         rX   _analyze_op_getitemz!ArrayAnalysis._analyze_op_getitemD  s?    %%eY

DJJO!9 DJayrZ   c                 h   |j                   }| j                  |j                     }t        |t        j
                        s<| j                  |||j                   |j                        }|d   
|d   |_        |d   S |j                  |      }t        |j                  t              rDt        |j                  t        |      k         t        j                  ||j                           S t        |j                  t              r#t        j                  ||j                           S t        d       y )Nr   r:   r  F)r   r   r   r[   r   rj   r  r  r  r%  r   r   rx   rk  r  r  )	r   r  r   rS  rM  r  r   r  rs   s	            rX   _analyze_op_static_getitemz(ArrayAnalysis._analyze_op_static_getitemJ  s    jjll388$#u/))y$**dnnF ay$!'!9$$S)djj#&DJJU+, ..U4::5F.GG

E* ..U4::5F.GGrZ   c                     t        |j                  t        v        | j                  |j                  j
                        s|j                  t        j                  k(  r t        j                  |j                        S y r  )
r   rO  UNARY_MAP_OPr  r   r   rP  rE   rk  r  r  s        rX   _analyze_op_unaryzArrayAnalysis._analyze_op_unary\  sS    <'( ==)TWW-D ..TZZ.@@rZ   c                     t        |j                  t        v        | j                  |||j                  |j
                  |j                  g|j                        S rh   )r   rO  BINARY_MAP_OP_analyze_broadcastr  rM  rN  r  s        rX   _analyze_op_binopzArrayAnalysis._analyze_op_binopd  sF    =()&&9dhh488(<dgg
 	
rZ   c                     t        |j                  t        v        | j                  |||j                  |j
                  |j                  g|j                        S rh   )r   rO  INPLACE_BINARY_MAP_OPre  r  rM  rN  r  s        rX   _analyze_op_inplace_binopz'ArrayAnalysis._analyze_op_inplace_binopj  sG    001&&9dhh488(<dgg
 	
rZ   c                 \    | j                  |||j                  |j                         d       S rh   )re  r  	list_varsr  s        rX   _analyze_op_arrayexprz#ArrayAnalysis._analyze_op_arrayexprp  s+    &&9dhh(8$
 	
rZ   c           	         |j                   D ]w  }t        |t        j                        st        | j                  |j
                     t        j                        sP| j                  |j
                     j                  dkD  sw y  g }|j                   D ]2  }t        t        | j                  |      }||j                  |       2 nv t        |D cg c]"  }t        j                  ||j                        $ c}      }t         j#                  |t        j                  t        |      |j                              S t         j#                  t        |j                               S c c}w )Nr:   rs   rN  r  )r  r[   r   r   r   r   r   ri   r   r   r   rR  r   r   r   r  rk  r  )	r   r  r   rS  rM  r   constsr  outs	            rX   _analyze_op_build_tuplez%ArrayAnalysis._analyze_op_build_tupleu  s   
 A1bff%t||AFF3U5J5JKLL(--1  ::Cj$,,4A}a   ?1!TXX.?@C ..HHU6]DHH5 /  
 **tzz1B*CC @s   'E(c           
         ddl m} |j                  }t        | j                  |      }t        |t        j                  t        j                  f      r>t        |j                        r)t        j                  t        |j                              S t        |t        j                  t        j                  f      r_t        |j                  |      rI|j                  }| j                  |||j                  |j                   |t#        |j$                              S t'        | j                  || j(                        \  }	}
d}t        |
t        j*                        rFt        | j(                  |
j,                     t.        j0                        r|
g|j                  z   }d}
d}n|j                  }dj3                  |
|	      j5                  d	d
      }	|	t6        v r| j9                  |||j                   |d       S 	 t;        | |	      }t?        ||||j                   |t#        |j$                              }|r
|dd  |_        |S # t<        $ r Y y w xY w)Nr   )StencilFuncr  rH  FnumpyTz_analyze_op_call_{}_{}.r  )r  r   r  rI   kwsr:   ) numba.stencils.stencilrs  r  r   rR  r[   r   r  FreeVarr   r   rk  r  r   rI   _analyze_stencilr  dictrv  r   r   r   r   r   ri   r   replaceUFUNC_MAP_OPre  r  r  r   )r   r  r   rS  rM  rs  callee
callee_defrI   rT  rU  added_mod_namerO  r  s                 rX   _analyze_op_callzArrayAnalysis._analyze_op_call  s   6#DLL&9
BJJ/
!*"2"23 ..U4995E.FFj299bjj"9:zk@
 99D((  TXX  (LL$
x h'JLL')>)>-
 :		)DH!N99D(//%@HH
 L **5)+/88T4A AT5) #HHNF  H	M! " s   7H? ?	I
Ic                    t        t        |      dk(         |d   }| j                  |j                     }t        t	        |t
        j                               |j                  |      }t        j                  |d   |d         S )Nr:   r   rn  )
r   rx   r   r   r[   r   ri   r  rk  r  )	r   r  r   r  rI   rv  r  r   rs   s	            rX   _analyze_op_call_builtins_lenz+ArrayAnalysis._analyze_op_call_builtins_len  sp    D	Q1gll388$
3 5 567$$S)**quQx*HHrZ   c                 (     |j                   |dd    y Nr:   )r   r   r  r   r  rI   rv  s         rX   :_analyze_op_call_numba_parfors_array_analysis_assert_equivzHArrayAnalysis._analyze_op_call_numba_parfors_array_analysis_assert_equiv  s     		QR)rZ   c                    t        t        |      dk(         |d   j                  }|d   j                  }|j                  |      }|j                  |      }	||	f|j                  v r_|j                  ||	f   }
t        |
|j
                  v        |j
                  |
   }t        |g k7         t        j                  |d   f      S t        j                  t        ||	            S )zX Analyze wrap_index calls added by a previous run of
            Array Analysis
        r   r   r:   r  )	r   rx   r   r   r5  r   rk  r  rf  )r   r  r   r  rI   rv  rh  ri  slice_eqdim_eqwrap_indr  s               rX   8_analyze_op_call_numba_parfors_array_analysis_wrap_indexzFArrayAnalysis._analyze_op_call_numba_parfors_array_analysis_wrap_index  s     	D	Q!W\\
7<<,,Z8**84 f!3!33 ))8V*<=HH	 4 445%%h/BB"H ..beX.>>
 !..#Hf5 /  rZ   c                     d }t        |      dkD  r|d   }n	d|v r|d   }|rt        j                  |      S t        j                  d|      )Nr   rs   r  z'Must specify a shape for array creationr
  )rx   rk  r  r   UnsupportedRewriteError)r   r  r   r  rI   rv  	shape_vars          rX   _analyze_numpy_create_arrayz)ArrayAnalysis._analyze_numpy_create_array  s[    	t9q=QI^GI ..Y.??,,5
 	
rZ   c                 ,    | j                  |||||      S rh   r  r  s         rX   _analyze_op_call_numpy_emptyz*ArrayAnalysis._analyze_op_call_numpy_empty	       //9c4
 	
rZ   c                 ,    | j                  |||||      S rh   r  r  s         rX   7_analyze_op_call_numba_np_unsafe_ndarray_empty_inferredzEArrayAnalysis._analyze_op_call_numba_np_unsafe_ndarray_empty_inferred	  s"     //9c4
 	
rZ   c                 ,    | j                  |||||      S rh   r  r  s         rX   _analyze_op_call_numpy_zerosz*ArrayAnalysis._analyze_op_call_numpy_zeros	  r  rZ   c                 ,    | j                  |||||      S rh   r  r  s         rX   _analyze_op_call_numpy_onesz)ArrayAnalysis._analyze_op_call_numpy_ones	  r  rZ   c                     t        |      dkD  r|d   }n!d|v r|d   }nt        j                  d|      d|v r|d   }n|}t        j	                  ||f      S )Nr   Nz,Expect one argument (or 'N') to eye functionr
  Mr  )rx   r   r  rk  r  )r   r  r   r  rI   rv  r  r  s           rX   _analyze_op_call_numpy_eyez(ArrayAnalysis._analyze_op_call_numpy_eye"	  sn    t9q=QACZCA00>  #:CAA**!Q*88rZ   c                 \    t        |      dkD  sJ |d   }t        j                  ||f      S Nr   r  rx   rk  r  )r   r  r   r  rI   rv  r  s          rX   _analyze_op_call_numpy_identityz-ArrayAnalysis._analyze_op_call_numpy_identity2	  s5     4y1}}G**!Q*88rZ   c                    t        |      dkD  sJ |d   }t        |t        j                        sJ | j                  |j
                     }t        |t        j                        r|j                  dk(  rZd|v r|d   }|j                  |d      sy |j                  |      \  }	}
|j                  |	|
      rt        j                  |	f      S y |j                  dk(  r+|j                  |      \  }	t        j                  |	|	f      S y )Nr   r   r"  r  r:   )rx   r[   r   r   r   r   r   ri   r   r   r  rk  r  )r   r  r   r  rI   rv  rm   atypr"  r   r   s              rX   _analyze_op_call_numpy_diagz)ArrayAnalysis._analyze_op_call_numpy_diag9	  s     4y1}}G!RVV$$$||AFF#dE112yyA~#:CA$--a3#"--a0A%%a+(66aT6BB  a ++A.$22!Q2@@rZ   c                 B   t        |      dkD  sJ |d   }| j                  |j                     }t        |t        j
                        rt        j                  d      S t        |t        j                        r'|j                  |      rt        j                  |      S y )Nr   )r:   r  )
rx   r   r   r[   r   r]   rk  r  ri   r  )r   r  r   rI   rv  r  r   s          rX   _analyze_numpy_array_likez'ArrayAnalysis._analyze_numpy_array_likeN	  s    4y1}}1gll388$c5==) ..T.::U223	8K8K9
 !..S.99rZ   c                 P   t        |      dk(  sJ |d   }| j                  |j                     }t        |t        j
                        sJ |j                  dk(  rM|j                  |      r<|j                  dk(  rt        j                  ||      S t        j                  |      S y )Nr:   r   Crn  r  )rx   r   r   r[   r   ri   r   r  layoutrk  r  )r   r  r   r  rI   rv  r  r   s           rX   _analyze_op_call_numpy_ravelz*ArrayAnalysis._analyze_op_call_numpy_ravelZ	  s    4yA~~1gll388$#u4455588q=Y005zzS  %22#2FF$222==rZ   c                 *    | j                  ||||      S rh   r  r  s         rX   _analyze_op_call_numpy_copyz)ArrayAnalysis._analyze_op_call_numpy_copyj	  s    --eYcJJrZ   c                 *    | j                  ||||      S rh   r  r  s         rX   !_analyze_op_call_numpy_empty_likez/ArrayAnalysis._analyze_op_call_numpy_empty_likem	       --eYcJJrZ   c                 *    | j                  ||||      S rh   r  r  s         rX   !_analyze_op_call_numpy_zeros_likez/ArrayAnalysis._analyze_op_call_numpy_zeros_liker	  r  rZ   c                 *    | j                  ||||      S rh   r  r  s         rX    _analyze_op_call_numpy_ones_likez.ArrayAnalysis._analyze_op_call_numpy_ones_likew	  r  rZ   c                 *    | j                  ||||      S rh   r  r  s         rX    _analyze_op_call_numpy_full_likez.ArrayAnalysis._analyze_op_call_numpy_full_like|	  r  rZ   c                 *    | j                  ||||      S rh   r  r  s         rX   %_analyze_op_call_numpy_asfortranarrayz3ArrayAnalysis._analyze_op_call_numpy_asfortranarray	  r  rZ   c                    t        |      }|dkD  sJ |dk(  rO| j                  |d   j                     }t        |t        j
                        rt        j                  |d         S g }d}	t        dt        |            D ]w  }
||
   }t        t        | j                  |      }t        |t        j                        s>|j                  dk  sN|	dk(  r|
}	Vd}t        j                   ||j"                         |	dk\  r|d   j"                  }t        j$                  |t'        d      |      }t        j(                  | j                  |j                  <   t        j*                  t        j,                  j/                  |d   d	|      ||      }|j1                  |       t        dt        |            D ]  }
|
|	k(  r	t        j$                  |t'        d      |      }t        j(                  | j                  |j                  <   t        j,                  j3                  t4        j6                  |||
   |      }t        j*                  |||      }t9        t        j(                  t        j(                  t        j(                        | j:                  |<   |j1                  |       |} |||	<   t        j                  t=        |dd        |
      S )Nr:   r   r  r   r   z7The reshape API may only include one negative argument.r
  calc_size_varrM   rM  )rx   r   r   r[   r   rj   rk  r  r   r   r   rR  r   r   r   r   r  r  r   r   r^   r  rK  r  r   rJ  rP  floordivr   rm  r   )r   r  r   r  rI   rv  r   r   r  neg_one_index	arg_indexreshape_argreshape_arg_defr   r  init_calc_vardiv_calc_size_var	new_binopdiv_calcs                      rX   _analyze_op_call_numpy_reshapez,ArrayAnalysis._analyze_op_call_numpy_reshape	  sZ   I1uu6,,tAw||,C#u/$22a2AA q#d),Iy/K#NDLL+NO/2884"((1,$*(1 ,$<<[__  - A q'++CFF5-*H#NM/4zzDLL++,IIQ5}cM LL' #1c$i0	-$&FF=93%! 8=zz.334 GGMM%%}d9os	 99Y0A3G,5JJ

EJJ-y) X& 1% 1* #0D**tABxe*LLrZ   c                 &   |d   }| j                   |j                     }t        |t        j                        sJ d       |j                  |      }t        |      dk(  r(t        j                  t        t        |                  S |dd  D 	cg c]  }	t        t        | j                  |	       }
}	t        |
d   t              rt        |
d         }
d |
v ry |
D cg c]  }||   	 }}t        j                  t        |            S c c}	w c c}w )Nr   zInvalid np.transpose argumentr:   r  )r   r   r[   r   ri   r  rx   rk  r  r   reversedr   r   rR  r  )r   r  r   r  rI   rv  in_arrr   rs   rm   axesr   rets                rX   r  z.ArrayAnalysis._analyze_op_call_numpy_transpose	  s    all6;;'&&
 	+*	+ 
 $$V,t9> ..U8E?5K.LL<@HEHqj$,,2HEd1gu%Q=D4<!%&AuQx&**s*<< F
 's   "D	Dc                 ^    t        |      dkD  rt        j                  t        |            S y r  )rx   rk  r  r   r  s         rX   "_analyze_op_call_numpy_random_randz0ArrayAnalysis._analyze_op_call_numpy_random_rand	  s*     t9q= ..U4[.AArZ   c                 ,    | j                  |||||      S rh   )r  r  s         rX   #_analyze_op_call_numpy_random_randnz1ArrayAnalysis._analyze_op_call_numpy_random_randn	  s"     669c4
 	
rZ   c                     d|v rt         j                  |d         S t        |      |kD  rt         j                  ||         S y )NrM   r  )rk  r  rx   )r   posr  r   rI   rv  s         rX   "_analyze_op_numpy_random_with_sizez0ArrayAnalysis._analyze_op_numpy_random_with_size	  sI     S= ..S[.AAt9s? ..T#Y.??rZ   c                 ,    | j                  d||||      S rc   r  r  s         rX   "_analyze_op_call_numpy_random_ranfz0ArrayAnalysis._analyze_op_call_numpy_random_ranf	  "     66uis
 	
rZ   c                 ,    | j                  d||||      S rc   r  r  s         rX   +_analyze_op_call_numpy_random_random_samplez9ArrayAnalysis._analyze_op_call_numpy_random_random_sample
  r  rZ   c                 ,    | j                  d||||      S rc   r  r  s         rX   $_analyze_op_call_numpy_random_samplez2ArrayAnalysis._analyze_op_call_numpy_random_sample
  r  rZ   c                 ,    | j                  d||||      S rc   r  r  s         rX   $_analyze_op_call_numpy_random_randomz2ArrayAnalysis._analyze_op_call_numpy_random_random
  r  rZ   c                 ,    | j                  d||||      S rc   r  r  s         rX   -_analyze_op_call_numpy_random_standard_normalz;ArrayAnalysis._analyze_op_call_numpy_random_standard_normal
  r  rZ   c                 ,    | j                  d||||      S r  r  r  s         rX   '_analyze_op_call_numpy_random_chisquarez5ArrayAnalysis._analyze_op_call_numpy_random_chisquare
  r  rZ   c                 ,    | j                  d||||      S r  r  r  s         rX   %_analyze_op_call_numpy_random_weibullz3ArrayAnalysis._analyze_op_call_numpy_random_weibull$
  r  rZ   c                 ,    | j                  d||||      S r  r  r  s         rX   #_analyze_op_call_numpy_random_powerz1ArrayAnalysis._analyze_op_call_numpy_random_power+
  r  rZ   c                 ,    | j                  d||||      S r  r  r  s         rX   '_analyze_op_call_numpy_random_geometricz5ArrayAnalysis._analyze_op_call_numpy_random_geometric2
  r  rZ   c                 ,    | j                  d||||      S r  r  r  s         rX   )_analyze_op_call_numpy_random_exponentialz7ArrayAnalysis._analyze_op_call_numpy_random_exponential9
  r  rZ   c                 ,    | j                  d||||      S r  r  r  s         rX   %_analyze_op_call_numpy_random_poissonz3ArrayAnalysis._analyze_op_call_numpy_random_poisson@
  r  rZ   c                 ,    | j                  d||||      S r  r  r  s         rX   &_analyze_op_call_numpy_random_rayleighz4ArrayAnalysis._analyze_op_call_numpy_random_rayleighG
  r  rZ   c                 ,    | j                  d||||      S Nr   r  r  s         rX   $_analyze_op_call_numpy_random_normalz2ArrayAnalysis._analyze_op_call_numpy_random_normalN
  r  rZ   c                 ,    | j                  d||||      S r  r  r  s         rX   %_analyze_op_call_numpy_random_uniformz3ArrayAnalysis._analyze_op_call_numpy_random_uniformU
  r  rZ   c                 ,    | j                  d||||      S r  r  r  s         rX   "_analyze_op_call_numpy_random_betaz0ArrayAnalysis._analyze_op_call_numpy_random_beta\
  r  rZ   c                 ,    | j                  d||||      S r  r  r  s         rX   &_analyze_op_call_numpy_random_binomialz4ArrayAnalysis._analyze_op_call_numpy_random_binomialc
  r  rZ   c                 ,    | j                  d||||      S r  r  r  s         rX   _analyze_op_call_numpy_random_fz-ArrayAnalysis._analyze_op_call_numpy_random_fj
  r  rZ   c                 ,    | j                  d||||      S r  r  r  s         rX   #_analyze_op_call_numpy_random_gammaz1ArrayAnalysis._analyze_op_call_numpy_random_gammaq
  r  rZ   c                 ,    | j                  d||||      S r  r  r  s         rX   '_analyze_op_call_numpy_random_lognormalz5ArrayAnalysis._analyze_op_call_numpy_random_lognormalx
  r  rZ   c                 ,    | j                  d||||      S r  r  r  s         rX   %_analyze_op_call_numpy_random_laplacez3ArrayAnalysis._analyze_op_call_numpy_random_laplace
  r  rZ   c                 ,    | j                  d||||      S r  r  r  s         rX   %_analyze_op_call_numpy_random_randintz3ArrayAnalysis._analyze_op_call_numpy_random_randint
  r  rZ   c                 ,    | j                  d||||      S )N   r  r  s         rX   (_analyze_op_call_numpy_random_triangularz6ArrayAnalysis._analyze_op_call_numpy_random_triangular
  r  rZ   c           	      ,   t        |      dkD  sJ |d   j                  }t        | j                  |d         \  }}t        |      }t	        |dkD         d}	d|v r3t        |d   t              r|d   }	nAt        | j                  |d         }	n't        |      dkD  rt        | j                  |d         }	t	        t        |	t                     t	        |dk(         |D 
cg c]  }
|j                  |
       }}
|	dk  rt        |d         |	z   }	t	        d|	cxk  xr t        |d         k  nc        g }g }|dk(  r|d   }|j                  |d         }|j                  d       t        t        |            D ]<  }||	k(  r |j                  ||         }|r|r||z  nd }(| j                  ||d         }> |j                         nt        t        |d               D ]v  }||	k(  r$| j                  ||D cg c]  }||   	 c}      }n:|D cg c]  }||   	 }}|j                  | j                  ||||             |d   }|j                  |       x t        j!                  t#        |      t%        |g             S c c}
w c c}w c c}w Nr   axisr:   rE  rM  )rx   r  r   rR  r   r[   r   r   r  r   popr   	_sum_sizer   _call_assert_equivrk  r  r   r  )r   r  r   r  rI   rv  rS  rL  r   r  r   r  r  	new_shapers   r   r   rM   sizess                      rX   "_analyze_op_call_numpy_concatenatez0ArrayAnalysis._analyze_op_call_numpy_concatenate
  s~    4y1}}1gkk%dllDG<RHAS=#f+s+6{!$,,F<Y]dllDG4D
4%&m#$3673a)&&q)37!8vay>D(DT*Cq	N*+	61IE))&)4AIIaL3u:&9!11%(;A%&11q54D>>)VAY?D ' T"3vay>*9>>!&#A&E!H&#AD 4::6%U1X6E:NN//sIuM !8D  & + **	"GR  + 
 	
? 8, $B ;s    J<JJc                 "   t        |      dkD  sJ |d   j                  }t        | j                  |d         \  }}t        |      }t	        |dkD         d}	d|v r3t        |d   t              r|d   }	nAt        | j                  |d         }	n't        |      dkD  rt        | j                  |d         }	t	        t        |	t                     t	        |dk(         |D 
cg c]  }
|j                  |
       }}
| j                  ||||      }|d   }|	dk  rt        |      |	z   dz   }	t	        d|	cxk  xr t        |      k  nc        t        |d|	       |gz   t        ||	d        z   }t        j                  t        |      |      S c c}
w r  )rx   r  r   rR  r   r[   r   r   r  r  r  rk  r  r   )r   r  r   r  rI   rv  rS  rL  r   r  r   r  r  rs   r  s                  rX   _analyze_op_call_numpy_stackz*ArrayAnalysis._analyze_op_call_numpy_stack
  sr   4y1}}1gkk%dllDG<RHAS=#f+s+6{!$,,F<Y]dllDG4D
4%&m#$3673a)&&q)37))%iEq	!8u:$q(DT'SZ'(q'1#-U45\0BB	**y1Aw*OO 8s    Fc                    t        |      dk(  sJ t        | j                  |d         \  }}t        |      }t        |dkD         | j                  |d   j
                     }	t        t        |	t        j                               |	j                  dk  r| j                  |||||      S d|d<   | j                  |||||      S Nr:   r   r   r  )rx   r   rR  r   r   r   r[   r   ri   r   r  r	  
r   r  r   r  rI   rv  rS  rL  r   r   s
             rX   _analyze_op_call_numpy_vstackz+ArrayAnalysis._analyze_op_call_numpy_vstack
  s    4yA~~%dllDG<RHAll3q6;;'
3 5 56788a<44y#tS  CK::y#tS rZ   c                 h   t        |      dk(  sJ t        | j                  |d         \  }}t        |      }t        |dkD         | j                  |d   j
                     }	t        t        |	t        j                               |	j                  dk  rd|d<   nd|d<   | j                  |||||      S r  )rx   r   rR  r   r   r   r[   r   ri   r   r	  r  s
             rX   _analyze_op_call_numpy_hstackz+ArrayAnalysis._analyze_op_call_numpy_hstack
  s    4yA~~%dllDG<RHAll3q6;;'
3 5 56788a<CKCK669c4
 	
rZ   c                 `   t        |      dk(  sJ t        | j                  |d         \  }}t        |      }t        |dkD         | j                  |d   j
                     }	t        t        |	t        j                               |	j                  dk(  rYd|d<   | j                  |||||      }
t        |
       t        dgt        |
j                  d         z         |
j                  d<   |
S |	j                  dk(  rd|d<   | j                  |||||      S d|d<   | j                  |||||      S )Nr:   r   r  rs   r   )rx   r   rR  r   r   r   r[   r   ri   r   r  r   r  r  r	  )r   r  r   r  rI   rv  rS  rL  r   r   r  s              rX   _analyze_op_call_numpy_dstackz+ArrayAnalysis._analyze_op_call_numpy_dstack  s)   4yA~~%dllDG<RHAll3q6;;'
3 5 56788q=CK66y#tSF FO%*A3fmmG6L1M+M%NFMM'"MXX]CK44y#tS  CK::y#tS rZ   c                      y rh   rd   r  s         rX   _analyze_op_call_numpy_cumsumz+ArrayAnalysis._analyze_op_call_numpy_cumsum      rZ   c                      y rh   rd   r  s         rX   _analyze_op_call_numpy_cumprodz,ArrayAnalysis._analyze_op_call_numpy_cumprod"  r  rZ   c                 r    t        |      }d}|dkD  r|d   }n	d|v r|d   }t        j                  |f      S )N2   r   numr  r  )r   r  r   r  rI   rv  r   r  s           rX   _analyze_op_call_numpy_linspacez-ArrayAnalysis._analyze_op_call_numpy_linspace&  sH     Iq5q'Cc\e*C**#*88rZ   c           
         t        |      }|dk\  sJ |d   j                  }t        t        |D cg c]  }| j	                  |j
                         c}             |D cg c]  }| j                  |j
                      }}|D 	cg c]  }	|	j                   }
}	t        t        d |
D                     |
d   dk(  r	|
d   dk(  ry |D cg c]  }|j                  |       }}|
d   dk(  rQ| j                  ||||d   d   |d   d   g      }t        j                  t        |d   dd |d   dd  z         |      S |
d   dk(  rH| j                  ||||d   d   |d   d   g      }t        j                  t        |d   dd       |      S |
d   dk(  rO|
d   dk(  rG| j                  ||||d   d   |d   d   g      }t        j                  |d   d   |d   d   f|      S |
d   dkD  r	 y c c}w c c}w c c}	w c c}w )Nr   r   c              3   &   K   | ]	  }|d kD    yw)r   Nrd   rK  s     rX   rn   z;ArrayAnalysis._analyze_op_call_numpy_dot.<locals>.<genexpr>8  s     (4aAE4s   r:   r   rM  )rx   r  r   r   r  r   r   r   r  r  rk  r  r   )r   r  r   r  rI   rv  r   r   typstydimsr  r  s                rX   _analyze_op_call_numpy_dotz(ArrayAnalysis._analyze_op_call_numpy_dot1  sN   IAvv1gkkD9DqT]]166*D9:;.23dQVV$d3"&'$B$'(4(()7a<DGqL3784a)&&q)487a<--sIq	!fQim'DG !..F1IaOfQin<= /   7a<--sIq	"vay|'DG !..F1IaO, /   7a<DGqL--sIq	!fQil'CG !..ay|VAYq\2 /   7Q;C :3' 9s   "G0! G5G:G?c                 J   |j                   j                  dd      }|j                  j                  }t	        |t
              r|f}g }	t        |      dkD  rt        |      t        |      k(  sJ t        ||      D ]O  \  }
}| j                  |j                     }t	        |t        j                        s:|
|vs?|	j                  |       Q t        |	      }t        |dkD         | j                  ||||	      }|j                  |	d         }t         j#                  ||      S )Nstandard_indexingrd   r   rM  )optionsr   	kernel_irr  r[   r   rx   ry   r   r   r   ri   r   r   r  r  rk  r  )r   r  r   stencil_funcr  rI   rv  std_idx_arrskernel_arg_namesrel_idx_arrsr  r  r   r   r  rs   s                   rX   ry  zArrayAnalysis._analyze_stencilX  s    $++//0CRH'11;;lC((?L4y1}Tc2B.C!CCC,d3HC,,sxx(C#u445|###C( 4 A))%iN##LO4**G*DDrZ   c                     t        t        |      dk\         t        j                  |j	                  |d               S )Nr:   r   r  )r   rx   rk  r  r  r  s         rX   !_analyze_op_call_numpy_linalg_invz/ArrayAnalysis._analyze_op_call_numpy_linalg_invm  s7     	D	Q**1E1Ed1g1N*OOrZ   c           
          t        t         fd|            }t        |      dk(  r|j                  dk(  r j                  |d   j
                     } j                  |d   j
                     }|j                  dk(  r(t        j                  |j                  |d               S |j                  dk(  r(t        j                  |j                  |d               S 	 |D 	cg c]  }	|j                  |	       }
}	d|
v ryt        |
d      }t        j                  |      S t        t         fd	|            }t        t        |      dkD         |D 	cg c]  }	|	j
                   }}	|D 	cg c]%  }	 j                  |	j
                     j                  ' }}	t        |      }t        |dkD         	 |D 	cg c]  }	|j                  |	       }
}	g }d|
v ryg }t!        |
      D ]g  \  }}|O||   } j                  |j
                     } j#                  |||j                  d|      }|j%                  |       W|j%                  |       i |}
 j'                  ||||
|      }|r2d|j(                  v r|j(                  d   }ng }||z   |j(                  d<   |S c c}	w # t        $ r Y yw xY wc c}	w c c}	w c c}	w # t        $ r/ t        j                  |d    j                  ||||      
      cY S w xY w)zInfer shape equivalence of arguments based on Numpy broadcast rules
        and return shape of output
        https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html
        c                 :    j                  | j                        S rh   )_istupler   rm   r   s    rX   r  z2ArrayAnalysis._analyze_broadcast.<locals>.<lambda>x      T]]166%:rZ   r   rE   r   r:   r  Nrd   c                 :    j                  | j                        S rh   )r  r   r1  s    rX   r  z2ArrayAnalysis._analyze_broadcast.<locals>.<lambda>  r2  rZ   rM  r  )r  r  rx   r   r   r   r  rk  r  r  r  r   r   r   r   r  	enumerater  r   r  r  )r   r  r   r  rI   rO  tupstup0typtup1typr   r  concat_shapesarrsr   r"  max_dimr  
new_shapesr   sr  r   rs   r  prev_pres   `                        rX   re  z ArrayAnalysis._analyze_broadcasts  s   
 F:DABt9>bkkU2 ll47<<0Gll47<<0G}}!$22#--d1g6 3   }}!$22#--d1g6 3  	:>?$Q)--a0$?6> #FB$22' 3   F:DABD	A!%&A&3784aQVV$))48d)!	6:;di))!,dF; 6> J!&)19q'C,,sxx0C 00!3$E %%e,%%a( *  F..9c65
  %!==/#&>FMM% i @ "  '8 < 	 ..1g++E3	4H /  	sZ   J" "J:J" !J" J1/*J65K  9J;K  J" "	J.-J.;K   5K87K8c           
         g }g }t        |D cg c]  }t        |       c}      }	d}
t        |	      D ]  }g }g }t        ||      D ]c  \  }}|t        |      k  s|t        |      dz
  |z
     }|j	                  |      }|dk(  r|}
B|j                  |       |j                  |       e |g k(  r&|
J |j                  |
       |j                  d       |j                  | j                  |||||             |j                  |d           t        j                  t        t        |            t        |g             S c c}w )zProduce assert_equiv for sizes in each dimension, taking into
        account of dimension coercion and constant size of 1.
        Nr:   1r   r   rM  )r   rx   r   ry   r   r   r  rk  r  r   r  r  )r   r  r   r  r  r   r  r  rs   r:  const_size_oner   r  
size_namesr   rM   
const_sizes                    rX   r  z&ArrayAnalysis._broadcast_assert_shapes  sX    	v6ves5zv67wAEJ"5&1es5z> Ua!!34D!*!:!:4!@J!Q)-T*"))$/  2 {%111^,!!#&NN''3	5
 ( 
 U1X&+  , **+,GR  + 
 	
1 7s   Ec                 l    | j                  |||||      }t        |      dkD  r |j                  |  |S )Nr@  r:   )r  rx   r   )r   r  r  r   rI   r   instss          rX   r  z ArrayAnalysis._call_assert_equiv  sD    ''3	4u ( 
 t9q="I""D)rZ   c           
      h   t         j                  dk\  rt        d||       ||D cg c]  }|j                   }}g }g }t	        ||      D ]  \  }	}t         j                  dk\  rt        d|	|       d}
|D ]H  }t         j                  dk\  rt        d||j                  ||             |j                  ||      sFd}
 n |
rx|j                  |       |j                  |	        t        |      dk  r t         j                  dk\  rt        d       g S dj                  d	j                  |      |      }t        j                  ||      }t        j                  |      }t        j                  |t        d
      |      }|| j                   |j                  <   t#        |g|D cg c]  }| j                   |j                      c}z         }t        j$                  j'                  |      }t        j                  |t        d      |      }t        j(                  dt*        |      }t-        t*              }| j.                  j1                  ||fi       }| j3                  ||||       t        j                  |t        d      |      }t        j4                  j7                  ||g|z   i |      }| j3                  ||t        j8                  |       || j:                  |<   t        j<                  |||      t        j<                  |||      t        j<                  |||      gS c c}w c c}w )Nr   zmake_assert_equiv:zname, x:Fzis equiv to?Tz@Will not insert assert_equiv as args are known to be equivalent.zSizes of {} do not match on {}z, r   assertr   r
  r  r  )r   r   r   r   ry   r   r   rx   r   joinr   r   r   r   r   r   r   r   r   
from_typesr  r   r   rF   r+  r  rK  rG  r   rm  r  )r   r  r  r   _argsr   r   rI   r  r   seenr?  r   msg_valmsg_typmsg_varargtypstup_typ
assert_var
assert_defr8  rH   r  r   s                           rX   r  z ArrayAnalysis._make_assert_equiv  s   !!Q&&u5=%*+UQVVUE+	5%(GD!%%*j$*D))Q..!Y-?-?1-EF%%a+D  A  & ) t9q=%%*" I.55IIi #
 ((3$%%c*&&e 4c:%,W\\"	4$H4aT\\!&&%94$HHI $$//8 VVE=#:C@
YY~|E
"<0ll00z2FY
D*= ffUM%0#6Z'T)923GYUZZ7 #u IIGG=IIJzsCIIE#37
 	
g ,B %Is   L*& L/
c           
         t        |t        j                        r|j                  |      }t        |t        j                        r|}d }d }nt        |t        j                        r|}d }d }nt        j
                  j                  |d|j                        }t        j                  |j                  t        dj                  |j                              |j                        }t        j                  j                  t        j                  |      }g }	d}
|rt!        |      }||k  r|||z
  d  }t#        |      D ]d  }d}|rl||   rft        ||   t        j                        rO| j$                  ||   j                     }t        |t        j&                  t        j(                  f      r||   }d}nt        ||   t*              r$t        j,                  ||   |j                        }n||   }t        |t        j,                        sJ t        j                  |j                  t        dj                  |j                  |            |j                        }|j/                  t        j0                  |||j                               | j3                  ||t        j                  |       d}|st        j                  |j                  t        dj                  |j                  |            |j                        }t        j
                  j5                  ||d |j                        }d}
d | j6                  |<   |j/                  t        j0                  |||j                               | j3                  ||t        j                  |       |	j/                         g |
rG|rE|j9                  dt        j0                  |||j                               | j3                  |||       t;        |	      S )Nrs   z{}_shapeFTz	{}_size{}r   )r[   r   r   r  r  rK  r  r  r  r   r   r   r   r  r  r^   rx   r   r   rW  rk   r   r   r   r  r  static_getitemrm  r  r   )r   r   r  r   rs   r  attr_varshape_attr_callshape_attr_typ	size_varsuse_attr_varnshapesr   skipr   r5  r6  getitems                     rX   r  zArrayAnalysis._gen_shape_call(  s   eRVV$''.E eRVV$H"OErvv&H"OE ggooc7CGGDOvv		=):):388)DEswwH #--66uzz5IN	%jGww12uADqeAh/,,uQx}}5C!#eoo'FG#(8#!%(C0#%88E!Hcgg#>#(8%h999!vv		%k&8&81&EF H
 KK		(Hcgg FGLLHejj(KD66II!+"4"4SXXq"ABGG
 ''001dCGGL#*.w'BIIgxABY%**gFX&E F OKK299_hHILLHnoNYrZ   c                     | j                   |   }t        |t        j                  j                        xr |j
                  dkD  S rc   )r   r[   r   npytypesArrayr   r   varnamer   s      rX   r  zArrayAnalysis._isarrayl  s4    ll7##u~~334EAErZ   c                 T    | j                   |   }t        |t        j                        S rh   )r   r[   r   rj   r`  s      rX   r0  zArrayAnalysis._istuplep  s!    ll7##u//rZ   c                 L    d}|D ]  }|j                  |      }| y||z  } |S )zzReturn the sum of the given list of sizes if they are all equivalent
        to some constant, or None otherwise.
        r   N)r   )r   r   r  r<  rM   r   s         rX   r  zArrayAnalysis._sum_sizet  s;     D))$/AyQ  rZ   rd  )static_literal_slice_partrh   )cr   r   r   r  r   r   rz  r  r  r  r  r  r  objectr  r  r  r  r  r  r   r  r  r  rh  r  r]  r_  rb  rf  ri  rl  rq  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r   r	  r  r  r  r  r  r  r  r#  ry  r-  re  r  r  r  r  r  r0  r  rd   rZ   rX   rk  rk  4  s   H&",

%0:d	BB"H3
=! !HT6@=  )L:2>[
zG9RXEt$



D:=~I>







9 9*
 KK
K
K
K
K
HMT=&






















4
lP4"
4	9%NE*PJX!
F<
|B HF0rZ   rk  )Brt  rP  
numba.corer   r   r   r   r   numba.core.ir_utilsr   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   numba.core.analysisr   numba.core.typingr   r   r   numba.core.extendingr   rA   UNKNOWN_CLASSCONST_CLASSufunc	MAP_TYPESr  array_creationrandom_int_argsrandom_1arg_sizerandom_2arg_sizelastrandom_3arg_sizelastrandom_callsra   re   r   re  r   r   r/  rf  rk  r  NumpyRulesUnaryArrayOperator_op_mapkeysr  ra  NumpyRulesArrayOperatorrd  NumpyRulesInplaceArrayOperatorrh  supported_ufuncsr   r|  )r2   s   0rX   <module>r{     s     9 9    " 8 0  * [[M	  47#  	    ,	   ,5 ,5^
 =0 =0@Vv Vrz*H z*zkE} kE\	!F !BK!F K!\B G88@@EEGHLLL  //77<<>>>FFKKM $+$<$<=$<q

$<==s   $E;