
    J/Ph7             
       .   d Z ddlZddlZddlZddlZddlmZ ddlmZ ddl	Z
ddlmZmZ ddlmZ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 ddl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. dd
l/m0Z0 ddl1m2Z2 ddl3m4Z4m5Z5m6Z6m7Z7m8Z8 ddl9m:Z:m;Z; ddl<m=Z= ddl>m?Z?m@Z@ ddl3mAZA ddlBmCZDmEZFmGZGmHZHmIZI d ZJd ZKd ZLd ZMd ZNd ZOd ZPd ZQd ZR	 dRdZSd ZTd ZU e5eU          d             ZV e$dejW                  d              ZXd! ZY e$d"ejZ                   e*e.j[                  d#                         Z\	 dRd$Z]d% Z^d& Z_ e$ej`        ejW        eja                   e$ej`        ejW        ejb                  d'                         Zc e$ej`        ejW        ejd                  d(             Ze e$ejf        ejW        ejg        ejg                  d)             Zh e$eiejW                  d*             Zj e$d+ejk                  d,             Zle"d-k     r  e$d.ejk        ejg                  d/             Zm G d0 d1en          Zo G d2 d3eo          Zp G d4 d5eo          Zq G d6 d7eo          Zr G d8 d9eo          Zs G d: d;eo          Zt G d< d=en          Zud> Zv e$ej`        ejW        ejk                  d?             Zwd@ ZxdA ZydB ZzdC Z{dD Z|dE Z}dF Z~dG Ze7dH             Ze7dI             Ze4dJ             ZdK Z e5e
j                  dL             Ze4dM             Z e5e
j                  dN             Z e5e
j                  dO             ZdP ZdQ Z e$dRejk                  dS             ZdT Z e$dRejk        ejd                  dU             Z e$dRejk         ej        ejg                            dV             Z e5e
j                  dRdW            Z e%ejk        dX          dY             Z e5e
j                  dSd[            Z e5e
j                  dSd\            Z e5e
j                  dTd^            Zd_ Zd` Z e$daejk        ejd                  db             Z e$daejk         ej        ejg                            dc             Ze"ddk     r e5e
j                  de             Zn e5e
j                  df             Z e5e
j                  dg             Z e5e
j                  dRdh            Z e$diejk                  dj             Z e$e
j        ejk                  dk             Z e$dlejk                  dm             Ze4dn             Ze4do             Z e5e
j                  dRdp            Z e6ejk        dq          dUdr            Zds Z e5e
j                  dt             Z e5e
j                  du             Z e5e
j                  dv             Z e5e
j                  dw             Ze4dx             Z ej6        ejk        dy          dz             Ze7d{             Zd| Z e5ed}~          d             Z e$dejk        ej                  d             Z e%ejk        d          d             Z e%ejk        d           e%ej        d          d                         Z e%ejk        d           e%ej        d          d                         Z e%ejk        d           e%ej        d          d                         Z e%ejk        d          d             Z e%ejk        d           e%ej        d          d                         Z e%ejk        d           e%ej        d          d                         Z e%ej        d          d             Z e%ej        d          d             Z e%ej        d          d             Z e%ej        d          d             Z e%ejk        d          d             Z e%ej        d          d             Z e(ej        ej                   e(ej        ej                  d                         Zd Z e%ejk        d          d             Z e%ej        d           e%ej        d          d                         Z e%ej        d          d             Z e%ejk        d          d             Z e%ejk        d          d             Zd Z e6ejk        d           e6ejk        d          d                         Zd Z  e%ej        d          e٦             e%ej        d          e٦            e$dej        ejg                  d             Z e&ejk                  d             Z e$dejk        ej2                  d             Z e&ej                  d             Z e'ej                  d             Z e$dej        ej2                  d             Z e$dej        ej                  d             Z e$dej        ej2        ejg                  d             Z e$dej        ej        ejg                  d             Z e)ejk                  d             Z e)ej                  d             Z e)ej                  d             Z e$ej        ejk        ejk                  d             Z e8ejk        d          d             Zd Zd Z	 	 dUdZ	 dRdZd ZdÄ ZdĄ Z e%ejk        dŦ          dƄ             Z e$d"ej                   e*e.j[                  dǄ                         Z e$ej`        ej        eja                  dȄ             Z e$ejf        ej        eja        ejg                  dɄ             Z e$eiej                  dʄ             Z e$e
j        ejk                  d˄             Z e$d"ej                   e*e.j[                  d̄                         Z e$e ej        eja                             e$e
j         ej        eja                            d̈́                         Z  e$eejd                   e$e
j        ejd                  d΄                         Z e$d"ej                   e*e.j[                  dτ                         Z e$e
j        ejg                  dЄ             Z e$d"ej                   e*e.j[                  dф                         Z e$ej        ej        ej                  d҄             Z	dӄ Z
 eAejk        dԦ          dՄ             Zdք Ze7dׄ             Zd؄ Zdل Zdڄ Zdۄ Ze7d܄             Z e5e
j                  efd݄            Ze7dބ             Z e5e
j                  dRd߄            Ze7d             Z e6ejk        d          d             Z e5e
j                  efd            Z e5e
j                  dRd            Z e5e
j                  dRd            Z  e5e
j!                  dRd            Z" e5e
j#                  dRd            Z$ e5e
j%                  dRd            Z& e5e
j'                  dRd            Z(d Z) ej5        e)          d             Z* ej5        e
j+                  ddefd            Z, e5e
j-                  dVd            Z. e5e
j/                  d             Z0 e5e
j1                  dVd            Z2d Z3 e5e
j4                   e6ejk        d          dRd                        Z5d Z6 e5e
j7                  dUd            Z8 e5e
j9                  dSd            Z:d Z;e7d             Z< e$dejk                  d             Z= e5e
j>                  d             Z?d Z@e7d             ZA e5e
jB                  d             ZC e5e
jD                  d             ZE e$dejk        ej                   e$dejk        ej2                  d                          ZFe7d             ZG e5e
jH                  efd            ZI e5e          dRd            ZJ e5e          dRd            ZKd ZLd ZMd ZNd ZOd	 ZPd
 ZQd ZRd ZSe7d             ZT e5e
jU                  dRd            ZVd ZWd ZXd ZYd ZZe7d             Z[ e5e
jZ                  d             Z\d Z]d Z^ e5e
j_                  d             Z` e5e
ja                  d             Zb e5e
jc                  d             Zdd Zed Zfd Zgd Zhe7d             Zi e5e
jj                  dVd            Zkd  Zle7d!             Zm e5e
jn                  d"             Zod# Zpe7d$             Zq e5e
jr                  dVd%            Zsd& Zte7d'             Zu e5e
jv                  d(             Zwe7d)             Zx e5e
jy                  d*             Zze"d-k    r  e5e
j{                  ez           e7d+             Z| e5e
j}                  d,             Z~ ej6        ejk        d-          d.             Z ej6        ejk        d/          d0             Z e5e
j                  d1             Z e5e
j                  d2             Ze7d3             Z e5e
j                  d4             Z e5e
j                  dVd5            Z e5e
j                  dVd6            Z e5e
j                  d7             Z e5e
j                  d8             Z e5e
j                  d9             Zi Zd: ZdWd<Zd= Z e$d>ejk                  d?             Z e5e
j                  d@             Z e$dAejk        ej2                   e$e
j        ejk        ej2                  dB                         Z e(ejk        ejk                  dC             Z e(ejk        ej                   e(ejk        ej                   e(ejk        eja                   e(ejk        ej                   e(ejk        ej                   e(ejk        ej                   e(ejk        ej                  dD                                                                                     Z e(ejk        ej                  dE             ZdF Z ej        e          dG             Z e$eejk        ejd        ejd                  dH             Z ej5        e
j        j        j                  dXdI            Z ej5        e
j        j        j                  dRdJ            Z e5e          dK             Z e5e
j                  dL             Ze4dM             Z e5e
j                  dN             Z e5e
j                  dYdQ            ZdS (Z  z[
Implementation of operations on Array objects and objects supporting
the buffer protocol.
    N)ir)Constant)pndindexliteral_unroll)typestypingerrorscgutils	extendingconfig)
as_dtype
from_dtypecarrayfarrayis_contiguous
is_fortrancheck_is_integertype_is_scalar
lt_complex	lt_floats)type_can_asarrayis_nonelikenumpy_version)lower_builtinlower_getattrlower_getattr_genericlower_setattr_generic
lower_castlower_constantiternext_implimpl_ret_borrowedimpl_ret_new_refimpl_ret_untrackedRefType)	signature)StringLiteral)register_jitableoverloadoverload_method	intrinsicoverload_attribute)	quicksort	mergesort)slicing)tuple_setitembuild_full_slice_tuple)overload_classmethod)parse_dtypeparse_shape_parse_nested_sequence_sequence_of_arrays_choose_concatenation_layoutc                     t          |j        |          t          |j        |          g}| j                            |          }|                    d|           dS )zz
    Set the "range" metadata on a load instruction.
    Note the interval is in the form [lower_bound, upper_bound).
    rangeN)r   typemoduleadd_metadataset_metadata)builderloadlower_boundupper_boundrange_operandsmds         Q/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/numba/np/arrayobj.pyset_range_metadatarD   -   sZ    
 ty+66ty+668N		$	$^	4	4Bgr"""""    c                 T    d|j         j        dz
  z  dz
  }t          | |d|           dS )zF
    Mark the result of a load instruction as positive (or zero).
       r   N)r9   widthrD   )r=   r>   r@   s      rC   mark_positiverI   8   s6     1,-2Kwa55555rE   c                 |      j         t          j                  j         G  fdd          S )z
    Return the Structure representation of the given *array_type*
    (an instance of types.ArrayCompatible).

    Note this does not call __array_wrap__ in case a new array structure
    is being created (rather than populated).
    c                   B     e Zd Z fdZefd            Z xZS )make_array.<locals>.ArrayStructc                    t          
	          }	 | j                            d|          }n3# t          $ r& t	          |                               |          cY S w xY w| j        j        	         }|                     |          }|t          j	        | j
        |d          }n|} || j
        |f          }||fS )N	__array__T)zfill)r%   _contextget_functionNotImplementedErrorsuper
_make_refsdata_model_manager_get_be_typer
   alloca_once_builder)selfrefsig
array_impl	datamodelbe_type	outer_refArrayStruct	__class__
array_typereal_array_types          rC   rT   z*make_array.<locals>.ArrayStruct._make_refsN   s    OZ88C@!]77SII

& @ @ @[$//::3?????@ 8DI''	22G{#/w6:< < <		  	 *T]YL99Cc>!s   / -AAc                 h   | j         }dk    r                    | d          S |                     d          }g }t                    D ]S}t	          j        ||d|          }|                    |          }|                    |           t          ||           Tt	          j	        ||          S )z\
            Override .shape to inform LLVM that its elements are all positive.
            r   shape)
rX   __getattr___get_ptr_by_namer8   r
   gep_inboundsr>   appendrI   
pack_array)	rY   r=   ptrdimsidimptrr>   basendims	          rC   re   z%make_array.<locals>.ArrayStruct.shapeb   s    
 mGqyy''g666 ''00CD4[[ - - -gsAqAA||F++D!!!gt,,,,%gt444rE   )__name__
__module____qualname__rT   propertyre   __classcell__)ra   r`   rb   ro   rp   rc   s   @rC   r`   rL   L   sr        	" 	" 	" 	" 	" 	" 	" 	"( 
	5 	5 	5 	5 	5 
	5 	5 	5 	5 	5rE   r`   )as_arrayr
   create_struct_proxyrp   )rb   r`   ro   rp   rc   s   `@@@@rC   
make_arrayrx   @   sz     !)O&77DD+5 +5 +5 +5 +5 +5 +5 +5 +5 +5 +5d +5 +5 +5Z rE   c                 `    |                      |j                  }|                     |          S )zB
    Return the item size for the given array or buffer type.
    )get_data_typedtypeget_abi_sizeof)contextrb   lltys      rC   get_itemsizer   |   s.       !122D!!$'''rE   c                 T    |j         rdnd}|                     ||j        ||          S )z3
    Load the item at the given array pointer.
    NrG   align)alignedunpack_valuer{   )r}   r=   arraytyrk   r   s        rC   	load_itemr      s<     O*DDE&+   - - -rE   c                 V    |j         rdnd}|                     ||j        |||          S )z4
    Store the item at the given array pointer.
    NrG   r   )r   
pack_valuer{   )r}   r=   r   valrk   r   s         rC   
store_itemr      s5     O*DDEgw}c3eLLLrE   c                     |j         r9|                     |||t          j                  }t	          j        |||          }n"|                     |||t          j                  }|S )zM
    Fix the integer index' type and value for the given dimension size.
    )signedcastr   intpr.   	fix_indexuintp)r}   r=   idxtyidxsizeinds         rC   fix_integer_indexr      s[     | =ll7C
;;d33ll7C<<JrE   c                 
   t          |t          j                  rf|j        dk    r[t          |j        t          j                  sJ  t          |          | ||          }t          | |||j                  }|j        |fS ||fS )zS
    Normalize the index type and value.  0-d arrays are converted to scalars.
    r   )	
isinstancer   Arrayrp   r{   Integerrx   r   data)r}   r=   r   r   idxaryidxvals         rC   normalize_indexr      s     %%% %*//%+u}55555"E""7GS997GUFK@@{F""czrE   c                 z     t          |          r't           fdt          ||          D              \  }}||fS )z^
    Same as normalize_index(), but operating on sequences of
    index types and values.
    c                 :    g | ]\  }}t          ||          S  )r   ).0r   r   r=   r}   s      rC   
<listcomp>z%normalize_indices.<locals>.<listcomp>   s@     %' %' %')3 &5Wgu58&: &: %' %' %'rE   )lenzip)r}   r=   index_typesindicess   ``  rC   normalize_indicesr      se    
 7|| (" %' %' %' %' %'7:;7P7P%' %' %'  (W rE   c                 t   | j         }| j        }| j        }	t          j        t          j        dd          }
|j        |
         }t          |j                  }t          |	j                  }||z  |k    r:||z
  }d| j	         dt          |          dk    rdnd d| d}t          |          |6t          |                    |	                    d
                    d	          }|                    t          j                  }t!          |t"          t$          f          rt'          j        |||          }t!          |t"          t$          f          rt'          j        |||          }t!          |t*                    r ||          }t-          |||||          }|:t          |                    |	                    d                    d	          |d<   n||d<   |                    t          j        d          }t'          j        |||j        j                  }|D ]}|                    ||dg          }||d<   t          |                                          }||k    r%t          d                    ||z
                      |                                D ]\  }}t?          | ||           | S )z
    Helper function for populating array structures.
    This avoids forgetting to set fields.

    *shape* and *strides* can be Python tuples or LLVM arrays.
    rG   CzThe datamodel for type z is missing fields  .Nmeminfo)re   stridesr   itemsizer   parentnswflagsnitemszmissing {0}) rP   rX   
_datamodelr   r   float64rU   set_fields_fe_typer   
ValueErrorr   get_value_typeget_typer   r   tuplelistr
   rj   intdictget_constantunpack_tupler9   countmulkeysformatitemssetattr)arrayr   re   r   r   r   r   r}   r=   r]   standard_arraystandard_array_type_datamodelrequired_fieldsdatamodel_fieldsmissingmsgintp_tattrsr   unpacked_shapeaxlen
got_fieldskvs                           rC   populate_arrayr      s    nGnG I [377N$+$>~$N!7?@@O9,-- 	**>>!$44D D D!'llQ..ssBD D9@D D Doo711y))+ +,02 2 ##EJ//F%%'' ;"7E6::'E4=)) ?$Wgv>>(C   $6(##u " 	# # #E ~"7#9#9x(($* $*+/1 1h !h!!%*a00F)'5%*:JKKN ; ;VU5'::E(O UZZ\\""J_$$--o
.JKKLLL   1q!LrE   c                 R   |j         }|j        }|                    t          j        d          }t          j        ||j        | j                  }|D ]}|	                    ||dg          }||_
        |                    t          j        t          ||                     |_        dS )z
    Update some auxiliary information in *array* after some of its fields
    were changed.  `itemsize` and `nitems` are updated.
    rG   r   r   N)rP   rX   r   r   r   r
   r   re   rp   r   r   r   r   )arytyr   r}   r=   r   r   r   s          rC   update_array_infor      s    
 nGnG !!%*a00F)'5;
KKN ; ;VU5'::EL))%**6w*F*FH HENNNrE   c                     t                      )z/Constrain axis values to valid positive values.rR   )	func_namearg_namerp   axiss       rC   normalize_axisr     s    


rE   c                     t          | t                    st          j        d          t          |t                    st          j        d          | j         d|j         dfd}|S )Nz func_name must be a str literal.zarg_name must be a str literal.z: Argument z* out of bounds for dimensions of the arrayc                 T    |dk     r||z  }|dk     s||k    rt                    |S Nr   r   )r   r   rp   r   r   s       rC   implz&normalize_axis_overloads.<locals>.impl$  s7    !88DLD!88tt||S//!rE   )r   r&   r	   TypingErrorliteral_value)r   r   rp   r   r   r   s        @rC   normalize_axis_overloadsr     s    i// E !CDDDh.. D !BCCC " 	4 	4x/E 	4 	4 	4 
     KrE   getiterc                 x   |j         \  }|\  }|                     ||j                  }|                     t          j        d          }t          j        ||          }||_        ||_	        | j
        r| j                            |||           |                                }	t          | ||j        |	          }
|
S r   )argsmake_helperreturn_typer   r   r   r
   alloca_once_valueindexr   
enable_nrtnrtincref	_getvaluer"   )r}   r=   r[   r   r   r   iterobjzeroindexptrresouts              rC   getiter_arrayr   /  s    IWGU!!'3?;;G
A..D($77HGMGM  47GU333




C 7GS_c
B
BCJrE   c           
         t          j        ||j        |j                  }t          j        ||j        |j                  }|                    |d         |          }t          j        ||j        |          }	|dd         }
|dd         }t          |t          j
                  r*t          | |||||	|
|          }|                                S |
rJ t          | |||	          S )z1 Evaluate `ary[idx]`, where idx is a single int. r   r   rG   N)r
   r   re   rp   r   r   pointer_addr   r   r   Buffer	make_viewr   r   )r}   r=   r   r   aryr   shapesr   offsetdataptrview_shapesview_stridesretarys                rC   _getitem_array_single_intr  G  s     !'39EJGGGF"7CKuzJJJG[[S))F!'38V<<G*K122;L+u|,, ;7GUC"K? ?!!! '5':::rE   iternextc           	      ~   |j         \  }|\  }|j        }|                     |||          } t          |          | ||j                  }	t          j        ||	j        d          \  }
|                    |j	                  }|
                    d||
          }|                    |           |                    |          5  t          | ||j        ||	|          }|                    |           t          j        ||          }|                    ||j	                   d d d            d S # 1 swxY w Y   d S )NvaluerG   r   <)r   rb   r   rx   r   r
   r   re   r>   r   icmp_signed	set_validif_thenr  
yield_typeyield_increment_indexstore)r}   r=   r[   r   resultitertyiterr   r   r   r   r   is_validr  nindexs                  rC   iternext_arrayr  \  s    xHVFTG!!'6!>>G
*W

gwgm
D
D
DC"7CIQ???GFLL''E""3v66H
X		"	" - -)Wf/#u
 
 	e(%88fgm,,,- - - - - - - - - - - - - - - - - -s   AD22D69D6c           	         |                      t          j        d          }|                      t          j        d          }t          j        ||j        |j                  }	t          j        ||j        |j                  }
g }g }g }t          d |D                       }d}t          ||          D ].\  }}|t          j
        u r|j        t          |          z
  dz   |z   }t          |          D ]R}|                    |           |                    |	|                    |                    |
|                    |dz  }St          |t          j                  r|                     |||          }t!          j        | |||           t!          j        |||	|                    |                    |j                   t!          j        ||          }t!          j        |||
|                   }|                    |           |                    |           nt          |t          j                  rOt/          | ||||	|                   }|rt          j        | |||	|         |           |                    |           nQt3          |          r0|                    |           |                    |           |dz  }nt5          d|          |dz  }0||j        k    sJ ||j        k     rF|                    |	|                    |                    |
|                    |dz  }||j        k     Ft          j        | ||||dd          }|||fS )z
    Perform basic indexing on the given array.
    A (data pointer, shapes, strides) tuple is returned describing
    the corresponding view.
    r   rG   c                 0    g | ]}t          |          |S r   r   r   r   s     rC   r   z"basic_indexing.<locals>.<listcomp>  s%    FFFs[5E5EFsFFFrE   r
  unexpected index type: F
wraparoundboundscheck)r   r   r   r
   r   re   rp   r   r   r   ellipsisr8   ri   r   	SliceTyper   r.   guard_invalid_slice	fix_slicestartget_slice_length
fix_strider   r   do_boundscheckr   rR   get_item_pointer)r}   r=   r   r   r   r   r!  r   oner  r   output_indicesoutput_shapesoutput_stridesnum_newaxesaxindexvalr   	n_missingrm   sliceshstr   r  s                            rC   basic_indexingr6  x  s    
A..D


uz1
-
-C!'39ejAAF"7CKDDGNMNFFkFFFGGK	
Bw44    %EN""
S\\1A5CI9%%  %%d+++$$VBZ000%%gbk222aeU_-- 	N''h'GGE'%GGGgufRj999!!%+...)'599B#GUGBK@@B  $$$!!"%%%%u}-- 	N#GWeX$*2J0 0C N&wfRj"MMM!!#&&&& 	N  %%%!!$'''!GBB%%UU&LMMM
a 
uz//VBZ(((gbk***
a uz// &w'527UL L LG ]N33rE   c           	           t          |          | |          }t          |||||j        |j        |j                   |S )zF
    Build a view over the given array with the given parameters.
    r   re   r   r   r   r   )rx   r   r   r   r   )	r}   r=   r   r   r   r   r  r   r  s	            rC   r   r     sU    
 %Z$$Wg66F6"L;*& & & & MrE   c           
          t          | |||||| j                  \  }}}	t          |t          j                  r*t          | |||||||	          }
|
                                S |rJ t          | |||          S )zp
    Return the result of indexing *ary* with the given *indices*,
    returning either a scalar or a view.
    r!  )r6  enable_boundscheckr   r   r   r   r   r   )r}   r=   r   r   r   r   r   r  r  r  r  s              rC   _getitem_array_genericr<    s     	w['#*#=	? 	? 	? 'G[, +u|,, ;7GUC"K? ?!!! '5':::rE   c           	          |j         \  }}|\  }}|j        dk    sJ  t          |          | ||          }t          | ||j        |||f|f          }t          | ||j        |          S )z4
    Basic indexing with an integer or a slice.
    rG   )r   rp   rx   r<  r   r!   	r}   r=   r[   r   r   r   r   r   r   s	            rC   getitem_arraynd_intpr?    s|     8LE5HC:????
*U

GWc
2
2C
 '3?!&eXv? ?CWgsDDDrE   c           
         |j         \  }}|\  }} t          |          | ||          }|j        }t          j        ||t          |                    }	t          | |||	          \  }}	t          d |D                       rt          | |||||||	          S t          | ||j
        ||||	          }
t          | ||j
        |
          S )z2
    Basic or advanced indexing with a tuple.
    r   c              3   J   K   | ]}t          |t          j                  V  d S Nr   r   r   )r   tys     rC   	<genexpr>z&getitem_array_tuple.<locals>.<genexpr>  s.      
=
=2:b%+&&
=
=
=
=
=
=rE   )r   rx   r   r
   r   r   r   anyfancy_getitemr<  r   r!   )r}   r=   r[   r   r   tuptyr   tupr   r   r   s              rC   getitem_array_tuplerJ    s    
 8LE5HC
*U

GWc
2
2C+K"7Cs5zzBBBG,Wg-8'C CK 
=
=
=
=
=== ?WgsD"Cg? ? 	? !'3?!&['C CCWgsDDDrE   c           	      .   |j         \  }}}|\  }}}	t          |t          j                  r,|j        }
t	          j        ||t          |                    }n|f}
|f} t          |          | ||          }t          | ||
|          \  }
}	 t          | ||||
|| j
                  \  }}}t          |          }n# t          $ r d}Y nw xY w|rt          | ||||
|          S |                     ||	||j                  }	t!          | |||	|           dS )zH
    array[a] = scalar_or_array
    array[a,..,b] = scalar_or_array
    r   r:  TN)r   r   r   	BaseTupler
   r   r   rx   r   r6  r;  boolrR   fancy_setslicer   r{   r   )r}   r=   r[   r   r   r   valtyr   r   r   r   r   r  r  r   use_fancy_indexings                   rC   setitem_arrayrQ    st    (E5%MCc%)) k&w3u::FFFh&
*U

GWc
2
2C -Wg-8'C CK*7GUCg'.'AC C C 	! "&\\  " " "!"
  4 gwT)74 4 	4 ,,wUEK
8
8CwW55555s   B= =CCc                     |j         \  }|\  }t          |          } || ||          }|j        }|                    |d          }t	          | ||j        |          S r   )r   rx   re   extract_valuer#   r   )	r}   r=   r[   r   r   r   arysttyshapearyr   s	            rC   	array_lenrV  4  sd    xHUFSG
''7C
(
(CyH


!
,
,CgwEEErE   z
array.itemc           	         |j         \  }|\  } t          |          | ||          }|j        }|                    |                    d||                    d                    d          5  d}| j                            |t          |f           d d d            n# 1 swxY w Y   t          | |||j
                  S )N!=rG   Flikelyz>item(): can only convert an array of size 1 to a Python scalar)r   rx   r   r  r  r9   	call_convreturn_user_excr   r   r   )r}   r=   r[   r   r   r   r   r   s           rC   
array_itemr]  ?  s   XFEDC
*U

GWc
2
2CZF	,,T66;;q>>JJ % 
 
' 
' G GN))':vFFFG G G G G G G G G G G G G G G
 Wguch777s   .%BB#&B#   r   zarray.itemsetc           	         |j         \  }}|\  }}||j        k    sJ  t          |          | ||          }|j        }|                    |                    d||                    d                    d          5  d}	| j                            |t          |	f           d d d            n# 1 swxY w Y   t          | ||||j                   |                                 S )NrX  rG   FrY  z/itemset(): can only write to an array of size 1)r   r{   rx   r   r  r  r9   r[  r\  r   r   r   get_dummy_value)
r}   r=   r[   r   r   rO  r   r   r   r   s
             rC   array_itemsetrb  O  s9   xuS####j#66__W00vv{{1~~NN$)  + + 	K 	KCC--gzC6JJJ	K 	K 	K 	K 	K 	K 	K 	K 	K 	K 	K 	K 	K 	K 	K
 	7GUC:::&&(((s   =%B..B25B2c                   6    e Zd ZdZd Zd Zd Zd Zd Zd Z	dS )	Indexerzq
    Generic indexer interface, for generating indices over a fancy indexed
    array on a single dimension.
    c                     t           )ze
        Prepare the indexer by initializing any required variables, basic
        blocks...
        r   rY   s    rC   preparezIndexer.preparej  
    
 "!rE   c                     t           )z=
        Return this dimension's size as an integer.
        r   rf  s    rC   get_sizezIndexer.get_sizeq  
     "!rE   c                     t           )z;
        Return this dimension's shape as a tuple.
        r   rf  s    rC   	get_shapezIndexer.get_shapew  rk  rE   c                     t           )z}
        Return a half-open [lower, upper) range of indices this dimension
        is guaranteed not to step out of.
        r   rf  s    rC   get_index_boundszIndexer.get_index_bounds}  rh  rE   c                     t           )aW  
        Start indexation loop.  Return a (index, count) tuple.
        *index* is an integer LLVM value representing the index over this
        dimension.
        *count* is either an integer LLVM value representing the current
        iteration count, or None if this dimension should be omitted from
        the indexation result.
        r   rf  s    rC   	loop_headzIndexer.loop_head  s
     "!rE   c                     t           )z)
        Finish indexation loop.
        r   rf  s    rC   	loop_tailzIndexer.loop_tail  rk  rE   N)
rq   rr   rs   __doc__rg  rj  rm  ro  rq  rs  r   rE   rC   rd  rd  d  sx         
" " "" " "" " "" " "	" 	" 	"" " " " "rE   rd  c                   <    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
d	S )
EntireIndexerz:
    Compute indices along an entire array dimension.
    c                     || _         || _        || _        || _        || _        | j                             t          j                  | _        d S rB  )	r}   r=   r   r   dimr   r   r   ll_intp)rY   r}   r=   r   r   rx  s         rC   __init__zEntireIndexer.__init__  sB    
|225:>>rE   c                 
   | j         }|                    | j        j        | j                  | _        t          j        || j                  | _	        |
                                | _        |
                                | _        d S rB  )r=   rS  r   re   rx  r   r
   rW   ry  r   append_basic_blockbb_startbb_endrY   r=   s     rC   rg  zEntireIndexer.prepare  sf    ,))$(.$(CC	($,??
22440022rE   c                     | j         S rB  r   rf  s    rC   rj  zEntireIndexer.get_size  s
    yrE   c                     | j         fS rB  r  rf  s    rC   rm  zEntireIndexer.get_shape  s    	|rE   c                 :    |                      d          | j        fS r   ry  r   rf  s    rC   ro  zEntireIndexer.get_index_bounds      Q++rE   c                    | j         }| j                             t          | j        d          | j                   |                    | j                   |                    | j                   |                    | j                  }|	                    |
                    d|| j                  d          5  |                    | j                   d d d            n# 1 swxY w Y   ||fS Nr   >=FrY  )r=   r  r   ry  r   branchr}  position_at_endr>   r  r  r   r~  )rY   r=   	cur_indexs      rC   rq  zEntireIndexer.loop_head  s   ,8DL!44djAAAt}%%%...LL,,	__W00y$)LL$)  + + 	( 	(NN4;'''	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( )##   :C!!C%(C%c                    | j         }t          j        ||                    | j                            }|                    || j                   |                    | j                   |                    | j	                   d S rB  )
r=   r
   r  r>   r   r  r  r}  r  r~  rY   r=   
next_indexs      rC   rs  zEntireIndexer.loop_tail  so    ,,Wgll4:6N6NOO
j$*---t}%%%,,,,,rE   Nrq   rr   rs   rt  rz  rg  rj  rm  ro  rq  rs  r   rE   rC   rv  rv    s         ? ? ?3 3 3    , , ,
$ 
$ 
$- - - - -rE   rv  c                   <    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
d	S )
IntegerIndexerz0
    Compute indices from a single integer.
    c                     || _         || _        || _        | j                             t          j                  | _        d S rB  )r}   r=   r   r   r   r   ry  )rY   r}   r=   r   s       rC   rz  zIntegerIndexer.__init__  s4    |225:>>rE   c                     d S rB  r   rf  s    rC   rg  zIntegerIndexer.prepare      rE   c                 ,    t          | j        d          S NrG   )r   ry  rf  s    rC   rj  zIntegerIndexer.get_size  s    a(((rE   c                     dS Nr   r   rf  s    rC   rm  zIntegerIndexer.get_shape  s    rrE   c                 t    | j         | j                            | j         |                                           fS rB  )r   r=   addrj  rf  s    rC   ro  zIntegerIndexer.get_index_bounds  s+    $,**48T]]__EEFFrE   c                     | j         d fS rB  )r   rf  s    rC   rq  zIntegerIndexer.loop_head  s    x~rE   c                     d S rB  r   rf  s    rC   rs  zIntegerIndexer.loop_tail  r  rE   Nr  r   rE   rC   r  r    s         ? ? ?  ) ) )  G G G      rE   r  c                   <    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
d	S )
IntegerArrayIndexerz;
    Compute indices from an array of integer indices.
    c                     || _         || _        || _        || _        || _        |j        dk    sJ | j                             t          j                  | _	        d S r  )
r}   r=   r   r   r   rp   r   r   r   ry  )rY   r}   r=   r   r   r   s         rC   rz  zIntegerArrayIndexer.__init__  sQ    
	zQ|225:>>rE   c                 
   | j         }t          j        || j        j                  d         | _        t          j        || j                  | _        |	                                | _
        |	                                | _        d S r   )r=   r
   r   r   re   idx_sizerW   ry  	idx_indexr|  r}  r~  r  s     rC   rg  zIntegerArrayIndexer.prepare  sg    ,,Wdk6GHHK ,WdlCC22440022rE   c                     | j         S rB  r  rf  s    rC   rj  zIntegerArrayIndexer.get_size  s
    }rE   c                     | j         fS rB  r  rf  s    rC   rm  zIntegerArrayIndexer.get_shape  s    rE   c                 :    |                      d          | j        fS r   r  rf  s    rC   ro  z$IntegerArrayIndexer.get_index_bounds  r  rE   c                    | j         }| j                             t          | j        d          | j                   |                    | j                   |                    | j                   |                    | j                  }|	                    |
                    d|| j                  d          5  |                    | j                   d d d            n# 1 swxY w Y   t          | j        || j        j        | j        | j        |          }t%          | j        || j        j        || j                  }||fS r  )r=   r  r   ry  r  r  r}  r  r>   r  r  r  r~  r  r}   r   r{   r   r   r   )rY   r=   r  r   s       rC   rq  zIntegerArrayIndexer.loop_head  sf   ,8DL!44dnEEEt}%%%...LL00	__i??  
 
 	( 	( NN4;'''		( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( *L'4:#3TZ
 
 "$,"&*"2E49F Fir  c                    | j         }t          j        ||                    | j                            }|                    || j                   |                    | j                   |                    | j	                   d S rB  )
r=   r
   r  r>   r  r  r  r}  r  r~  r  s      rC   rs  zIntegerArrayIndexer.loop_tail  sv    ,,W-4\\$.-I-IK K
j$.111t}%%%,,,,,rE   Nr  r   rE   rC   r  r    s         ? ? ?3 3 3       , , ,     *- - - - -rE   r  c                   <    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
d	S )
BooleanArrayIndexerz>
    Compute indices from an array of boolean predicates.
    c                     || _         || _        || _        || _        |j        dk    sJ | j                             t          j                  | _        t          | j        d          | _
        d S NrG   r   )r}   r=   r   r   rp   r   r   r   ry  r   r   )rY   r}   r=   r   r   s        rC   rz  zBooleanArrayIndexer.__init__)  s]    
zQ|225:>>T\1--			rE   c                 z   | j         }t          j        || j        j                  d         | _        t          j        || j                  | _        t          j        || j                  | _	        |
                                | _        |
                                | _        |
                                | _        d S r   )r=   r
   r   r   re   r   rW   ry  r  r   r|  r}  bb_tailr~  r  s     rC   rg  zBooleanArrayIndexer.prepare2  s    ,($+2CDDQG	 ,WdlCC($,??
224411330022rE   c           	         | j         }t          j        || j                  }t          j        || j                  5 }|                    |          }t          | j        || j	        j
        | j	        | j        |j                  }|                    ||                    ||j                            }|                    ||           d d d            n# 1 swxY w Y   |                    |          S rB  )r=   r
   r   r   	for_ranger   r>   r  r}   r   r{   r   r   r  zextr9   r  )rY   r=   r   loopcpreds         rC   rj  zBooleanArrayIndexer.get_size;  s   ,)'49==w	22 	$dU##A,gtz'7
DK D Aw||D!&99::AMM!U###	$ 	$ 	$ 	$ 	$ 	$ 	$ 	$ 	$ 	$ 	$ 	$ 	$ 	$ 	$ ||E"""s   BCCCc                 ,    |                                  fS rB  rj  rf  s    rC   rm  zBooleanArrayIndexer.get_shapeJ      !!rE   c                 :    |                      d          | j        fS r   r  rf  s    rC   ro  z$BooleanArrayIndexer.get_index_boundsM  s     Q++rE   c                    | j         }| j                             | j        | j                   | j                             | j        | j                   |                    | j                   |                    | j                   |                    | j                  }|                    | j                  }|	                    |
                    d|| j                  d          5  |                    | j                   d d d            n# 1 swxY w Y   t          | j        || j        j        | j        | j        |          }|	                    |                    |                    5  |                    | j                   d d d            n# 1 swxY w Y   t)          j        ||          }|                    || j                   ||fS )Nr  FrY  )r=   r  r   r  r   r  r}  r  r>   r  r  r   r~  r  r}   r   r{   r   not_r  r
   r  )rY   r=   r  	cur_countr  
next_counts         rC   rq  zBooleanArrayIndexer.loop_headR  s   ,49dn55549dj111t}%%%...LL00	LL,,	__W00y$)LL$)  + + 	( 	(NN4;'''	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( )L'4:#3TZ
 
 __W\\$//00 	) 	)NN4<(((	) 	) 	) 	) 	) 	) 	) 	) 	) 	) 	) 	) 	) 	) 	) ,Wi@@
j$*---)##s$   +DDD2FF Fc                 t   | j         }|                    | j                   |                    | j                   t	          j        ||                    | j                            }|                    || j                   |                    | j	                   |                    | j
                   d S rB  )r=   r  r  r  r
   r  r>   r  r  r}  r~  r  s      rC   rs  zBooleanArrayIndexer.loop_tailj  s    ,t|$$$---,W-4\\$.-I-IK K
j$.111t}%%%,,,,,rE   Nr  r   rE   rC   r  r  $  s         . . .3 3 3# # #" " ", , ,
$ $ $0- - - - -rE   r  c                   <    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
d	S )
SliceIndexerz(
    Compute indices along a slice.
    c                     || _         || _        || _        || _        || _        || _        || _        | j                             t          j	                  | _
        t          | j
        d          | _        d S r   )r}   r=   r   r   rx  r   r3  r   r   r   ry  r   r   )rY   r}   r=   r   r   rx  r   r3  s           rC   rz  zSliceIndexer.__init__z  sc    


|225:>>T\1--			rE   c                    | j         }|                    | j        j        | j                  | _        t          j        | j        || j	        | j
                   t          j        || j
        | j                   t          j        || j
        j                  | _        t          j        || j                  | _        t          j        || j                  | _        |                                | _        |                                | _        d S rB  )r=   rS  r   re   rx  dim_sizer.   r$  r}   r   r3  r%  r
   
is_neg_intstepis_step_negativerW   ry  r   r   r|  r}  r~  r  s     rC   rg  zSliceIndexer.prepare  s    ,--dhndhGG#DL'4:$(J	0 	0 	0'4:t}=== ' 27DJO L L($,??
($,??
22440022rE   c                 @    t          j        | j        | j                  S rB  )r.   r'  r=   r3  rf  s    rC   rj  zSliceIndexer.get_size  s    'djAAArE   c                 ,    |                                  fS rB  r  rf  s    rC   rm  zSliceIndexer.get_shape  r  rE   c                 N    t          j        | j        | j                  \  }}||fS rB  )r.   get_slice_boundsr=   r3  )rY   loweruppers      rC   ro  zSliceIndexer.get_index_bounds  s&    /djIIue|rE   c           	         | j         }| j                             | j        j        | j                   | j                             | j        | j                   |                    | j                   |	                    | j                   |
                    | j                  }|
                    | j                  }|                    | j        |                    d|| j        j                  |                    d|| j        j                            }|                    |d          5  |                    | j                   d d d            n# 1 swxY w Y   ||fS )Nz<=r  FrY  )r=   r  r3  r&  r   r   r   r  r}  r  r>   selectr  r  stopr  r~  )rY   r=   r  r  is_finisheds        rC   rq  zSliceIndexer.loop_head  sz   ,4:+TZ88849dj111t}%%%...LL,,	LL,,	nnT%:%,%8%8y9=&J &J%,%8%8y9=&J &JK K
 __[_77 	( 	(NN4;'''	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	()##s   0EEEc                    | j         }|                    |                    | j                  | j        j        dg          }|                    || j                   t          j        ||                    | j	                            }|                    || j	                   |
                    | j                   |                    | j                   d S )Nr   r   )r=   r  r>   r   r3  r  r  r
   r  r   r  r}  r  r~  )rY   r=   r  r  s       rC   rs  zSliceIndexer.loop_tail  s    ,[[dj!9!94:?(-w ! 0 0
j$*---,Wgll4:6N6NOO
j$*---t}%%%,,,,,rE   Nr  r   rE   rC   r  r  u  s         	. 	. 	.3 3 3B B B" " "  $ $ $$- - - - -rE   r  c                   6    e Zd ZdZd Zd Zd Zd Zd Zd Z	dS )	FancyIndexerz4
    Perform fancy indexing on the given array.
    c           
      0   || _         || _        || _        t          j        ||j        |j                  | _        t          j        ||j        |j                  | _        | j         	                    t          j                  | _        g | _        g }t          d |D                       }d}	d}
t          ||          D ]9\  }}|t          j        u rb|j        t          |          z
  dz   |z   }t#          |          D ]4}t%          |||||	          }|                    |           |	dz  }	|
dz  }
5vt)          |t          j                  rC|                    |||          }t/          |||||	||          }|                    |           n\t)          |t          j                  rEt3          ||||| j        |	                   }t5          |||          }|                    |           nt)          |t          j                  r t9          |          |||          }t)          |j        t          j                  rt=          ||||| j        |	                   }n4t)          |j        t          j                  rtA          ||||          }nJ |                    |           nAtC          |          r | j                            |
           |	dz  }	ntE          d|          |	dz  }	|
dz  }
;|	|j        k    sJ |	|j        f            |	|j        k     r8t%          |||||	          }|                    |           |	dz  }	|	|j        k     8t          |          |j        k    sJ t          |          |j        f            || _#        d S )Nc                 0    g | ]}t          |          |S r   r  r  s     rC   r   z)FancyIndexer.__init__.<locals>.<listcomp>  s%    JJJ3S9I9IJ3JJJrE   r   rG   r  )$r}   r=   r   r
   r   re   rp   r  r   r   r   r   ry  newaxesr   r   r"  r8   rv  ri   r   r#  r   r  r   r   r  r   rx   r{   r  Booleanr  r   AssertionErrorindexers)rY   r}   r=   r   r   r   r   r  r/  r0  new_axr1  r   r2  rm   indexerr3  r   r   s                      rC   rz  zFancyIndexer.__init__  s   
*7CIuzJJ+GS[%*MM|225:>>JJ+JJJKK"7K88 (	 (	OHe&&!JW59KG	y))    A+GWeS"MMGOOG,,,!GBaKFF %11 M++GUHEE&wR',e5 5((((E5=11 M'%(,B9 9('3??((((E5;// M*E**7GXFFek5=99 1'72726+b/C CGG  U];; 1'727A AGG H((((U## M##F+++a$nEE%KLLL!GBaKFF UZ"ej!15:oo#GWeS"EEGOOG$$$!GB 5:oo
 8}}
***S]]EJ,G*** rE   c                    | j         D ]}|                                 | j                            t          j        d          }d | j         D             }| j        D ]}|                    ||f           t          |d          | _	        d S )NrG   c                 6    g | ]}|                                 S r   )rm  r   rm   s     rC   r   z(FancyIndexer.prepare.<locals>.<listcomp>  s     :::qQ[[]]:::rE   r   )
r  rg  r}   r   r   r   r  insertsumindexers_shape)rY   rm   r+  	res_shapes       rC   rg  zFancyIndexer.prepare  s     	 	AIIKKKKl''
A66 ;:DM:::	  	( 	(AQ''''
 ")R00rE   c                     | j         S )z?
        Get the resulting data shape as Python tuple.
        )r  rf  s    rC   rm  zFancyIndexer.get_shape  s     ""rE   c           	      t   t          |          | j        j        k    sJ | j        }t          j        }|                     d          }|                     d          }|}|}t          | j        | j	        |          D ]\  }	}
}|
                    ||                    d|
|                    }|	                                \  }}|                    ||          }|                    ||                    ||                    }|                    d||          }|                    ||                    |||                    }|                    ||                    |||                    }|                    ||          }|                    |||          }|                    |||          }||fS )z
        Get a half-open [lower, upper) range of byte offsets spanned by
        the indexer with the given strides and itemsize.  The indexer is
        guaranteed to not go past those bounds.
        r   rG   ==r  )r   r   rp   r=   r
   	false_bitry  r   r  r  or_icmp_unsignedro  r   subr  r  r  )rY   r   r   r=   is_emptyr   r+  r  r  r  re   stridelower_indexupper_indexlower_offsetupper_offsetis_downwardss                    rC   get_offset_boundszFancyIndexer.get_offset_bounds  s    7||tz....,$||All1oo&)$-9L*1'3 '3 	> 	>"GUF{{8#*#8#8ud#K#KM MH (/'?'?'A'A$K";;v{;;L";;vw{{;/L/LMML"..sFDAALKK '|/;/;!= !=> >E KK '|/;/;!= !=> >EE
 E8,,xu55xu55e|rE   c                 @    t          d | j        D              \  }}||fS )Nc              3   >   K   | ]}|                                 V  d S rB  )rq  r  s     rC   rE  z+FancyIndexer.begin_loops.<locals>.<genexpr>A  s*      EE!EEEEEErE   )r   r  )rY   r   countss      rC   begin_loopszFancyIndexer.begin_loops@  s+    EEt}EEEFrE   c                 \    t          | j                  D ]}|                                 d S rB  )reversedr  rs  )rY   rm   s     rC   	end_loopszFancyIndexer.end_loopsD  s4    $-(( 	 	AKKMMMM	 	rE   N)
rq   rr   rs   rt  rz  rg  rm  r  r  r  r   rE   rC   r  r    s}         @! @! @!D1 1 1&# # #$ $ $L      rE   r  c                 z   t          j        ||j                  }t          j        ||j                  }	|j        }
t          | |||||          }|                                 |j        }|                                }t          | |||          }|j        }t          j
        ||                     t          j        d                    }|                                \  }}t          j        | ||
||	|j        |d| j        	  	        }t%          | |||          }|                    |          }|                    ||g          }t+          | ||||           t          j        ||          }|                    ||           |                                 t3          | |||                                          S )Nr   Fr  )r
   r   re   r   r   r  rg  r   rm  _empty_nd_implr   r   r   r   r  get_item_pointer2layoutr;  r   r>   gepr   r  r  r  r"   r   )r}   r=   r[   r   r   r   r   r   r  r   r   r  out_ty
out_shapesr   out_dataout_idx_rk   r   curnext_idxs                         rC   rG  rG  I  s    !'3955F"7CK88G8D7GUC&1 1GOO _F""$$J
'6:
>
>CxH'(/(<(<UZ(K(KM MG $$&&JGQ 
#GWdFG$)L'e070JL L LC GWeS
1
1C ,,w

C
++h
&
&Cwc222&w44HMM(G$$$GWfcmmooFFFrE   c           
      *   |j         \  }}|\  }} t          |          | ||          }|j        dk    rHt          | |||          \  }}t	          | ||j        |||f|f          }t          | ||j        |          S t          | ||||||f|f          S )z3
    Advanced or basic indexing with an array.
    r   )r   rx   rp   r   r<  r   r!   rG  r>  s	            rC   fancy_getitem_arrayr  t  s    
 8LE5HC
*U

GWc
2
2CzQ$WgucBB
s$Wgs%*C%C6C C '3?CHHH WgsD"C%C6; ; 	;rE   c           	         |j         }|                    d          }|                    d          }|j        dv r|}	|                    ||j                  }
n|}	|}
t          |j                  D ]}|                    ||         |                    ||         |                    }|                    d||          }|	                    ||
                    |
|          |
          }
|	                    ||	|
                    |	|                    }	|
                    |
|          }
|                    d|j        |          }|	                    |||
          }
|	                    |||	          }	|	|
fS )z
    Compute a half-open range [lower, upper) of byte offsets from the
    array's data pointer, that bound the in-memory extent of the array.

    This mimics offset_bounds_from_strides() from
    numpy/core/src/private/mem_overlap.c
    r   rG   CFr  r  )r   r9   r  r   r   r8   rp   r  r  r  r  )r}   r=   arrtyarrr  r   r   r   r+  r  r  rm   max_axis_offset
is_upwardsr  s                  rC   offset_bounds_from_stridesr    s~    |H==D
))A,,C|t Hcj11 uz"" 	O 	OA &kk'!**1++fQi*E*EG GO ,,T?DIIJNN:#*;;uo#F#FO OENN:#('++e_*M*MO OEE E8,,&&tSZ>>xu55xu55%<rE   c                     |                     ||j                  }|                    ||          }|                    ||          }||fS )z
    Given [lower, upper) byte offsets and a base data pointer,
    compute the memory pointer bounds as pointer-sized integers.
    )ptrtointr9   r  )r}   r=   r  r  r   data_ptr_as_intr&  ends           rC   compute_memory_extentsr    sK    
 &&tUZ88OKK//E
++ou
-
-C#:rE   c                 V    t          | |||||          \  }}t          | ||||          S )zr
    Compute a half-open range [start, end) of pointer-sized integers
    which fully contain the array data.
    )r  r  )	r}   r=   r	  r
  r  r   r   r  r  s	            rC   get_array_memory_extentsr    s:     .gws.4g? ?LE5!'7E5$GGGrE   c                     |                     |                    d||          |                    d||                    }|S )z[
    Whether two memory extents [a_start, a_end) and [b_start, b_end)
    may overlap.
    r  )and_r  )r}   r=   a_starta_endb_startb_endmay_overlaps          rC   extents_may_overlapr    sI     ,,c7E22c7E22 K rE   c                 2    j         dt          j                  d                     d          5                      |j        |j                  } j                            |          }	|	j         	                    |	          }	
                    |	                                t          j                  }
t          j        |
          5 }t          j         j        |          }t          j         |	|          }
                                        |          |           d d d            n# 1 swxY w Y   d d d            n# 1 swxY w Y    fd} fd}||fS )Nr   FrY  c                 4   t          j        
          }                    d          5 \  }}|5                      t          j                                      	| d          |           d d d            n# 1 swxY w Y   |5                      t          j        j        | d          |           d d d            n# 1 swxY w Y   d d d            n# 1 swxY w Y   t                              |                    S )NFrY  r   )r
   rW   if_elser  r  r>   r  r   )source_indicessrc_ptrif_copy	otherwiser=   r}   	copy_datacopy_layoutcopy_shapescopy_stridesptrtysrc_data
src_shapessrc_stridessrctyuse_copys       rC   src_getitemz&maybe_copy_source.<locals>.src_getitem  s   %gu55__Xe_44 	8L)  -gw.5ll9.E.E.9<.9>9>	@ @ @
                    -gw.8+.3lN9>@ @ @                 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	  '5',,w2G2GHHHsY   C*AB8C*B	C*B	C*6CC*C	C*C	C**C.1C.c                                           d          5                                }                     |           } j                            |            d d d            d S # 1 swxY w Y   d S )NFrY  )r  r>   bitcastr   free)r   r=   r}   r%  r.  	voidptrtys    rC   src_cleanupz&maybe_copy_source.<locals>.src_cleanup  s    __Xe_44 	, 	,<<	**D??433DKWd+++	, 	, 	, 	, 	, 	, 	, 	, 	, 	, 	, 	, 	, 	, 	, 	, 	, 	,s   AA--A14A1)r9   r
   r   r  r   r   r   r   allocater1  r  r   r   r   	loop_nestr  r  r>   )r}   r=   r.  r-  srcr+  r,  r*  	allocsizer   r   r   r"  dest_ptrr/  r4  r%  r&  r'  r(  r)  r3  s   ```` ```        @@@@@@rC   maybe_copy_sourcer:    s   MEK)'8<<IKL	%	0	0 ; ; KKcj99	{##GY77I	tU++dI&&& ''
33w
F;; 	;w/(0:K05gG GG 0'41<l1<gG GH MM',,w//:::	; 	; 	; 	; 	; 	; 	; 	; 	; 	; 	; 	; 	; 	; 	;; ; ; ; ; ; ; ; ; ; ; ; ; ; ;,I I I I I I I I I I I I I I I I(, , , , , , , , , ##s8   B$E1+A#EE1E	E1!E	"E11E58E5c                   
 |                      t          j        d          }|                      t          j        d          
t          |          t          |          k    r2t          |          t          |          z
  }
g|z  |z   }|g|z  |z   }nt          |          t          |          k     rt          |          t          |          z
  }
fd|d|         D             }t	          j        j        |t          j                  }	                    
                    |          d          5  d}	| j                            t          |	f           ddd           n# 1 swxY w Y   ||d         }||d         }||fS )ae  
    Preprocess dimension for broadcasting.
    Returns (shapes, strides) such that the ndim match *target_shape*.
    When expanding to higher ndim, the returning shapes and strides are
    prepended with ones and zeros, respectively.
    When truncating to lower ndim, the shapes are checked (in runtime).
    All extra dimension must have size of 1.
    r   rG   c                 >    g | ]}                     d |          S r  )r  )r   r4  r=   r+  s     rC   r   z(_bc_adjust_dimension.<locals>.<listcomp>(  s;     2 2 2 ++D"c:: 2 2 2rE   NFrY  z,cannot broadcast source array for assignment)r   r   r   r   	functoolsreducer  r
   true_bitr  r  r[  r\  r   )r}   r=   r  r   target_shaper   nd_diff
dim_is_oneacceptedr   r+  s    `        @rC   _bc_adjust_dimensionrE    s    Q//D


u{A
.
.C <3v;;&&l##c&kk16)&7"W,	\		S[[	(	(f++L 1 112 2 2 2 2 &xx 02 2 2
#GL*$+$46 6 __W\\(33E_BB 	K 	K@C--gzC6JJJ	K 	K 	K 	K 	K 	K 	K 	K 	K 	K 	K 	K 	K 	K 	K !'((#7?s   :%E++E/2E/c                   
 g }g }|                      t          j        d          |                      t          j        d          
fdt          ||          D             }
fd|D             }fdt          ||          D             }	fdt          |	||          D             }fdt          |	|          D             }||fS )z
    Broadcast shapes and strides to target_shape given that their ndim already
    matches.  For each location where the shape is 1 and does not match the
    dim for target, it is set to the value at the target and the stride is
    set to zero.
    r   rG   c                 D    g | ]\  }}                     d ||          S )rX  r  )r   taroldr=   s      rC   r   z,_bc_adjust_shape_strides.<locals>.<listcomp>C  s?     ; ; ;C ##D#s33 ; ; ;rE   c                 >    g | ]}                     d |          S r=  rH  )r   rJ  r=   r+  s     rC   r   z,_bc_adjust_shape_strides.<locals>.<listcomp>E  s+    HHH#'%%dC55HHHrE   c                 B    g | ]\  }}                     ||          S r   )r  )r   xyr=   s      rC   r   z,_bc_adjust_shape_strides.<locals>.<listcomp>F  s+    FFFDAqW\\!QFFFrE   c                 F    g | ]\  }}}                     |||          S r   r  )r   prI  rJ  r=   s       rC   r   z,_bc_adjust_shape_strides.<locals>.<listcomp>G  sE     F F F QS 3,, F F FrE   c                 D    g | ]\  }}                     ||          S r   rP  )r   rQ  rJ  r=   r   s      rC   r   z,_bc_adjust_shape_strides.<locals>.<listcomp>I  s=     5 5 5a ..D#.. 5 5 5rE   )r   r   r   r   )r}   r=   r  r   rA  	bc_shapes
bc_stridesmismatch
src_is_onepredsr+  r   s    `        @@rC   _bc_adjust_shape_stridesrX  7  s-    IJQ//D


u{A
.
.C; ; ; ; #L& 9 9; ; ;HHHHHHHHHJFFFFC*,E,EFFFEF F F F$'|V$D$DF F FI5 5 5 5 5 #E7 3 35 5 5Jj  rE   c           	         t          j        ||j                  }t          j        ||j                  }t	          | ||||          \  }}t          | ||||          \  }}|                    t          |          d          } t          |          | |          }t          ||j
        t          j        ||          t          j        ||          |j        |j        |j                   ||fS )zX
    Broadcast the given array to the target_shape.
    Returns (array_type, array)
    Arp   r  r8  )r
   r   re   r   rE  rX  copyr   rx   r   r   rj   r   r   r   )	r}   r=   arrtyper
  rA  r  r   new_arrtypenew_arrs	            rC   _broadcast_to_shaper`  N  s     !'3955F"7CK88G*7GVW+79 9OFG.w/6F FOFG,,C$5$5c,BBK%j%%gw77G7 +GV<<"-gw??L;*& & & & rE   c                 b    |                     |j        dd          } |||          }d }||fS )NrZ  T)rp   r  readonlyc                    |\  }}|j         d         } t          |          | ||          }t          j        ||          }t	          | ||||          \  }}t          |dt          |                     |j        	                    d                    d                      |
                                }	t          | ||j        |	          S )Nr   r   )r   rx   r
   r   r`  r   r   r   r   r   r   r!   r   )
r}   r=   r[   r   r7  shape_r-  r  destr   s
             rC   codegenz$_numpy_broadcast_to.<locals>.codegenm  s    Vj#66%gv66%gwsFLL4 	h&&t'?'?'I'IJJ! ! 	 	 	 nn '3?CHHHrE   )r\  r   )	typingctxr   re   retr[   rf  s         rC   _numpy_broadcast_tori  h  sJ    
**%+cD*
A
AC
#eU

CI I I <rE   c                 R    |                     d          } ||          }d }||fS )NTrb  c                     |\  }|j         d         } t          |          | ||          }t          j        |j        j                  |_        |                                }t          | ||j        |          S r   )	r   rx   r
   get_null_valuer   r9   r   r!   r   )r}   r=   r[   r   r7  r-  re  r   s           rC   rf  z#get_readonly_array.<locals>.codegen  sk     z%  '377,T[-=>>nn '3?CHHHrE   )r\  )rg  r
  rh  r[   rf  s        rC   get_readonly_arrayrn    sB     ((D(
!
!C
#c((CI I I <rE   c                 D   | j         }t          |          }t          |          }||k    rt          d          |D ]}|dk     rt          d          d}||z
  }||k     r>||         }||         }	||	k    s|dk    r|dz  }|dz  }nt          d          ||k     <d S d S )NzDinput operand has more dimensions than allowed by the axis remappingr   z4all elements of broadcast shape must be non-negativerG   z=operands could not be broadcast together with remapped shapes)re   r   r   )
r   
dest_shape	src_shapesrc_ndim	dest_ndimr   	src_index
dest_indexsrc_dimdest_dims
             rC   _can_broadcastrx    s    I9~~HJI) 1 2 2 	2 - -!88 , - - - 
 IX%J
h

I&j) h'Q,,NI!OJJ 4 5 5 5 h





rE   c                 j    t          j        |           } t          | |           t          | |          S rB  )npasarrayrx  ri  r   re   s     rC   _default_broadcast_to_implr}    s1    JuE5%   ue,,,rE   c                    t          |           st          j        d          t          |t          j                  rd }|S t          |t          j                  r<t          |j        t          j                  sd}t          j        |          t          S t          |t          j	                  rE|j
        dk    r:t          d |D                       sd| d}t          j        |          t          S t          |t          j	                  r\|j
        dk    rQt          | t          j                  o
| j        dk    }t          |           s|rd }|S d	}t          j        |          d
|z  }t          j        |          )Nz-The first argument "array" must be array-likec                 .    t          j        | |f          S rB  )rz  broadcast_tor|  s     rC   r   z numpy_broadcast_to.<locals>.impl  s    ?55(333rE   z7The second argument "shape" must be a tuple of integersr   c                 B    g | ]}t          |t          j                  S r   )r   r   IntegerLiteral)r   typs     rC   r   z&numpy_broadcast_to.<locals>.<listcomp>  s%    KKKcJsE$899KKKrE   "z," object cannot be interpreted as an integerc                 H    t          j        |           } t          |           S rB  )rz  r{  rn  r|  s     rC   r   z numpy_broadcast_to.<locals>.impl  s!     
5)))%000rE   z/Cannot broadcast a non-scalar to a scalar arrayz:The argument "shape" must be a tuple or an integer. Got %s)r   r	   r   r   r   r   UniTupler{   r}  Tupler   allr   rp   r   )r   re   r   r   is_scalar_arrays        rC   numpy_broadcast_tor    s   E"" 2  "1 2 2 	2 %'' "&	4 	4 	4	E5>	*	* &%+u}55 	*KC$S)))))	E5;	'	' &EK!OOKKUKKKLL 	*IeIIIC$S)))))	E5;	'	' &EK1,<,<$UEK88LUZ1_%   	*O 	*1 1 1
 K DC$S)))  %%%rE   c                    t          t          |                    D ]h}|t          |          z
  |z   }||         }|dk     rt          d          |dk    r;| |         dk    r|| |<   M| |         |k    rt          d          id S )Nr   #negative dimensions are not allowedrG   z=shape mismatch: objects cannot be broadcast to a single shape)r8   r   r   )rmre   rm   r   tmps         rC   numpy_broadcast_shapes_listr    s    3u:: 3 3E

NQAh77BCCC!88Q4199AaDDqTS[[ 2 3 3 3 3 3rE   c                  |  	 t          |           D ]\  }}t          |t          j                  }t          |t          j                  ot          |j        t          j                  }t          |t          j                  ot          |j                  dk    }|s |s|sd| d| }t          j	        |          d| D ]d}t          |t          j                  rt          d          -t          |t          j                  rt          t          |                    edk    rd S dz  		fd}|S )Nr   z	Argument z* must be either an int or tuple[int]. Got rG   c                      dS r  r   r   s    rC   <lambda>z+ol_numpy_broadcast_shapes.<locals>.<lambda>	  s    R rE   rG   c                  J   dgz  }}t          |           D ]c}t          |t                    r%t          |          dk    rt	          ||           <t          |t
                    rt	          ||f           dt          |          D ]\  }}t          |||          }|S r  )r   r   r   r   r  r   	enumerater/   )r   r  rI  argr   elemr  tup_inits         rC   r   z'ol_numpy_broadcast_shapes.<locals>.impl  s    aAC%d++ > >c5)) >c#hhll/1c::::S)) >/1sf===&q\\ 4 4	T#Cd33JrE   )r  r   r   r   r  r{   r  r   r	   r   maxrL  )
r   r   r  is_intis_int_tupleis_empty_tupler   r   r  r  s
           @@rC   ol_numpy_broadcast_shapesr    sh    dOO * *SC//!#u~66 1sy%-00 	#C55M#ci..A:M 	*, 	*. 	* s       C$S))) 	
A ! !c5=)) 	!Aq		AAU_-- 	!As3xx  AAvv!8	 	 	 	 	 	 rE   c                     t          |           D ],\  }}t          |          st          j        d| d          -d }d }| D ]T}t	          |t
          j        t
          j        f          r|j        }n|}||}7||k    rt          j        d|            Udt          |           D ]\  }}t	          |t
          j	                  rt          |j                  5t	          |t
          j        t
          j        t
          j        f          rt          d          wt          j        d|           dz  fd}|S )	Nz
Argument "z" must be array-likezTMismatch of argument types. Numba cannot broadcast arrays with different types. Got r   rG   zUnhandled type r   c                  z   dgz  }t          |           D ]*}t          |t          j        |          j                   +}t                    D ]}t          ||||                   }g }t          |           D ]<}|                    t          j        t          j        |          |                     =|S r  )	r   r  rz  r{  re   r8   r/   ri   r  )r   re   r   rI  rm   outsr  r  s         rC   r   z$numpy_broadcast_arrays.<locals>.impl?  s    
 a#D)) 	K 	KE'q"*U2C2C2IJJJJq 	2 	2AQa11CC #D)) 	A 	AEKK
5(9(93??@@@@rE   )r  r   r	   r   r   r   r   rL  r{   ArrayCompatibler  rp   Numberr  )r   r   r  unified_dtypedtr   r  r  s         @@rC   numpy_broadcast_arraysr    s    dOO 6 6S$$ 	6$ &5# &5 &5 &5 6 6 6	6 M	B 4 4cEK9:: 	BBB MMb  $ &3,0&3 &3 4 4 4 ! 	
AdOO > >Sc5011 	>Asx  AAelEM5?KLL 	>Aq		AA$%<s%<%<===axH     ( KrE   c                    *+, |j         \  }},|\  }}* t          |           |          }t          j        |j                  }	t          j        |j                  }
|j        }t           ||||          }|                                 t          ,t          j                  r,j        +|                                } t          ,           *          *t           ,*|          \  ,*t          j        *j                  }t          j        *j                  }*j        }t          j        }t!          |          t!          |          k    sJ t#          ||          D ]0\  }}                    |                    d||                    }1                    |d          5  d }t          j        t          j        t          j        t!          |                    t          j        t          j        t!          |                              }                     |j         d         |                               |j         d         |          f}                     |||          }t5           ||          } j                            t:          |ft          j        f           ddd           n# 1 swxY w Y   t=           ,*|||          \  }}|                    |
|j                   \  }}tC           |||          \  }}tE           ||||          }tG           |,*|||          \  }} n|t          ,t          j$                  rW,j        +|                                }t!          |          dk    sJ  %                    t           tM          t          j'        ,                    }! |!*f          }"                    d|d         |"          }                    |d          5  d }|"|d         f}t          j        t          j        t          j                  }                     |||          }t5           ||          } j                            t:          |ft          j        f           ddd           n# 1 swxY w Y    *+,fd	}d
 } n
,+*fd}d }  (                    t          j)        d          }#|*                                \  }$}%tW          |%          }%|j,        D ]}&|%-                    |&|#           d |%D             }' ||'          }( .                    |(+|j                  }(t          j/         ||	|
|j0        |$d j1        	  	        })te           ||(|)           |3                                  |               4                                S )z
    Implement slice assignment for arrays.  This implementation works for
    basic as well as fancy indexing, since there's no functional difference
    between the two for indexed assignment.
    rX  FrY  c                     ddd                     d | D                        dz   dz   dd                     d |D                        dz   S )	Nzcannot assign slice of shape (, c                 ,    g | ]}t          |          S r   strr   rM  s     rC   r   z6fancy_setslice.<locals>.raise_impl.<locals>.<listcomp>  s    &B&B&B!s1vv&B&B&BrE   z) from zinput of shape c                 ,    g | ]}t          |          S r   r  r  s     rC   r   z6fancy_setslice.<locals>.raise_impl.<locals>.<listcomp>  s    &C&C&C!s1vv&C&C&CrE   ))join)r+  index_shapes     rC   
raise_implz"fancy_setslice.<locals>.raise_impl}  st    7LDII&B&Bz&B&B&BCCLLLM)* HDII&C&C{&C&C&CDDGGGH IrE   r   rG   Nc                     d|  dd| dz   S )Nzcannot assign slice of shape (z, )zfrom input of shape (r   )seq_leninput_shapes     rC   r  z"fancy_setslice.<locals>.raise_impl  s*    EEEE@@@@A BrE   c                     | \  }                     t          j        t          t          j                            } ||f          S rB  )rQ   operatorgetitemr%   r   r   )r!  r   getitem_implr=   r}   r7  	src_dtyper-  s      rC   r/  z#fancy_setslice.<locals>.src_getitem  sN    !DC"// )UEJ77 L  <#s444rE   c                      d S rB  r   r   rE   rC   r4  z#fancy_setslice.<locals>.src_cleanup      DrE   c                     S rB  r   )r!  r7  s    rC   r/  z#fancy_setslice.<locals>.src_getitem  s    JrE   c                      d S rB  r   r   rE   rC   r4  z#fancy_setslice.<locals>.src_cleanup  r  rE   c                     g | ]}||S rB  r   )r   r  s     rC   r   z"fancy_setslice.<locals>.<listcomp>  s    999A1=a===rE   r  )5r   rx   r
   r   re   r   r   r  rg  r   r   r   r{   rm  r`  r  r   r   r  r  r  unicode_typer  int64
make_tuplecompile_internalr"   r[  return_dynamic_user_excr   r  r  r   r  r  r:  SequencerQ   r%   r   r   r   r  r   r  r  r   r  r  r;  r   r  ra  )-r}   r=   r[   r   r   r   r   r  r   dest_shapesdest_strides	dest_datar  r  r+  r,  r*  shape_errorur   r  rI  r   r   	src_startsrc_end
dest_lower
dest_upper
dest_startdest_endr.  r/  r4  len_implr  r   dest_indicesr  rm   r!  r   r9  r7  r  r-  s-   ``                                        @@@rC   rN  rN  V  s    hOE1eKCC
*U

GWc
2
2C&w	::K'==LI7GUC&1 1GOO%&& eK	''))j#66('5#)46 6
s)'39==
*7CK@@8 ';3z??2222
K00 	G 	GDAq!++k&-&9&9$1&E&EG GKK __[_77 	M 	MI I I $u{C
OO<<u{C,<,<==? ?C %%gsx{JGG%%gsx{KHHJC **7JSIIC"7GS#>>C55gz7:f7<7I6KM M M	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M( 6gw69:6A8M M	7 ")!:!:<;><"I "I
J5gw6@*6? A  A
H 'wG'18= = $5Wgx5:C5@($L $L [[ 
E5>	*	* ,K	 ''));1$$$$''Yuz5-I-IJJ(7SF++))$AHH__[_77 	M 	MB B B KN+C$U[%+>>C**7JSIIC"7GS#>>C55gz7:f7<7I6KM M M	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M	5 	5 	5 	5 	5 	5 	5 	5 	5	 	 	 	 		 	 	 	 		 	 	 Q//D"..00L& &\\F
 _  a99999N
+n
%
%C ,,wY
<
<C ('9)4l).|495<5O	Q Q QH
 wX666KMMM""$$$s&   ;D	KKKBR00R47R4c                 ~    |j         d         }|j         dd          }|d         }|dd          } fdt          ||          D             }t          j        ||d         j                  }t          j        t
          j        t          |                    }	t          j
        |j        ||	          }
||f}|
|fS )Nr   rG   c                 Z    g | ]'\  }}                     ||t          j                  (S r   r   r   r   )r   rD  r   r=   r}   s      rC   r   z#vararg_to_tuple.<locals>.<listcomp>  sA     . . .C LL#r5:66 . . .rE   r{   r   )r   r   r
   rj   r9   r   r  r   r   r   r%   r   )r}   r=   r[   r   r   dimtysr   rl   re   shapetynew_signew_argss   ``          rC   vararg_to_tupler    s    HQKEXabb\F
q'C8D. . . . .vt,,. . .D wd1gl;;En5:SYY???Gsw??GEzHHrE   zarray.transposec                 H    t          | ||j        d         |d                   S r   )array_Tr   r}   r=   r[   r   s       rC   array_transposer    s     7GSXa[$q':::rE   c                 *   t          |           t          t          |                     k    rt          d          t          |          }| D ]*}||k    st          |          |k    rt          d          +||          |d d <   ||          |d d <   d S )Nzrepeated axis in transposez2axis is out of bounds for array of given dimension)r   r   r   abs)r   re   r   rx  rM  s        rC   permute_arraysr    s    
4yyCD		NN""5666
e**C 0 088s1vv|| / 0 0 0 $ T{E!!!HGAAAJJJrE   c           
          |j         d         } t          |           |d                   }|j         d         |d         }}|j        |j        }	}                     t
          j                  }
t          j        |
|          ||j	        |j
        g}fd|D             }t          ||          D ]\  }}                    ||           t          j        |	dd                               t
          j                             |
                    } fd|D             }t          ||          D ]`\  }}t!          |                    ||
                                                               t
          j        |          g|g|d            a                     t(          t+          j        t
          j                  d |D                         t          |j                             }t!          ||j                            |d                                       |d	                   |j        |j        |j        
           |                                }t?           |j        |          S )Nr   rG   c                 :    g | ]}t          j                  S r   r
   rW   )r   r  r=   ll_ary_sizes     rC   r   z)array_transpose_tuple.<locals>.<listcomp>.  s&    GGGQw"7K88GGGrE   r   r{   rp   r  c                 B    g | ]} t                              S r   rx   )r   r  r=   r}   	np_ary_tys     rC   r   z)array_transpose_tuple.<locals>.<listcomp>9  s.    EEE1$z)$$Wg66EEErE   r   re   r   r   r   c                 6    g | ]}|                                 S r   r   r   as     rC   r   z)array_transpose_tuple.<locals>.<listcomp>I  s     ===akkmm===rE   r_  r8  ) r   rx   r   r{   r   r   r   r   	ArrayTypere   r   r   r  r   r   r|   r   r1  
as_pointerr  r  r   r%   voidr   r   r>   r   r   r   r   r!   )r}   r=   r[   r   r   r   axistyr   num_axisr{   ry  arysll_arysr7  dstnp_itemsizenp_arysnp_aryll_aryrh  r   r  r  s   ``                   @@rC   array_transpose_tupler  !  s   HQKE
*U

GWd1g
6
6C8A;QDFlFLeH$$UZ00G,w11K #)S[)DGGGGG$GGGG g&&    Sc3%a<<<I&&uz'.'='=g'F'FH HK FEEEEEEEEG gw// % %v#OOFG4F4F4H4HII%225:xHHI +} +#	% 	% 	% 	% 	% Wn#-ej.7IO O==W===? ? ? &*S_
%
%gw
7
7C3 gaj11"<<
33L;*& & & & --//CWgsDDDrE   c                 P    t          | |||          \  }}t          | |||          S rB  )r  r  r}   r=   r[   r   r  r  s         rC   array_transpose_varargr  X  s.    '#tDDGX '7HEEErE   c                 x    t          | t          j                  rt          j        d          |dd}ndd}|S )Nz#np.transpose does not accept tuplesc                 *    |                                  S rB  	transposer  axess     rC   np_transpose_implz*numpy_transpose.<locals>.np_transpose_impld  s    ;;== rE   c                 ,    |                      |          S rB  r  r  s     rC   r	  z*numpy_transpose.<locals>.np_transpose_implg  s    ;;t$$$rE   rB  )r   r   rL  r	   r   )r  r  r	  s      rC   numpy_transposer  ^  sc    !U_%% H !FGGG|	! 	! 	! 	! 	!	% 	% 	% 	% rE   Tc                    |j         dk    r|}n t          |          | ||          } t          |          | |          }t          j        ||j        |j                   }t          j        ||j        |j                   }t          ||j        t          j        ||d d d                   t          j        ||d d d                   |j	        |j
        |j                   |                                }t          | |||          S )NrG   r8  )rp   rx   r
   r   re   r   r   r   rj   r   r   r   r   r!   )	r}   r=   r  r  r   r   rh  r  r   s	            rC   r  r  m  s    
x1}}joogw66joogw//%gsy#(CC&wSXFFsH$/"FF&1'744R4=II #"{!j	* 	* 	* 	* mmooWgsC888rE   2   c                 0   t          | t          j                  st          j        d          t          |t          j                  st          j        d          t          |t
          t          j        f          st          j        d          dd}|S )Nz+The first argument "start" must be a numberz+The second argument "stop" must be a numberz+The third argument "num" must be an integerr  c                 X    t          j        | ||          }t          j        d|          S )Ng      $@)rz  linspacepower)r&  r  numrN  s       rC   r   znumpy_logspace.<locals>.impl  s'    KtS))xa   rE   r  )r   r   r  r	   r   r   r   )r&  r  r  r   s       rC   numpy_logspacer    s    eU\** P !NOOOdEL)) P !NOOOcC/00 P !NOOO! ! ! ! KrE   c                    t          | t          j                  sd}t          j        |          t          |t          j                  sd}t          j        |          t          |t
          t          j        f          sd}t          j        |          t          d | |fD                       rDt          t          j
        t          |           t          |          d                     dfd	}ndd}|S )	Nz%The argument "start" must be a numberz$The argument "stop" must be a number%The argument "num" must be an integerc              3   J   K   | ]}t          |t          j                  V  d S rB  r   r   Complexr   r  s     rC   rE  z"numpy_geomspace.<locals>.<genexpr>  .      
C
Cc:c5=))
C
C
C
C
C
CrE   r  c                 :   | dk    s|dk    rt          d           	|           }  	|          }t          dk     rh| j        dk    |j        dk    z  }t          j        |           dk    t          j        |          dk    z  }d}|r| j        } |j        }d}|r	|  } | }| }nt          j        |           }| |z  } ||z  }t          j        |           }t          j        |          }t          j        |||          }|dk    r| |d<   |dk    r||d<   ||z  S )Nr   &Geometric sequence cannot include zeror^  r  rG   y              ?)r   r   realrz  signimaglog10logspace)
r&  r  r  both_imaginaryboth_negativeout_signlogstartlogstopr  result_dtypes
            rC   r   znumpy_geomspace.<locals>.impl  sC   zzTQYY !IJJJ L''E<%%Dv%%"'*/di1n!E!#2!5"'$--2:M N! "!JE9D!H  )"FE 5D (yH75>>! xHhtnnG[7C88F Qww!q	77!%F2Jf$$rE   c                 f   | dk    s|dk    rt          d          t          j        |           dk    t          j        |          dk    z  }d}|r	|  } | }| }t          j        |           }t          j        |          }t          j        |||          }|dk    r| |d<   |dk    r||d<   ||z  S )Nr   r  r  rG   )r   rz  r!  r#  r$  )r&  r  r  r&  r'  r(  r)  r  s           rC   r   znumpy_geomspace.<locals>.impl  s    zzTQYY !IJJJWU^^r1bgdmmr6IJMH %u$9xHhtnnG[7C88F Qww!q	77!%F2Jf$$rE   r  )r   r   r  r	   r   r   r   rF  r   rz  result_typer   )r&  r  r  r   r   r*  s        @rC   numpy_geomspacer-    s   eU\** &5 %%%dEL)) &4 %%%cC/00 &5 %%%

C
CeT]
C
C
CCC :%!".%19$#G #G H H 	%  	%  	%  	%  	%  	%  	%F	% 	% 	% 	%* KrE   rG   c                    t          |t          t          j        f          st	          j        d          t          | t          j                  st	          j        d          | j        dk     rt	          j        d          dd}|S )Nz*The second argument "k" must be an integerz'The first argument "m" must be an arrayr_  Input must be >= 2-d.rG   c                 J   |dz  }|dk    r
| d d          S |dk    r(t          j        t          j        |           dd          S |dk    r&t          j        t          j        |                     S |dk    r(t          j        t          j        | dd                    S t          )N   r   rG   r_     )rz  swapaxesfliplrflipudr  )r  r   s     rC   r   znumpy_rot90.<locals>.impl  s    E66QQQ4K!VV;ry||Q222!VV9RYq\\***!VV9R[Aq11222  rE   r  )	r   r   r   r   r	   r   r   rp   NumbaValueError)r  r   r   s      rC   numpy_rot90r7    s     a#u}-.. O !MNNNa%% L !JKKKvzz$%<===! ! ! ! KrE   c                    |                      t          j                  }|                                }|                      t          j                  }	t          j        |	||||||||	g          }
t          j        |j	        |
d          } ||j
                  }t          j        ||                    d          dd          }t          j        ||                    d          dd          } ||          }t          j        ||dd          }t          j        ||dd          } |	d          }|                    ||||||||j        |g          }|S )a  
    Call into Numba_attempt_nocopy_reshape() for the given array type
    and instance, and the specified new shape.

    Return value is non-zero if successful, and the array pointed to
    by *newstrides* will be filled up with the computed results.
    numba_attempt_nocopy_reshapere   r   r   )r   r   r   r  intcr   FunctionTyper
   get_or_insert_functionr:   rp   rh   rg   callr   )r}   r=   r   r   newndnewshape
newstridesry  ll_intp_starll_intcfntyfnndre   r   
is_f_orderr   s                    rC   _attempt_nocopy_reshaperG    sd    $$UZ00G%%''L$$UZ00G?7||%  D 
	'(F
H 
HB 
		B #*>*>w*G*GANNE"7C,@,@,K,K#$a) )GGENNE#GXq!<<H%gz1a@@JJ
,,rBw!8ZL*6 7 7C JrE   c                 (   d}d}t          |          D ]\  }}|dk     r|dz  }|}||z  }|dk    r| |k    rt          d          d S |dk    r5|dk    r	d}| dk    }n| |z  }| |z  dk    }|st          d          |||<   d S t          d          )Nr   rG   z)total size of new array must be unchangedzmultiple negative shape values)r  r   )	origsizere   num_neg_value
known_sizer0  r   neg_axinferredoks	            rC   normalize_reshape_valuerO    s    MJ5!!  Aq55QMFF!OJJz!!HIII "! 
!		??HQBB:-HJ&!+B 	JHIII f 9:::rE   zarray.reshapec           	      ,   |j         d         }|j        }|j         d         }|d         }|                     t          j                  }t          j        ||j                  }	 t          |          | ||d                   }
t          j
        ||	          }|                    ||           t          j        |j        dd          } t          |          | |          }|                     t          j        |                     |                    }t!          ||                    ||                                          |                     t          j        |j                  g|g|d            |
j        }|                     |t*          t-          j        t          j        t          j        |          ||                                g           |j        }t          j
        ||	          }t7          | |||
|||          }|                    d||                    d                    }|                    |          5  d}| j                             |tB          |f           d d d            n# 1 swxY w Y    t          |          | |          }t!          ||
j"        |#                    |          |#                    |          |
j$        |
j%        |
j&                   |                                }tO          | ||j        |          S )	Nr   rG   r   r  r  r  zincompatible shape for arrayr8  )(r   r   r   r   r   r   r  r   rx   r
   rW   r  r   r{   r   r|   r   r1  r  r   r  rO  r   r%   r  r   r   rG  r  r9   r  r[  r\  rR   r   r>   r   r   r   r!   )r}   r=   r[   r   r   rettyr  re   ry  ll_shaper   r?  shape_ary_ty	shape_aryshape_itemsizer   r>  r@  rN  failr   rh  r   s                          rC   array_reshaperW  ;  s+   HQKEOEhqkGGE$$UZ00G|GW]33H
*U

GWd1g
6
6C "7H55HMM%""" ;W]3GGGL(
<(('::I))%**1*@*@*I*IK KN9'2D2D2F2FGG!..uz7=IIJ*+*! ! ! ! :D W&=#-ej.3k<I I"I$7$7$9$9:< < < ME$Wh77J	 '5#u!):
7 
7B  r2771::66D			 P P,))'3FOOOP P P P P P P P P P P P P P P *U

GW
-
-C3 h//"<<
33L;*& & & & --//CWgsDDDs   %I77I;>I;c                 P    t          | |||          \  }}t          | |||          S rB  )r  rW  r  s         rC   array_reshape_varargrY  |  s.    '#tDDGX'7H===rE   )r_  rG   c                     d }|S )Nc                 ,    |                      |          S rB  reshape)r  r?  s     rC   np_reshape_implz#np_reshape.<locals>.np_reshape_impl  s    99X&&&rE   r   )r  r?  r^  s      rC   
np_reshaper_    s    	' 	' 	'rE   c                     d }|S )Nc                 ,    |                      |          S rB  r\  )r  re   s     rC   r^  z#np_reshape.<locals>.np_reshape_impl  s    99U###rE   r   )r  re   r^  s      rC   r_  r_    s    	$ 	$ 	$rE   c                 (   t          |           sd}t          j        |          t          |t          j                  rt          |j        t          j                  s0t          |t          j                  sd}t          j        |          d }|S )N#The argument "a" must be array-likezBThe argument "new_shape" must be an integer or a tuple of integersc                 8   t          j        |           } t          j        |           } t          |t                    r6d}t          j        |          D ]}||z  }|dk     rd}t          |          n|dk     rd}t          |          |}| j        dk    r,t          j        |                              | j	                  S | | j        z   }| }t          |dz
            D ]}t          j        || f          }|d |         }t          j        ||          S )NrG   r   z0All elements of `new_shape` must be non-negative)rz  r{  ravelr   r   r   r   zerosastyper{   r8   concatenater]  )	r  	new_shapenew_size
dim_lengthr   msg2repeatsr   rm   s	            rC   r   znumpy_resize.<locals>.impl  s-   JqMMHQKKi'' 	!H j33 * *
J&>>LC$S//) "* 1}}I &&& H6Q;;8I&&--ag666I'(w{## 	+ 	+A.#q**CC)8)nz#y)))rE   )r   r	   r   r   r   r  r{   r   )r  ri  r   r   s       rC   numpy_resizern    s     A &3 %%%	5>22 &	77& y%-00	&
% %%%* * *8 KrE   c                    t          |           st          j        d          t          |          st          j        d          t          |          rdd}n2t	          |t
          j                  st          j        d          dd}|S )Nz+The first argument "arr" must be array-likez/The second argument "values" must be array-likec                     t          j        t          j        |                     } t          j        t          j        |                    }t          j        | |f          S rB  )rz  re  r{  rh  r
  valuesr   s      rC   r   znp_append.<locals>.impl  sF    (2:c??++CXbj0011F>3-000rE   z,The third argument "axis" must be an integerc                 2    t          j        | |f|          S Nr   rz  rh  rq  s      rC   r   znp_append.<locals>.impl  s    >3-d;;;;rE   rB  )r   r	   r   r   r   r   r   )r
  rr  r   r   s       rC   	np_appendrw    s     C   P !NOOOF## /  ". / / 	/ 4 <	1 	1 	1 	1 	1 $.. 	0$ &/ 0 0 0	< 	< 	< 	<KrE   zarray.ravelc                     d }d }|j         d         j        dk    r|}n|}|                     ||||          }t          | ||j        |          }|S )Nc                 6    |                      | j                  S )zNo copy version)r]  r   r   s    rC   
imp_nocopyzarray_ravel.<locals>.imp_nocopy  s    {{38$$$rE   c                 *    |                                  S )zCopy version)flattenrz  s    rC   imp_copyzarray_ravel.<locals>.imp_copy  s    {{}}rE   r   r   )r   r  r  r"   r   )r}   r=   r[   r   r{  r~  impr   s           rC   array_ravelr    sw    % % %  
 x{S   

"
"7Cd
;
;C
7GS_c
B
BCJrE   c                 8    d }|                      ||||          S )Nc                 *    |                                  S rB  )re  r  s    rC   np_ravel_implznp_ravel.<locals>.np_ravel_impl  s    wwyyrE   )r  )r}   r=   r[   r   r  s        rC   np_ravelr    s-       ##G]CFFFrE   zarray.flattenc                 j    d }|                      ||||          }t          | ||j        |          }|S )Nc                 Z    |                                                      | j                  S rB  )r\  r]  r   rz  s    rC   r  zarray_flatten.<locals>.imp  s     xxzz!!#(+++rE   )r  r"   r   )r}   r=   r[   r   r  r   s         rC   array_flattenr    sF    , , , 
"
"7Cd
;
;C
7GS_c
B
BCJrE   c                    |t          j        |           n|}t          j        | ||          \  }}}t          j        |j                  D ];}||         }	||         }
||         }t          t          |	|
          |          ||<   <|S rB  )rz  
empty_likebroadcast_arraysndindexre   minr  )r  a_mina_maxr   rh  a_ba_min_ba_max_br   val_a	val_a_min	val_a_maxs               rC   _np_clip_implr  	  s     "k"-


sC/5%@@C'CI&& ; ;E
EN	EN	UI..	::E

JrE   c                     t          j        | j                  D ];}| |         }||         }|rt          ||          ||<   (t	          ||          ||<   <|S rB  )rz  r  re   r  r  )r  buse_minr   r   r  val_bs          rC   _np_clip_impl_noner  	  sf    AG$$ + +%% 	+UE**CJJUE**CJJJrE   c                 6   t          |           st          j        d          t          |t          j                  s#t          |          st          j        d          t          |t          j                  s#t          |          st          j        d          t          |t          j                  s%t          |          sd}t          j        |          |d u pt          |t          j                  }|d u pt          |t          j                  }|r|rdd}|S t          |t          j                  }t          |t          j                  }	|r|	rdd}
|
S |r|	s|rdd}|S dd}|S |s|	r|rdd	}|S dd
}|S |rdd}|S |rdd}|S dd}|S )Nrc  z6The argument "a_min" must be a number or an array-likez6The argument "a_max" must be a number or an array-likez5The argument "out" must be an array if it is providedc                      t          d          )Nz&array_clip: must set either max or minr   r  r  r  r   s       rC   
np_clip_nnznp_clip.<locals>.np_clip_nn6	  s    EFFFrE   c                     |t          j        |           n|}t          j        | j                  D ]+}| |         }t	          t          ||          |          ||<   ,|S rB  )rz  r  r  re   r  r  r  r  r  r   rh  r   r  s          rC   
np_clip_ssznp_clip.<locals>.np_clip_ss?	  sd     '*k"-"""sCAG,, ; ;% UE!2!2E::E

JrE   c                     |t          j        |           n|}t          j        | j                  D ]}| |         }t	          ||          ||<   |S rB  )rz  r  r  re   r  r  s          rC   
np_clip_snznp_clip.<locals>.np_clip_snM	  Z     +.+bmA&&&3Z00 3 3EeHE!$UE!2!2CJJ
rE   c                 P    t          j        | |          }t          | |||          S rB  rz  	full_liker  )r  r  r  r   
a_min_fulls        rC   
np_clip_saznp_clip.<locals>.np_clip_saZ	  s)    
  \!U33
$Q
E3???rE   c                     |t          j        |           n|}t          j        | j                  D ]}| |         }t	          ||          ||<   |S rB  )rz  r  r  re   r  r  s          rC   
np_clip_nsznp_clip.<locals>.np_clip_nse	  r  rE   c                 P    t          j        | |          }t          | |||          S rB  r  )r  r  r  r   
a_max_fulls        rC   
np_clip_asznp_clip.<locals>.np_clip_asr	  s)    
  \!U33
$Qz3???rE   c                     |t          j        |           n|}t          j        | |          \  }}t          ||d|          S )NTrz  r  r  r  )r  r  r  r   rh  r  r  s          rC   
np_clip_naznp_clip.<locals>.np_clip_na~	  sD    *-+bmA&&&3!21e<<W)#wcBBBrE   c                     |t          j        |           n|}t          j        | |          \  }}t          ||d|          S )NFr  )r  r  r  r   rh  r  r  s          rC   
np_clip_anznp_clip.<locals>.np_clip_an	  sD    *-+bmA&&&3!21e<<W)#wsCCCrE   c                 &    t          | |||          S rB  )r  r  s       rC   
np_clip_aaznp_clip.<locals>.np_clip_aa	  s     %Quc:::rE   rB  )	r   r	   r   r   r   NoneTyper   r   r  )r  r  r  r   r   a_min_is_nonea_max_is_noner  a_min_is_scalara_max_is_scalarr  r  r  r  r  r  r  r  s                     rC   np_clipr  	  s   A H !FGGGuen-- 6 ''6  #4 6 6 	6 uen-- 5 ''5  "4 5 5 	5 sEK(( &K,<,< &E %%% TMFZu~%F%FMTMFZu~%F%FM  	G 	G 	G 	G  55O 55O V? V		 		 		 		 	 I I 		 	 	 	 @ @ @ @  1 1 		 	 	 	 @ @ @ @   	C C C C  	D D D D ; ; ; ; rE   clipc                     dd}|S )Nc                 0    t          j        | |||          S rB  )rz  r  r  s       rC   r   zarray_clip.<locals>.impl	  s    wq%,,,rE   NNNr   )r  r  r  r   r   s        rC   
array_clipr  	  s    - - - -KrE   c           	         |j         |j         k    sJ |j        |j        k    sJ t          |j                  }t          d          t          d          t          d          t          j        fd}|                     t          j        t          | |                    }|                     t          j        t          | |                    }|                     t          j        |j                   }	t          j	        ||
                    d          dd          }
t          j	        ||
                    d          dd          }t          j        t          j        dd	          }|                     |          }t          j        ||                     t          j        |j                   g          }|                     |                     t          j                            }|                     t          j        |          }t          j        ||g          } || |          }t!          ||
|||d
            || |          }t!          |||||d
           |                                }|                                }|	|||||                     t          j        |          g}t%          t          j        t          j        ||t          j        t          j        t          j                  }|                     ||||          }t+          ||           t-          | ||j        |          }|S )a  
    Attempt to fix up *ary* for switching from *oldty* to *newty*.

    See Numpy's array_descr_set()
    (np/core/src/multiarray/getset.c).
    Attempt to fix the array's shape and strides for a new dtype.
    False is returned on failure, True on success.
    rZ  r   Fc                 d   |	k    r/|d         |k    r 
          }n|d         |k    r           }||k    r|	k    s| dk    rdS |
k    r| dz
  }nd}||k     r&||z  dk    rdS ||z  }||xx         |z  cc<   |||<   n+||k    r$||         |z  }||z  dk    rdS ||z  ||<   |||<   n	 dS )Nr  r   FrG   Tr   )rE  rl   r   old_itemsizenew_itemsizer  rm   newdim
bytelength
any_layoutc_layoutf_layoutint8s            rC   r  z_change_dtype.<locals>.imp	  s'    Zr{l**h|++h<''Vz-A-AR1WW5XQAAA,&& |+11u!\1FGGGvGGG%GAJJL(( a</J\)a//u L0DG%GAJJ
 trE   re   r   r   rG   r  Nr  )rp   r  ordr   r  r   r   r   r
   rh   rg   r   rx   rj   r|   rz   r   r   r%   booleanr  r   r!   r   )r}   r=   oldtynewtyr   
new_layoutr  r  r  rE  
shape_datastrides_datashape_strides_array_typearyclsshape_constantsizeof_intpstrides_constantrT  strides_aryre   r   r   r[   r   r  r  r  r  s                           @@@@rC   _change_dtyper  	  s@    :####<5<''''U\""JSJ3xxH3xxH:D. . . . . . . .` ''
(4We(D(DF FL''
(4We(D(DF FL 
		ej%*	5	5B%gs/C/CG/L/L&', ,J'(+(<(<Y(G(GAO OL  %{!CPPP 899F')0)=)=ej>Cj*J *J )KL LN (()>)>uz)J)JKKK&&uz;??K)'K=AAw((I9"'+'! ! ! ! &'**K;$'+'! ! ! ! !!E##%%Gwl  Z88:D EMJ,,JJJ C 
"
"7Cd
;
;CeS!!!
GWcos
C
CCJrE   c                 R    t          |           st          j        d          d }|S )Nz+The argument to np.shape must be array-likec                 4    t          j        |           j        S rB  )rz  r{  re   r  s    rC   r   znp_shape.<locals>.impl!
  s    z!}}""rE   r   r	   r   r  r   s     rC   np_shaper  
  s9    A P !NOOO# # #KrE   c                 R    t          |           st          j        d          d }|S )Nz*The argument to np.size must be array-likec                 4    t          j        |           j        S rB  )rz  r{  r   r  s    rC   r   znp_size.<locals>.impl+
  s    z!}}!!rE   r  r  s     rC   np_sizer  &
  s9    A O !MNNN" " "KrE   c                     d }|S )Nc                     t          j        |                                           t          d d                   }fdt	          dd                    D             }t          j        ||z             S )NrG   c                 2    g | ]\  }}|         |k    |S r   r   )r   rm   rM  r  s      rC   r   z5np_unique.<locals>.np_unique_impl.<locals>.<listcomp>7
  s&    <<<da!A$!)))))rE   )rz  sortre  r   r  r   )arheadtailr  s      @rC   np_unique_implz!np_unique.<locals>.np_unique_impl4
  sj    GBHHJJAbqbE{{<<<<i!""..<<<xt$$$rE   r   )r  r  s     rC   	np_uniquer  2
  s    % % %
 rE   c                    d }t          | t          j        t          j        t          j        t          j        t          j        f          r|t          |t          j                  rt          S t          |t          j        t          j        f          r!t          |j	        t          j                  r|S t          j        d          d S )Nc                 N   t          j        |t           j                  }|j        d         dk    rt	          | |d                   S t          j        |dk               rt          d          t          j        |           }|                                }|j        d         }|j        |j        k    rt          d          t          j        t          j	        |          |j
                  }d}t          |          D ]#}||         |||||         z   <   |||         z  }$|S )Nr{   r   rG   r  z(operands could not be broadcast together)rz  r{  r  re   np_repeat_impl_repeats_scalerrF  r   re  emptyr  r{   r8   )	r  rm  repeats_arrayasaaraveln	to_returnposrm   s	            rC   !np_repeat_impl_repeats_array_likez4np_repeat.<locals>.np_repeat_impl_repeats_array_likeA
  s   
7"(;;;q!Q&&0M!4DEEE6-!#$$ 	DBCCCjmmLO<=...:< < <HRVM22#)DDD	q 	$ 	$A6<QiIcC-"2223=##CCrE   zIThe repeats argument must be an integer or an array-like of integer dtype)r   r   r   ListrL  r  r  r   r  r{   r	   r   )r  rm  r  s      rC   	np_repeatr  <
  s    
  , !ekjolm	   1 gu}-- 	900%+uz!:;; 	9'-77 988 01 1 	11 1rE   c                    |dk     rt          d          t          j        |           }|                                }|j        d         }|dk    rt          j        d|j                  S |dk    rt          j        |          S t          j        ||z  |j                  }t          |          D ]}||         |||z  |dz   |z  <   |S )Nr   r  r  rG   )	r   rz  r{  re  re   r  r{   r\  r8   )r  rm  r  r  r  r  rm   s          rC   r  r  i
  s    {{>???
*Q--CYY[[FQA!||x++++	AwvHQ[	:::	q 	C 	CA9?Ia'kQUg$5566rE   repeatc                     d }|S )Nc                 ,    t          j        | |          S rB  )rz  r  )r  rm  s     rC   array_repeat_implz'array_repeat.<locals>.array_repeat_impl}
  s    yG$$$rE   r   )r  rm  r  s      rC   array_repeatr  {
  s    % % % rE   c                 8    t          j        |          }d }||fS )z"Computes the itemsize of the dtypec                     |                      |j        d         j                  }|                      |j                  } ||                     |                    S r   )rz   r   r{   r   r|   )cgctxr=   r[   llargsr~   llintps         rC   rf  z%_intrin_get_itemsize.<locals>.codegen
  sQ    ""38A;#455$$S_55ve**400111rE   )r   r   )tyctxr{   r[   rf  s       rC   _intrin_get_itemsizer  
  s.     *U

C2 2 2 <rE   c                     d S rB  r   )r  r{   s     rC   _compatible_viewr  
      DrE   generic)targetc                     d }|S )zDDetermines if the array and dtype are compatible for forming a view.c                    t          |          }|| j        k    r| j        dk    rd}t          |          	 | j        dz
  }| j        |         dk    }| j        dk    }| j        |         | j        k    }|r|r|rd}t          |          || j        k     r'|dk    s| j        |z  dk    rd}	t          |	          d S | j        |         | j        z  }
|
|z  dk    rd}t          |          d S d S )Nr   zOChanging the dtype of a 0d array is only supported if the itemsize is unchangedrG   zJTo change to a dtype of a different size, the last axis must be contiguouszZWhen changing to a smaller dtype, its size must be a divisor of the size of original dtypezuWhen changing to a larger dtype, its size must be a divisor of the total size in bytes of the last axis of the array.)r  r   rp   r   re   r   r   )r  r{   
dtype_sizemsg1r   p1p2p3rl  msg3r  msg4s               rC   r   z ol_compatible_view.<locals>.impl
  s8   )%00
##v{{7 &&&  6A:D!#B1B4AJ.B 'r 'b '2 &&&AJ&&??aj:&=&B&BID$T*** 'C&B
 3J&!++1D %T***A $#8 ,+rE   r   r  r{   r   s      rC   ol_compatible_viewr  
  s    "+ "+ "+F KrE   z
array.viewc                    |j         d         }|j        } t          |          | ||d                   } t          |          | |          }t          |j        j                  }t          |          D ]Q}	t          ||	          }
|	dk    r(|j        j	        }|
                    |
|          |_        @t          ||	|
           R| j        }|                    t                    }|                    |g |j         R i           }|                     ||          } |||           t#          | ||||          }|                    d|t'          |j	        d                    }|                    |          5  d}| j                            |t.          |f           d d d            n# 1 swxY w Y   |                                }t3          | ||j        |          S )Nr   r   r  z"new type not compatible with array)r   r   rx   r   r   r   sortedgetattrr   r9   r1  r   typing_contextresolve_value_typer  get_call_typerQ   r  r  r   r  r[  r\  r   r   r!   )r}   r=   r[   r   r   rQ  r   rh  fieldsr   r   r)  r  rC  _compatible_view_sigr   rN  rV  r   r   s                       rC   
array_viewr  
  s   HQKEOE
*U

GWd1g
6
6C
*U

GW
-
-C'((FF^^ ! !c1oo;;HMEsE22CHHCC    "E##$455D--e\sx\\2FF&:;;DD$	ws	;	;B  r8BGQ+?+?@@D			 G G2))':vFFFG G G G G G G G G G G G G G G --//CWgsDDDs   <%F--F14F1r{   c                 N    |                                  }t          | |||          S rB  )ra  r#   r}   r=   r  r  r   s        rC   array_dtyper"  
  s'    

!
!
#
#CgwS999rE   re   c                 l    t          |          } || ||          }|j        }t          | |||          S rB  )rx   re   r#   r}   r=   r  r  r   r   r   s          rC   array_shaper%  
  s=     ooGGGWe,,E
+CgwS999rE   r   c                 l    t          |          } || ||          }|j        }t          | |||          S rB  )rx   r   r#   r$  s          rC   array_stridesr'  
  s=     ooGGGWe,,E
-CgwS999rE   rp   c                 p    |                      t          j        |j                  }t	          | |||          S rB  )r   r   r   rp   r#   r!  s        rC   
array_ndimr)  
  s1     

uz38
4
4CgwS999rE   r   c                 l    t          |          } || ||          }|j        }t          | |||          S rB  )rx   r   r#   r$  s          rC   
array_sizer+    s;    ooGGGWe,,E
,CgwS999rE   r   c                 l    t          |          } || ||          }|j        }t          | |||          S rB  )rx   r   r#   r$  s          rC   array_itemsizer-    s=     ooGGGWe,,E
.CgwS999rE   nbytesc                     t          |          } || ||          }|                    |j        |j                  }t	          | |||          S )z"
    nbytes = size * itemsize
    )rx   r   r   r   r#   r$  s          rC   array_nbytesr0    sM     ooGGGWe,,E
++elEN
3
3CgwS999rE   
contiguousc                 p    |                      t          j        |j                  }t	          | |||          S rB  )r   r   r  	is_contigr#   r!  s        rC   array_contiguousr4     s/    


u}cm
<
<CgwS999rE   c_contiguousc                 p    |                      t          j        |j                  }t	          | |||          S rB  )r   r   r  is_c_contigr#   r!  s        rC   array_c_contiguousr8  &  /    


u}co
>
>CgwS999rE   f_contiguousc                 p    |                      t          j        |j                  }t	          | |||          S rB  )r   r   r  is_f_contigr#   r!  s        rC   array_f_contiguousr=  ,  r9  rE   rb  c                 r    |                      t          j        |j                   }t	          | |||          S rB  )r   r   r  mutabler#   r!  s        rC   array_readonlyr@  2  s1    


u}#+o
>
>CgwS999rE   ctypesc                 
   t          |          } || ||          }t          j        |          }|                     ||          }|j        |_        |j        |_        |                                }t          | |||          S rB  )rx   r   ArrayCTypesr   r   r   r   r!   )	r}   r=   r  r  r   r   actctinfor   s	            rC   array_ctypesrF  :  s|    ooGGGWe,,E

C
 
 C  #..F*FK]FN




CWgsC888rE   r   c                     |                      |||          }|j        }|                    ||                     t          j                            }t          | |||          S Nr
  )r   r   r  r   r   r   r#   )r}   r=   r  r  rE  r   s         rC   array_ctypes_datarI  G  s\      #U ;;F
+C


3 6 6uz B B
C
CCgwS999rE   c                     |                      |||          }|j        }|                    ||                     |                    }t	          | |||          S rH  )r   r   r1  r   r#   )r}   r=   fromtytotyr   rE  r   s          rC   array_ctypes_to_pointerrM  P  sZ       & <<F
+C
//#w55d;;
<
<Cgwc:::rE   c                     t          |          |||          }t          j        t          j        |j                  }|                    |                    |j                            }t          t          j	        ||t          j                  }|j
        |j        |                    t          j        |          g}|                    || ||          }	|	S )a)  Helper to invoke the contiguous checker function on an array

    Args
    ----
    checker :
        ``numba.numpy_supports.is_contiguous``, or
        ``numba.numpy_supports.is_fortran``.
    context : target context
    builder : llvm ir builder
    aryty : numba type
    ary : llvm value
    r
  )rx   r   r  r   rp   r|   r   r{   r%   bool_re   r   r   r  )
checkerr}   r=   r   r   tup_intpr   	check_sig
check_argsr3  s
             rC   _call_contiguous_checkrT  Y  s     *U

GWC
8
8
8C~ej%*55H%%g&<&<U[&I&IJJH%+x5:FFI)S[&&uz8<<>J(('9)35 5IrE   r   c                     |                      |t          j        |                    }||_        |                                }| j                            |||           t          | |||          S rB  )r   r   
ArrayFlagsr   r   r   r   r"   )r}   r=   r  r  flagsobjr   s         rC   array_flagsrX  s  sh    ""7E,<S,A,ABBHHO




CKwU+++GWc3777rE   c                    |j         j        dk    r;|                     |||          }t          t          | ||j         |j                  }n0|j         j        dk    }|                     t          j        |          }t          | |||          S )Nr   r
  )
rb   r  r   rT  r   r   r   r   r  r#   )r}   r=   r  r  rW  r   r   s          rC   array_flags_c_contiguousrZ  |  s     ~##&&w5&AA$]GW%(^X_F F n#s*""5=#66gwS999rE   c                 H   |j         j        dk    r;|                     |||          }t          t          | ||j         |j                  }nF|j         j        }|j         j        dk    r|dk    n|dv }|                     t          j	        |          }t          | |||          S )Nr  r
  rG   r  )rb   r  r   rT  r   r   rp   r   r   r  r#   )r}   r=   r  r  rW  r   r  r   s           rC   array_flags_f_contiguousr\    s    
~##&&w5&AA$Z'%(^X_F F &"~2Q66fmmFdN""5=#66gwS999rE   r   c                     |j         t          j        v rt          | |||d          S |j         t          j        v rt          | |||          S t          d                    t          j                             )Nr   attrzunsupported .real for {})	r{   r   complex_domainarray_complex_attrnumber_domainr!   rR   r   r9   )r}   r=   r  r  s       rC   array_real_partrc    sn    
yE(((!'7CVLLLL	e)	)	) '3>>>!"<"C"CDJ"O"OPPPrE   r"  c                 ,   |j         t          j        v rt          | |||d          S |j         t          j        v rt          |                    d          |          }t          | |||g          \  }}t          | |||          }t          j
        ||j        |                    |j        |j                  d           t          | ||j        |                                          S t%          d                    t(          j                             )Nr"  r^  Trk  r   zunsupported .imag for {})r{   r   r`  ra  rb  r%   r\  _parse_empty_like_argsr  r
   memsetr   r   r   r   r"   r   r   rR   r   r9   )r}   r=   r  r  r[   r]  r  r   s           rC   array_imag_partrg    s   
yE(((!'7CVLLLL	e)	)	)$//550'3PPWgw??w'++cl69j+B +BCD	F 	F 	F#/ #1 1 	1 ""<"C"CDJ"O"OPPPrE   c                 2   |dvs|j         t          j        vr"t          d                    |                    t          |          } || ||          }|j         j        }|                     |                     |                    }|j	        
                    |          }	|                     |                                          }
|                    |j        |
          }|dk    r2|                    | t!          j        d          d          g          }|                    |d          } t          |          | |          }t'          ||	          }t)          j        |||           t-          | |||                                          S )	a  
    Given a complex array, it's memory layout is:

        R C R C R C
        ^   ^   ^

    (`R` indicates a float for the real part;
     `C` indicates a float for the imaginary part;
     the `^` indicates the start of each element)

    To get the real part, we can simply change the dtype and itemsize to that
    of the underlying float type.  The new layout is:

        R x R x R x
        ^   ^   ^

    (`x` indicates unused)

    A load operation will use the dtype to determine the number of bytes to
    load.

    To get the imaginary part, we shift the pointer by 1 float offset and
    change the dtype and itemsize.  The new layout is:

        x C x C x C
          ^   ^   ^
    )r   r"  zcannot get attribute `{}`r"      rG   rZ  r{   r  )r   r   )r{   r   r`  rR   r   rx   underlying_floatr|   rz   r   r9   r   r  r1  r   r  r   IntTyper\  r   r
   copy_structr!   r   )r}   r=   r  r  r_  r   r   fltysizeof_fltyr   
llfltptrtyr  resulttyr  repls                  rC   ra  ra    s|   8 ###sy8L'L'L!"="D"DT"J"JKKKooGGGWe,,E 9%D(()>)>t)D)DEEK~"";//H ''--88::Jooej*55G v~~++g
2q(9(9':;; xxd3x//H!Z!!'733FWx000Dt,,,Wgx9I9I9K9KLLLrE   conj	conjugatec                     d }|S )Nc                 *    t          j        |           S rB  )rz  rs  r
  s    rC   r   zarray_conj.<locals>.impl  s    ws||rE   r   r
  r   s     rC   
array_conjry    s      KrE   c                 *    |                                  S rB  )ra  )r}   r=   dtypetydtypevals       rC   
dtype_typer}    s    ""$$$rE   r9   kindstatic_getitemc                     |j         }t          |t          j                  r0 |                     |          d          }t          | |||          S d}t          j        |          )zThis handles the "static_getitem" when a Numba type is subscripted e.g:
    var = typed.List.empty_list(float64[::1, :])
    It only allows this on simple numerical types. Compound types, like
    records, are not supported.
    NzlUnreachable; the definition of __getitem__ on the numba.types.abstract.Type metaclass should prevent access.)r   r   r   r   r   r#   r	   LoweringError)r}   r=   r[   r   rQ  r   r   s          rC   static_getitem_number_clazzr    sk     OE%%% 
( ,g$$U++D11!'7E3???L"3'''rE   c           
          t          |          } | ||          }|j        }t          |t          j                  st          d|d|d          |                    |          }|                    |          }	t          |t          j                  r+|	                    |j        |j
        |j
        z   d          }
n|	                    |d          }
t          |
          } | |          }                     t          j        |	          }t          j        ||j        ||j        j                  }t          |t          j                  rt          j        ||j        |j
                  }| fd|j        D             z  }t          j        ||j        |j
                  }| fd	|j        D             z  }                                          |j                            }n6|j        }|j        }                                          |                    }t-          ||||                     t          j        |          |j        |j        
           |                                }t5           ||
|          S )zq
    Generic getattr() implementation for record arrays: fetch the given
    record member, i.e. a subarray.
    z
attribute z of z not definedrZ  r  rj  )r   c                 P    g | ]"}                     t          j        |          #S r   r   r   r   r   rm   r}   s     rC   r   z(array_record_getattr.<locals>.<listcomp>@  s+    KKK!'&&uz155KKKrE   c                 P    g | ]"}                     t          j        |          #S r   r  r  s     rC   r   z(array_record_getattr.<locals>.<listcomp>C  s+    OOOAG((Q77OOOrE   r8  )rx   r{   r   r   RecordrR   typeofr  NestedArrayr\  rp   r   r   r
   r   r   r9   r   re   r   r|   rz   r   r   r   r   r!   )r}   r=   r  r  r_  r   r   rectyper{   r  restyrarytyraryconstoffset
newdataptrre   r   datasizer   s   `                  rC   array_record_getattrr    s    ooGGGWe,,EiGgu|,, 1!!%)TT333#0 1 1 	1NN4  E^^D!!F%*++ 2+CHuz$9#  G G uS11F6'7##D&&uz6::K$[ty~  J %*++ H$Wek38DDKKKKu{KKKK&wsxHHOOOOOOOO))'*?*?*L*LMM -))'*?*?*F*FGG4""#00XFF =,( ( ( ( ..

CWguc:::rE   c                     |d         }t          |t                    st          t          | ||j        d         |d         |          S r  )r   r  rR   r  r   )r}   r=   r[   r   r   s        rC   array_record_getitemr  V  sC    GEeS!! "!!#(1+tAwNNNrE   c           
      d                          ||           |                    |          }|                    |          }t          |t          j                  rt          |          } | |          }|j        }	 fd|j        D             }
 fd|j	        D             }t          j        |||                     |	                    }t          ||t          j        ||
          t          j        ||                               t          j        |j                  dd           |                                }t'           |||          S t          j        |||                     |                    }|j        rdnd}                     ||||          }t'           |||          S )zT
    Generic getattr() implementation for records: get the given record member.
    c                 P    g | ]"}                     t          j        |          #S r   r  r   r   r}   s     rC   r   z"record_getattr.<locals>.<listcomp>n  s7     " " "AG((Q77 " " "rE   c                 P    g | ]"}                     t          j        |          #S r   r  r  s     rC   r   z"record_getattr.<locals>.<listcomp>p  s7     & & &ag**5:q99 & & &rE   Nr8  rG   )sentry_record_alignmentr  r  r   r   r  rx   r{   re   r   r
   get_record_memberrz   r   rj   r   r   r   r   r!   r   r   )r}   r=   r  r  r_  r  elemtyr   r   r{   r?  r@  newdatar   dptrr   s   `               rC   record_getattrr  _  s   
 ##C...ZZFZZF&%+,, = 6""eGW%%" " " "L" " "& & & &n& & &
+GUF,3,A,A%,H,HJ J$Wh77&w
;;))%*fkBB	
 	
 	
 	
 mmoo '3<<<(%)0)>)>v)F)FH H*""7FD%@@ '3<<<rE   c           	         |j         \  }}|\  }}|                     ||           |                    |          }	|                    |          }
t	          |
t
          j                  r t          j        |          | ||d                   }|j	        }t          j
        |||	|j        j                  }t          j        ||||                     t
          j        |
j                             dS t          j
        |||	|                     |
                    }|                     ||||
          }|j        rdnd}|                     ||
|||           dS )zT
    Generic setattr() implementation for records: set the given record member.
    rG   r
  Nr   )r   r  r  r  r   r   r  r
   rw   r   r  r9   pointeememcpyr   r   r   rz   r   r   r   )r}   r=   r[   r   r_  r  rO  r  r   r  r  
val_structr7  re  r  r   s                   rC   record_setattrr    su   
 JCKFC##C...ZZFZZF&%+,, D7W077>B1gG G G
o(&&),)9; ;wc++EJFF	H 	H 	H 	H 	H (&&)0)>)>v)F)FH Hll7C77*7FCUCCCCCrE   c                     |                      |j        d         |d                   } || ||j        d         |d         |d                   S )3
    Record.__getitem__ redirects to getattr()
    r   rG   )get_getattrr   )r}   r=   r[   r   r   s        rC   record_static_getitem_strr    sI    
 sx{DG44D4#(1+tAwQ@@@rE   c                 4   |j         d         j        }t          |j         d         j                  }|                     |j        ||                   }|                     |j         d         |          } || ||j         d         |d         ||                   S )r  rG   r   )r   r   r   r  insert_const_stringr:   r  )r}   r=   r[   r   r   r  ll_fieldr   s           rC   record_static_getitem_intr    s    
 (1+
#C#(1+$%%F**7>6#;GGHsx{H55D4#(1+tAwsDDDrE   static_setitemc                     |j         \  }}}|\  }}}	t          |j        ||          }
|                     ||
          }|J  ||||	f          S )3
    Record.__setitem__ redirects to setattr()
    )r   r%   r   get_setattr)r}   r=   r[   r   rectyr  rO  recr   r   getattr_sigr   s               rC   record_static_setitem_strr    sf    
 hOE1eMCcCOUE::KsK00D4#s$$$rE   c                     |j         \  }}}|\  }}}	t          |j        ||          }
t          |j         d         j                  }|                     ||         |
          }|J  ||||	f          S )r  r   )r   r%   r   r   r  r  )r}   r=   r[   r   r  r  rO  r  r   r   r  r  r   s                rC   record_static_setitem_intr    s    
 hOE1eMCcCOUE::K#(1+$%%Fvc{K88D4#s$$$rE   c                 0    |                      |||          S )zB
    Create a constant array (mechanism is target-dependent).
    )make_constant_array)r}   r=   rD  pyvals       rC   constant_arrayr    s    
 &&wE:::rE   c                     t          j        t          j        d          |j                  } |t	          |                                                    }t          j        ||          S )zG
    Create a record constant as a stack-allocated array of bytes.
       )r   r  rl  r.  	bytearraytostringr
   r   )r}   r=   rD  r  ltyr   s         rC   constant_recordr    sS    
 ,rz!}}el
3
3C
#i(())
*
*C$Wc222rE   c                     t          j        t          |          t           j                  }|                     |||          S )zM
    Create a constant array from bytes (mechanism is target-dependent).
    r  )rz  r   r  uint8r  )r}   r=   rD  r  bufs        rC   constant_bytesr    s:    
 (9U##28
4
4
4C&&wC888rE   c                 p    |j         \  }}||k    rt          j        S d }|                     ||||          S )Nc                 v    | j         |j         k    o)| j        |j        k    o| j        j        |j        j        k    S rB  )re   r   rA  r   r  r  s     rC   array_is_implzarray_is.<locals>.array_is_impl  s9    17" /	QY&/.	0rE   )r   r
   r  r  )r}   r=   r[   r   atybtyr  s          rC   array_isr    sJ    xHC
czz  0 0 0
 ##G]CFFFrE   __hash__c                     d S )Nc                     d S rB  r   rw  s    rC   r  zol_array_hash.<locals>.<lambda>
  s    t rE   r   rw  s    rC   ol_array_hashr    s    rE   c                 "    t          | d          S )zq
    Return the Structure representation of the given *flatiterty* (an
    instance of types.NumpyFlatType).
    flat_make_flattening_iter_cls)
flatitertys    rC   make_array_flat_clsr    s    
 %Z888rE   c                 "    t          | d          S )zv
    Return the Structure representation of the given *nditerty* (an
    instance of types.NumpyNdEnumerateType).
    ndenumerater  nditertys    rC   make_array_ndenumerate_clsr    s    
 %X}===rE   c                 T   |                      t          j        d          }|                    d          }	| |                    t
          j        |           t          t          |                    D ]}
t          j	        |||
          }t          j
        ||                    |                    }||
         }|                    d||          }t          j        ||          5  |                    ||           | ||
           |                    |	           d d d            n# 1 swxY w Y   |                    ||           | ||
           | |                    t
          j        |           |                    |	           |                    |	           d S )Nr   end_incrementr  )r   r   r   r|  r  r
   
false_byter  r8   rh   r  r>   r  	if_likelyr  	true_byter  )r}   r=   rp   re   r   end_flagloop_continue
loop_breakr   bbendrx  idxptrr   r   	in_boundss                  rC   _increment_indicesr     s   
A..D&&77Eg((333d$$  %gw<<%gw||F/C/CDDc
''S%88	w	22 	" 	"MM#v&&&(c"""NN5!!!	" 	" 	" 	" 	" 	" 	" 	" 	" 	" 	" 	" 	" 	" 	" 	dF###!JsOOOg'222NN5E"""""s   (9D--D1	4D1	c                 x    t          j        ||j        |j                  }t	          | ||j        |||           d S rB  )r
   r   re   rp   r  )r}   r=   r	  r
  r   r  re   s          rC   _increment_indices_arrayr  A  s:     #)UZ@@EwUGXNNNNNrE   c                    	
  j         
 j        t           j                  	 j        r
nd G d dt
                    } G d d|           G  fdd|           G d d	|           G d
 d|           G d d|           G 	
 f
ddt          j                             }|S )zq
    Return the Structure representation of the given *nditerty* (an
    instance of types.NumpyNdIterType).
    rG   c                   P    e Zd ZdZd Zd Zej        d             Zd Z	d Z
d ZdS )	$make_nditer_cls.<locals>.BaseSubIterzF
        Base class for sub-iterators of a nditer() instance.
        c                 R    || _         || _        || _        || _        ||z
  | _        d S rB  )nditermember_name	start_dimend_dimrp   )rY   r  r  r  r  s        rC   rz  z-make_nditer_cls.<locals>.BaseSubIter.__init__V  s/     DK*D&DN"DL)+DIIIrE   c                 <    t          | j        | j        |           d S rB  )r   r  r  )rY   rk   s     rC   set_member_ptrz3make_nditer_cls.<locals>.BaseSubIter.set_member_ptr]  s    DK!1377777rE   c                 6    t          | j        | j                  S rB  )r  r  r  rf  s    rC   
member_ptrz/make_nditer_cls.<locals>.BaseSubIter.member_ptr`  s    4;(8999rE   c                     d S rB  r   )rY   r}   r=   s      rC   init_specificz2make_nditer_cls.<locals>.BaseSubIter.init_specificd  r  rE   c                     d S rB  r   rY   r}   r=   logical_dims       rC   r  z2make_nditer_cls.<locals>.BaseSubIter.loop_continueg  r  rE   c                     d S rB  r   r  s       rC   r  z/make_nditer_cls.<locals>.BaseSubIter.loop_breakj  r  rE   N)rq   rr   rs   rt  rz  r  r>  cached_propertyr  r  r  r  r   rE   rC   BaseSubIterr  Q  s        	 		, 	, 	,	8 	8 	8 
	"	: 	: 
#	"	:	 	 		 	 		 	 	 	 	rE   r  c                   *    e Zd ZdZd Zd Zd Zd ZdS )$make_nditer_cls.<locals>.FlatSubIterz
        Sub-iterator walking a contiguous array in physical order, with
        support for broadcasting (the index is reset on the outer dimension).
        c                     |                     t          j        d          }|                     t	          j        ||                     d S r   )r   r   r   r  r
   r   )rY   r}   r=   r   s       rC   r  z2make_nditer_cls.<locals>.FlatSubIter.init_specifics  s@    ''
A66D 9'4 H HIIIIIrE   c                 n    |                     | j                  }|                    |j        |g          S rB  )r>   r  r  r   )rY   r}   r=   r   r	  r
  r   s          rC   compute_pointerz4make_nditer_cls.<locals>.FlatSubIter.compute_pointerw  s-    LL11E;;sx%111rE   c                     || j         dz
  k    rL|                    | j                  }t          j        ||          }|                    || j                   d S d S r  )rp   r>   r  r
   r  r  )rY   r}   r=   r  r   s        rC   r  z2make_nditer_cls.<locals>.FlatSubIter.loop_continue{  s\    di!m++T_55/??eT_55555	 ,+rE   c                 @   |dk    r=|                     t          j        d          }|                    || j                   d S || j        dz
  k    rL|                    | j                  }t          j        ||          }|                    || j                   d S d S Nr   rG   )	r   r   r   r  r  rp   r>   r
   r  )rY   r}   r=   r  r   r   s         rC   r  z/make_nditer_cls.<locals>.FlatSubIter.loop_break  s    a++EJ::dDO44444	A--T_55/??eT_55555	 .-rE   N)rq   rr   rs   rt  r  r   r  r  r   rE   rC   FlatSubIterr  m  s]        	 	
	J 	J 	J	2 	2 	2	6 	6 	6		6 		6 		6 		6 		6rE   r  c                   $    e Zd ZdZ fdZd ZdS )+make_nditer_cls.<locals>.TrivialFlatSubIterzx
        Sub-iterator walking a contiguous array in physical order,
        *without* support for broadcasting.
        c                     j         rJ d S rB  )need_shaped_indexing)rY   r}   r=   r  s      rC   r  z9make_nditer_cls.<locals>.TrivialFlatSubIter.init_specific  s    444444rE   c                     t          |          dk    sJ t          |                      |                    |j        |          S r  )r   r  r   rY   r}   r=   r   r	  r
  s         rC   r   z;make_nditer_cls.<locals>.TrivialFlatSubIter.compute_pointer  s=    w<<1$$$c'll$$$;;sx111rE   N)rq   rr   rs   rt  r  r   r  s   rC   TrivialFlatSubIterr    sG        	 	
	5 	5 	5 	5 	5	2 	2 	2 	2 	2rE   r  c                       e Zd ZdZd ZdS )'make_nditer_cls.<locals>.IndexedSubIterzA
        Sub-iterator walking an array in logical order.
        c                 j    t          |          | j        k    sJ t          j        |||||d          S NFr  )r   rp   r
   r*  r
  s         rC   r   z7make_nditer_cls.<locals>.IndexedSubIter.compute_pointer  sF    w<<49,,,,+GWeS,3G G G GrE   Nrq   rr   rs   rt  r   r   rE   rC   IndexedSubIterr    s2        	 		G 	G 	G 	G 	GrE   r  c                       e Zd ZdZd ZdS )'make_nditer_cls.<locals>.ZeroDimSubIterz5
        Sub-iterator "walking" a 0-d array.
        c                     |j         S rB  )r   r
  s         rC   r   z7make_nditer_cls.<locals>.ZeroDimSubIter.compute_pointer  s	    8OrE   Nr  r   rE   rC   ZeroDimSubIterr    s-        	 		 	 	 	 	rE   r  c                       e Zd ZdZd ZdS )&make_nditer_cls.<locals>.ScalarSubIterz8
        Sub-iterator "walking" a scalar value.
        c                     |S rB  r   r
  s         rC   r   z6make_nditer_cls.<locals>.ScalarSubIter.compute_pointer  s    JrE   Nr  r   rE   rC   ScalarSubIterr    s-        	 		 	 	 	 	rE   r  c                      
 e Zd ZdZej         fd            Z	fdZfdZd Z	d Z
	fdZd Zd	 Zd
S )make_nditer_cls.<locals>.NdIterz
        .nditer() implementation.

        Note: 'F' layout means the shape is iterated in reverse logical order,
        so indices and shapes arrays have to be reversed as well.
        c           	          g }j         rnd}t          j                  D ]:\  }}|\  }}}}d|z  }	||         }
|                     |
| |	||                     ;|S )N)r  indexed0dscalarzindex%d)r  r  r  ri   )rY   l	factoriesrm   r  r~  r  r  r  r  factoryr  r  r  r  r  r  s              rC   subitersz(make_nditer_cls.<locals>.NdIter.subiters  s    A080M "10$2-#0	 I $H$566 I I3.1+i!'!m#D/{IwGGHHHHHrE   c                    |                     t          j        d          }|                    |t          j        |          |          | _        t          |          D ]P\  }}t          |t          j                  s1d|z  }t          j
        |||                   }	t          | ||	           Q|                     ||||          }t          j        t          j                  }
d}d}t          |          D ]F\  }}t          |t          j                  r'|j        k    r||         j        }||         j        } n@Gdk    sJ |                    ||
d          }|                     t          j        d          }d }t#          ||          D ]\  }}t          |t          j                  rg|j        dk    r\t%          t          j        t          j        t          j        |j                  |
          }|                    ||||j        |f           t          j        ||          }dk    r|ddd         }|                    d	||          }|                    |t          j        t          j                  }j        s|f}t7          |          k    sJ t          j        ||j        
          }t=                    D ].}t          j        |||          }|                     ||           /|| _!        t          j"        |||j                  | _        t          j
        ||          | _#        | j$        D ]}|%                    ||           dS )zY
            Initialize the nditer() instance for the specific array inputs.
            r   scalar%dNr   rG   c                     t          |           }t          |          D ]6}| |         |t          |          |z
  |z            k    rt          d          7d S )Nz2nditer(): operands could not be broadcast together)r   r8   r   )re   
main_shaper  rm   s       rC   check_shapezBmake_nditer_cls.<locals>.NdIter.init_specific.<locals>.check_shape  sm    JJq ? ?AQx:c*oo.AA.E#FFF( *> ? ? ? G? ?rE   r  r  r  r  )&r   r   r   r  r  arraysr  r   r   r
   r   r   _arrays_or_scalarsr  rp   re   r   r   r%   noner  r   r  r  r  r  r  r   rW   r9   r8   rh   r  r   rj   	exhaustedr#  r  )rY   r}   r=   arrtysr)  r   rm   rD  r  slotmain_shape_tyr'  main_nitemsr	  r(  r
  r[   r  shape_is_emptyr,  r   rx  r  subiterr  rp   r  nshapess                           rC   r  z-make_nditer_cls.<locals>.NdIter.init_specific  sr    ''
A66D ",,Wek&6I6I-35 5DK #6** 5 52!"ek22 5",q.K"4WfQiHHDD+t444,,WgvvNNF "N5:t<<MJK%f-- 	B 	B5eU[11 ejD6H6H!'J"()"2KE qyyyy$//KK
%225:qAA? ? ? "&&11 K K
seU[11 Kej1nn#EJ$)N5:uz$J$J$13 3C ,,Wk-039j2IK K K )':>>F}}" %00{DIIN~w7H'.'9; ;I 0 ( &v;;')))))'497KKKGW~~ , , -gwDDdF++++"DL +GVTYGGDJ$6w	JJDN  = 8 8%%gw77778 8rE   c                 &   |                     d          }t          j        ||                    | j                            }t          j        ||          5  |                    d           |                    |           ddd           n# 1 swxY w Y   j        }t          j	        || j                  }| 
                    ||||          }| j        }|                    d           |                     |||||          }	d |	D             }	t          |	          dk    r|                    |	d                    n/|                    |                    |j        |	                     t          j	        || j                  }
t%          ||t          |
          |
|| j        t'          j        | j        ||          t'          j        | j        ||                     |                    |           |                    |           dS )zJ
            Compute next iteration of the nditer() instance.
            r  FNTc                 6    g | ]}|                                 S r   r  r   r   s     rC   r   zEmake_nditer_cls.<locals>.NdIter.iternext_specific.<locals>.<listcomp>0  s     222qQ[[]]222rE   rG   r   )r|  r
   as_bool_bitr>   r,  if_unlikelyr  r  r)  r   r*  r   _make_viewsr   r  r  r  re   r  r>  partial_loop_continue_loop_breakr  )rY   r}   r=   r  r  r,  r-  r)  r   viewsre   r  s              rC   iternext_specificz1make_nditer_cls.<locals>.NdIter.iternext_specific  sM    ..u55E  +G,3LL,H,HJ JI$Wi88 & &  '''u%%%& & & & & & & & & & & & & & & _F)'4;??F,,WgvvNNFlG T"""$$WgwOOE22E222E5zzQeAh''''g00(:M168 8 9 9 9 ($*==EwUU&(01D1818 :  :  )01A1818 :  :! ! ! NN5!!!##E*****s   +BBBc                     | j         D ];}|j        |cxk    r|j        k     r"n |                    ||||j        z
             <d S rB  )r#  r  r  r  rY   r}   r=   rx  r  s        rC   r;  z.make_nditer_cls.<locals>.NdIter._loop_continueE  sg    } M M=C5555#+55555%%gwcm8KLLLM MrE   c                     | j         D ];}|j        |cxk    r|j        k     r"n |                    ||||j        z
             <d S rB  )r#  r  r  r  r@  s        rC   r<  z+make_nditer_cls.<locals>.NdIter._loop_breakJ  se    } J J=C5555#+55555NN7GS3=5HIIIJ JrE   c                    dgz  }j         }| j        }j        }	t          |	t          j                  rt          |	          }	n|	g}	fdt                    D             t          ||          D ]p\  }
}|
\  }}}}|j	        |j
                 }dk    r|ddd         }|D ]<}||         J |                     |||	|         ||         ||         |          ||<   =qt          d |D                       sJ |S )z:
            Compute the views to be yielded.
            Nc           	      b    g | ]+}                     t          j        |                    ,S r   r>   r
   rh   )r   rm   r=   r   s     rC   r   z?make_nditer_cls.<locals>.NdIter._make_views.<locals>.<listcomp>[  sD     0 0 0 ||G$8'1$M$MNN 0 0 0rE   r  r  c              3      K   | ]}|V  d S rB  r   r6  s     rC   rE  z>make_nditer_cls.<locals>.NdIter._make_views.<locals>.<genexpr>h  s"      ((Qq((((((rE   )r  r#  r  r   r   rL  r   r8   r   r  r  
_make_viewr  )rY   r}   r=   r   r-  r)  r=  r  r#  rettysr  r2  r  array_indicessub_indicesrm   r  narraysr  r3  s     ``            rC   r9  z+make_nditer_cls.<locals>.NdIter._make_viewsO  si    FW$E(H}H(F&%/22 "f 0 0 0 0 0 %g0 0 0G !$Hh 7 7 	N 	NW),&1a%g&7&GHS=="-ddd"3K& N NA 8+++#w/5ay/5ay&)W N  NE!HHN
 ((%((((((((LrE   c                    t          |t          j                  r|j        dk    sJ |                    |||||          } |                    |          ||          }	t          ||          }
|                    |t          j        t          j	        d          d          }|                    |t          j        t          j	        d          d          }t          |	||||
d           |	S )zD
            Compute a 0d view for a given input array.
            r   r   N)r   )r   r   r   rp   r   rx   r   r  r  r   r   )rY   r}   r=   r   rQ  r	  r
  r2  rk   viewr   re   r   s                rC   rF  z*make_nditer_cls.<locals>.NdIter._make_viewk  s    
 eU[11EejAoooo))'7GUCPPC,7%%e,,Wg>>D#GU33H&&wuz10M0M')+ +E((%.Q2O2O)+- -G 4eWhMMMMKrE   c                 @   g }t          t          ||                    D ]}\  }\  }}t          |t          j                  r5|                     |                    |          |||                     W|                    t          | d|z                       ~|S )Nr
  r%  )r  r   r   r   r   ri   rx   r  )	rY   r}   r=   r-  r)  r   rm   r	  r
  s	            rC   r*  z2make_nditer_cls.<locals>.NdIter._arrays_or_scalars  s     A#,S-@-@#A#A < <<E3eU[11 <HH6W//66w7>=@B B B C C C C HHWT:>::;;;;HrE   N)rq   rr   rs   rt  r>  r  r#  r  r>  r;  r<  r9  rF  r*  )
r  r  r  r  r  r  rJ  rp   r  r3  s
   rC   NdIterr    s       	 	 
	"	 	 	 	 	 	 	 	 	 
#	"	M	8 M	8 M	8 M	8 M	8 M	8 M	8 M	8^(	+ (	+ (	+ (	+ (	+T	M 	M 	M
	J 	J 	J
	 	 	 	 	 	 	 	8	 	 	(	 	 	 	 	rE   rN  )rp   r  r   r)  r  objectr
   rw   )r  r  rN  r  r  r  r  r  r  rJ  rp   r3  s   `  @@@@@@@@@rC   make_nditer_clsrP  G  s   
 =D_F(/""G3:ddG    f   86 6 6 6 6k 6 6 6@2 2 2 2 2 2 2[ 2 2 2G G G G G G G G              V V V V V V V V V V V V V V V V,X66 V V Vp MrE   c                 Z    | j          G fddt          j        |                     }|S )zr
    Return the Structure representation of the given *nditerty* (an
    instance of types.NumpyNdIndexType).
    c                   (    e Zd ZdZ fdZ fdZdS )%make_ndindex_cls.<locals>.NdIndexIterz,
        .ndindex() implementation.
        c                    |                     t          j        d          }t          j        ||j        |                     t          j                            }t          j        |t          j                  }t                    D ]}t          j	        |||          }|
                    ||           ||         }	|                    d|	|          }
t          j        ||
          5  |
                    t          j        |           d d d            n# 1 swxY w Y   || _        || _        t          j        |||j                  | _        d S Nr   r  r  )r   r   r   r
   rW   r9   r   r  r8   rh   r  r  r8  r  r   r,  rj   re   )rY   r}   r=   r  r   r   r,  rx  r  r  dim_is_emptyrp   s              rC   r  z3make_ndindex_cls.<locals>.NdIndexIter.init_specific  s   ''
A66D)'49/6/C/CEJDH0J 0JK K KG  1'7;MNNIT{{ 	@ 	@ -gwDDdF+++ "#;&44T8TJJ(,?? @ @MM'"3Y???@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ #DL&DN +GVTYGGDJJJs   ,!DD	 D	c                 ,    |                     t          j        d          }                    d          }t	          j                             j                            }t	          j        |          5  |	                    d           
                    |           d d d            n# 1 swxY w Y    fdt          
          D             }|D ]}t          |           |                    t	          j        ||j                             |	                    d           t	          j         j        
          }	t%          |
|	 j         j                   
                    |                               |           d S )Nr   r  Fc           	      l    g | ]0}                     t          j        j        |                    1S r   )r>   r
   rh   r   )r   rx  r=   rY   s     rC   r   zKmake_ndindex_cls.<locals>.NdIndexIter.iternext_specific.<locals>.<listcomp>  sR     / / /  ||G$89=9<%> %> ? ? / / /rE   T)r   r   r   r|  r
   r7  r>   r,  r8  r  r  r8   rI   r  rj   r9   r   re   r  r   r  )rY   r}   r=   r  r   r  r,  r   r>   re   rp   s   ` `       rC   r>  z7make_ndindex_cls.<locals>.NdIndexIter.iternext_specific  s   ''
A66D..u55E+G,3LL,H,HJ JI$Wi88 & &  '''u%%%& & & & & & & & & & & & & & &/ / / / / #(++/ / /G   - -gt,,,,MM',WgtyIIJJJT"""($*dCCEwu#|T^= = = NN5!!!##E*****s   ;+B22B69B6N)rq   rr   rs   rt  r  r>  rp   s   rC   NdIndexIterrS    sV        	 		H 	H 	H 	H 	H,	+ 	+ 	+ 	+ 	+ 	+ 	+rE   rZ  )rp   r
   rw   )r  rZ  rp   s     @rC   make_ndindex_clsr[    sT    
 =D5+ 5+ 5+ 5+ 5+ 5+ 5+g1(;; 5+ 5+ 5+n rE   c                     dv sJ | j         }|j        dk    r$ G fddt          j        |                     }|S  G fddt          j        |                     }|S )N)r  r  r   c                   4    e Zd ZdZ fdZ fdZd Zd ZdS )6_make_flattening_iter_cls.<locals>.CContiguousFlatIterzZ
            .flat() / .ndenumerate() implementation for C-contiguous arrays.
            c                    |                     t          j        d          }t          j        ||          | _        |j        | _        	dk    rt          j        ||j	        |                     t          j        |j
                            }t          |j
                  D ].}t          j        |||          }|                    ||           /|| _        d S d S )Nr   r  r  )r   r   r   r
   r   r   r   r  rW   r9   rp   r8   rh   r  r   )
rY   r}   r=   r	  r
  r   r   rx  r  r~  s
            rC   r  zD_make_flattening_iter_cls.<locals>.CContiguousFlatIter.init_specific  s    ++EJ::$6wEE
 "l=((%1$11%*ejIIK K KG  %UZ00 4 4!(!5gw!L!LdF3333#*DLLL )(rE   c                    |j         }|j        }                    | j                  }                    d||          }	|                    |	           t          j        |	          5                      |j	        |g          }
t          |||
          }dk    r|                    |           nu| j        fdt          |          D             }t          j        |          }|                    t          j        ||g                     t!          |||           t          j        |          }                    || j                   d d d            d S # 1 swxY w Y   d S )Nr  r  c           	      b    g | ]+}                     t          j        |                    ,S r   rD  r   rx  r=   r   s     rC   r   z\_make_flattening_iter_cls.<locals>.CContiguousFlatIter.iternext_specific.<locals>.<listcomp>  sT     #; #; #; (+ $+<<0DWELEH1J 1J $K $K #; #; #;rE   )rp   r   r>   r   r  r  r
   r  r  r   r   r  r   r8   rj   make_anonymous_structr  r  r  )rY   r}   r=   r	  r
  r  rp   r   r   r  rk   r  idxvalsidxtupler   r~  s     `           @rC   r>  zH_make_flattening_iter_cls.<locals>.CContiguousFlatIter.iternext_specific  s   zTZ00"..sE6BB  ***&w99 5 5!++ch88C%gwsCCEv~~e,,,, #',#; #; #; #; #; /4Dkk#; #; #; $+#5gw#G#G#9';CU:KM MN N N 1'514g? ? ? $3GUCCEMM%444)5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5s   -C0E**E.1E.c                 ^    |                     |j        |g          }t          ||||          S rB  )r  r   r   rY   r}   r=   r	  r
  r   rk   s          rC   r  z>_make_flattening_iter_cls.<locals>.CContiguousFlatIter.getitem  s-    kk#(UG44 '5#>>>rE   c                 d    |                     |j        |g          }t          |||||           d S rB  )r  r   r   rY   r}   r=   r	  r
  r   r  rk   s           rC   setitemz>_make_flattening_iter_cls.<locals>.CContiguousFlatIter.setitem  s5    kk#(UG447GUE3?????rE   N)rq   rr   rs   rt  r  r>  r  rj  r~  s   rC   CContiguousFlatIterr^    st         + + + + +25 5 5 5 5<? ? ?@ @ @ @ @rE   rl  c                   6    e Zd ZdZd Z fdZd Zd Zd ZdS )+_make_flattening_iter_cls.<locals>.FlatIterz
            Generic .flat() / .ndenumerate() implementation for
            non-contiguous arrays.
            It keeps track of pointers along each dimension in order to
            minimize computations.
            c                    |                     t          j        d          }|j        }|j        }t          j        ||j        |          }t          j        ||j	        |                     t          j        |j                            }	t          j        ||j	        |                     t          j        |j                            }
t          j
        |t
          j                  }t          |          D ]}t          j        ||	|          }t          j        ||
|          }|                    ||           |                    ||           ||         }|                    d||          }t          j        ||          5  |                    t
          j        |           d d d            n# 1 swxY w Y   |	| _        |
| _        || _        d S rU  )r   r   r   r   rp   r
   r   re   rW   r9   r   r  r8   rh   r  r  r8  r  r   pointersr,  )rY   r}   r=   r	  r
  r   r   rp   r  r   rp  r,  rx  r  ptrptrr  rV  s                    rC   r  z9_make_flattening_iter_cls.<locals>.FlatIter.init_specific%  s   ++EJ::xz -gsy$GG!-TYW-A-A%*BG*.N .NO O O #.TYW-A-A%*BG*.N .NO O O $5g6=6HJ J	 !;; D DC$1'7CHHF$1'8SIIFMM$///MM$///  &c{H#*#8#8x#N#NL ,WlCC D Dg&7CCCD D D D D D D D D D D D D D D  ' (!*s   !F11F5	8F5	c                 d   |j         }t          j        |j        |          }t          j        |j        |          }| j        | j        }	|                    t          j	        d          }

                    d          }t          j                            | j                            }t          j        |          5  |                    d                               |           d d d            n# 1 swxY w Y   |                    d           t          j        |	|dz
            }                    |          }t%          |||          }dk    r|                    |           n[fdt)          |          D             }t          j        |          }|                    t          j        ||g                     t/          t)          |                    D ]o}t          j        |          }t          j                            |                    }||         }||         }                    d||          }t          j        |          5                      ||           t          j        |	|          }                    |          }t          j        ||          }                    ||           t)          |dz   |          D ].}t          j        |	|          }                    ||           /                    |           d d d            n# 1 swxY w Y                       |
|           q                    t          j        | j                                       |                               |           d S )	Nr   r  FTrG   r  c           	      b    g | ]+}                     t          j        |                    ,S r   rD  rb  s     rC   r   zQ_make_flattening_iter_cls.<locals>.FlatIter.iternext_specific.<locals>.<listcomp>a  sT     7 7 7 $'  '||G,@AHAD-F -F  G  G 7 7 7rE   r  )rp   r
   r   re   r   r   rp  r   r   r   r|  r7  r>   r,  r8  r  r  rh   r   r  r8   rj   rc  r  r  r  r  r  r   r  r  )rY   r}   r=   r	  r
  r  rp   r  r   rp  r   r  is_exhaustedlast_ptrrk   r  rd  re  rx  r  r   r   r  r  rq  	inner_dimr   r~  s     `                       @rC   r>  z=_make_flattening_iter_cls.<locals>.FlatIter.iternext_specificF  s%   z -gsy$GG!.wTJJ,=++EJ::22599  '2W\\$.99 ;  ;(,?? * *$$U+++NN5)))* * * * * * * * * * * * * * *   &&& #/4!8LLll8,,!'7E3??6>>MM%((((7 7 7 7 7 +0++7 7 7G  '1'7CCHMM5g7?6GI IJ J J $E$KK00 0 0C$1'7CHHF!1'29,,v2F2FH HC #3KE$S\F ' 3 3Ce D DI *7I>> . .c6222!(!5gx!M!M%ll622%1'3GGc6222).sQw)=)= 7 7I%,%9':B:C&E &EF $MM#v6666u---. . . . . . . . . . . . . . . MM$//// g/@@@u%%%''.....s%   +C==DD-CL>>M	M	c           	         |j         }t          j        ||j        |          }t          j        ||j        |          }g }	t          t          |                    D ]M}
|	                    |                    |||
                              |	                    |||
                   }N|	
                                 t          j        |||j        |||j        |	          }|S )Nr   )rp   r
   r   re   r   r  r8   ri   uremudivreverser  r   r  )rY   r}   r=   r	  r
  r   rp   r  r   r   rx  rk   s               rC   _ptr_for_indexz:_make_flattening_iter_cls.<locals>.FlatIter._ptr_for_index  s    z -gsyMMM!.w4PPP #E$KK00 = =CNN7<<vc{#C#CDDD#LLs<<EE!!!/#(06079 9 
rE   c                 X    |                      |||||          }t          ||||          S rB  )r{  r   rg  s          rC   r  z3_make_flattening_iter_cls.<locals>.FlatIter.getitem  s1    ))'7E3NN '5#>>>rE   c                 ^    |                      |||||          }t          |||||           d S rB  )r{  r   ri  s           rC   rj  z3_make_flattening_iter_cls.<locals>.FlatIter.setitem  s9    ))'7E3NN7GUE3?????rE   N)	rq   rr   rs   rt  r  r>  r{  r  rj  rk  s   rC   FlatIterrn    s         + + +BC/ C/ C/ C/ C/J  "? ? ?@ @ @ @ @rE   r~  )rb   r  r
   rw   )r  r~  rb   rl  r~  s    `   rC   r  r    s    *****&JCB	@ B	@ B	@ B	@ B	@ B	@ B	@'"=j"I"I B	@ B	@ B	@H #"E	@ E	@ E	@ E	@ E	@ E	@ E	@w2:>> E	@ E	@ E	@N rE   r  c                 v   t          t          j        |                    } || |          }||_        |                     |          } || ||                    d                    }|                    | |||           |                                }t          | |t          j        |          |          S Nr   )rZ   )	r  r   NumpyFlatTyper   rx   rg   r  r   r!   )r}   r=   r	  r
  flatiterclsflatiterarrclsr   s           rC   make_array_flatiterr    s    %e&9%&@&@AAK{7G,,HHN&&F
&'x'@'@'I'I
J
J
JC7GUC888




CWgu/B5/I/I3OOOrE   c                     |j         \  }|\  }t          |          } || ||          }|j        }|                     |          }	 |	| ||j                  }
|                    | |||
|           d S rH  )r   r  rb   rx   r   r>  )r}   r=   r[   r   r  r  r  r  r	  r  r
  s              rC   iternext_numpy_flatiterr    s     8LZJX%j11K{7G8<<<H!E&&F
&'
8
8
8CwVDDDDDrE   c                    |j         d         }|\  }}t          |          } || ||          }|j        }|                     |          }	 |	| ||j                  }
|                    | |||
|          }t          | ||j        |          S Nr   r
  )r   r  rb   rx   r   r  r!   r   )r}   r=   r[   r   r  r  r   r  r	  r  r
  r   s               rC   iternext_numpy_getitemr    s    !JOHe%j11K{7G8<<<H!E&&F
&'
8
8
8C


7GUC
?
?CWgsDDDrE   c                    |j         d         }|\  }}}t          |          } || ||          }|j        }	|                     |	          }
 |
| ||j                  }|                    | ||	|||           |                                 S r  )r   r  rb   rx   r   rj  ra  )r}   r=   r[   r   r  r  r   r  r  r	  r  r
  s               rC   iternext_numpy_getitem_anyr    s     !J!HeU%j11K{7G8<<<H!E&&F
&'
8
8
8CWguc5%@@@""$$$rE   c                     |j         d         }t          |          } || ||d                   }|                     |j                  } || ||j                  }|j        S r  )r   r  rx   rb   r   r   )	r}   r=   r[   r   r  r  r  r  r
  s	            rC   iternext_numpy_getitem_flatr    sj    !J%j11K{7G47;;;H
 566F
&'
8
8
8C:rE   c                 v   |j         \  }|\  }t          t          j        |                    } || |          }||_        |                     |          } || ||                    d                    }|                    | |||           |                                }	t          | ||j
        |	          S r  )r   r  r   NumpyNdEnumerateTyper   rx   rg   r  r   r!   r   )
r}   r=   r[   r   r	  r
  	nditerclsr  r  r   s
             rC   make_array_ndenumerater    s    XFEDC*5+Ee+L+LMMIYw((FFL&&F
&'v'>'>w'G'G
H
H
HC
'5#666




CWgsDDDrE   c                     |j         \  }|\  }t          |          } || ||          }|j        }|                     |          }	 |	| ||j                  }
|                    | |||
|           d S rH  )r   r  rb   rx   r   r>  )r}   r=   r[   r   r  r  r  r  r	  r  r
  s              rC   iternext_numpy_nditerr    s     JXHV*844IYwv666FE&&F
&'
6
6
6C
Wguc6BBBBBrE   c                 B     fdt          |j        |          D             }t          t          j        t          |                              } |           }|                     |           |                                }t           |j	        |          S )zndindex(*shape)c                 Z    g | ]'\  }}                     ||t          j                  (S r   r  )r   argtyr  r=   r}   s      rC   r   z&make_array_ndindex.<locals>.<listcomp>  sA     4 4 4 \\'3uz:: 4 4 4rE   )
r   r   r[  r   NumpyNdIndexTyper   r  r   r!   r   )r}   r=   r[   r   re   r  r  r   s   ``      rC   make_array_ndindexr    s    4 4 4 4 4"38T224 4 4E !!7E

!C!CDDIYw((F
'5111




CWgsDDDrE   c                    
 |j         j        }|dk    rA|j        d         j        
|d         }t	          j        ||          } 
fd|D             }ng }t          t          j        t          |                              } |           }|
                     |           |                                }	t           |j         |	          S )zndindex(shape)r   c                 T    g | ]$}                     |t          j                  %S r   r  )r   r   r=   r}   r   s     rC   r   z,make_array_ndindex_tuple.<locals>.<listcomp>.  s=     # # # gsE5:>> # # #rE   )r   rp   r   r{   r
   r   r[  r   r  r   r  r   r!   )r}   r=   r[   r   rp   rI  re   r  r  r   r   s   ``        @rC   make_array_ndindex_tupler  $  s     ?Daxx!1g$Wc488# # # # # #!# # #  !7E

!C!CDDIYw((F
'5111




CWgsDDDrE   c                     |j         \  }|\  }t          |          } || ||          }|                    | ||           d S rH  )r   r[  r>  )r}   r=   r[   r   r  r  r  r  s           rC   iternext_numpy_ndindexr  ;  sU     JXHV **IYwv666F
Wgv66666rE   c                 `   |j         }|j        }t          |j        d         t          j                  rt          j        ||d                   }n	|d         g} t          |          | |          }|	                    | |||           |
                                }t          | |||          S )z
    nditer(...)
    r   )r   r)  r   r   r   rL  r
   r   rP  r  r   r!   )	r}   r=   r[   r   r  r-  r)  r  r   s	            rC   make_array_nditerr  G  s    
 H_F#(1+u// %gtAw77q'&_X&&w88F
'66:::




CWgx===rE   c                     |j         \  }|\  } t          |          | ||          }|                    | ||           d S rH  )r   rP  r>  )r}   r=   r[   r   r  r  r  s          rC   iternext_numpy_nditer2r  [  sP     JXHV&_X&&wvFFFF
Wgv66666rE   c                     |j         \  }}t          j        t          j        d          t	          ||k                        }t          | ||j        |          S r  )r   r   r   rl  r   r#   r   )r}   r=   r[   r   arg1arg2r   s          rC   dtype_eq_implr  e  sH    JD$
+bjmmS%6%6
7
7CgwEEErE   c                 H   t          |          } || |          }|                     |j                  }|                     t          j        t          | |                    }|                     t          j        d          }t          t          j	        d          d          }	|D ]X}
|
                    ||
          }|                    |d          }|                    |	|                    |d                    }	Y|j        dk    rd}n|j        dk    ri|g}t          |dd                   D ]1}|                    |                    |d         |                     2t%          t          |                    }n|j        dk    rO|g}|dd         D ]1}|                    |                    |d         |                     2t%          |          }n't'          d                    |j                            |
                    ||          }|                    |d          }|                    |	|                    |d                    }	|                    |	d	
          5  | j                            |t0          d           ddd           n# 1 swxY w Y   |j        }|                     |          }|                     t          j        |          }|                                 ||f}t	          j        t          j                  }t	          j        t?          |                    }tA          ||t          j        t          j                  }| !                    |tD          ||          }| j#        $                    ||          }| %                    t          j                  }tM          j'        |||          }tM          j'        |||          }tQ          ||)                    ||*                                          ||||           |S )a	  Utility function used for allocating a new array during LLVM code
    generation (lowering).  Given a target context, builder, array
    type, and a tuple or list of lowered dimension sizes, returns a
    LLVM value pointing at a Numba runtime allocated array.
    rG   r   r   r   Nr  r  z3Don't know how to allocate array with layout '{0}'.FrY  )z[array is too big; `arr.size * arr.dtype.itemsize` is larger than the maximum possible size.)rD  r  )+rx   rz   r{   r   r   r   r   r   r   rl  smul_with_overflowrS  r  rp   r  r  ri   r   r   rR   r   r  r[  r\  r   get_preferred_array_alignmentuint32ra  MemInfoPointervoidptrTypeRefr9   r%   r  _call_allocatorr   meminfo_datar   r
   rj   r   r1  r  )r}   r=   r]  r  r  r   datatyper   arrlenoverflowr   arrlen_multr   dimension_sizeallocsize_multr8  r{   	align_valr   r   miparytypeclassargtypesr   r   r   shape_arraystrides_arrays                               rC   r  r  o  s%      F
&'
"
"C$$W]33H##EJWg0N0NOOH !!%*a00F
1q))H 
 
00;;&&{A66;;g++K;;
 
 |q	3		*&vabbz22 	E 	ENNN7;;wr{NCCDDDD))**	3		*$SbSk 	E 	ENNN7;;wr{NCCDDDD..!AHH   ! ! 	!
 //AAN%%na88I{{8W%:%:>1%M%MNNH	%	0	0 
 
 	))Z-	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 ME55e<<I  y99E##%%y%8D

u}
-
-C=g//LlEJEEH&&w4PPG;##GW55D##EJ//F$Wf@@@K&wFCCCM3h.A.A.C.CDD$($"$ $ $ $ Js   1"JJ#&J#	_allocatec                     d }|S )zTImplements a Numba-only default target (cpu) classmethod on the array
    type.
    c                 "    t          ||          S rB  )intrin_alloc)clsr8  r   s      rC   r   z _ol_array_allocate.<locals>.impl  s    Iu---rE   r   )r  r8  r   r   s       rC   _ol_array_allocater    s    
. . .KrE   c                 .    |                      ||          S )z9Trampoline to call the intrinsic used for allocation
    )r  )r]  r   r   s      rC   r  r    s     T5)))rE   c                 n    d }t          j        t           j                  }t          |||          }||fS )z3Intrinsic to call into the allocator for Array
    c                 H    |\  }}| j                             |||          }|S rB  )r   meminfo_alloc_aligned)r}   r=   r%   r   r8  r   r   s          rC   rf  zintrin_alloc.<locals>.codegen  s*    !E+33GYNNrE   )r   r  r  r%   )rg  r8  r   rf  r  r[   s         rC   r  r    s@      
 
u}
-
-C
CE
*
*C<rE   c           	         d }t          |t          j                  r&d}|                     |||t          j                  g}n:t          |t          j                  sJ |j        }t          j        |||          }g }|D ](}|	                     || ||j
        |                     )|                     |t          j        d          }	t          |          D ]m}
|                    d||
         |	          }t          j        ||          5  | j                            |t"          d           ddd           n# 1 swxY w Y   n|S )z;
    Parse the shape argument to an array constructor.
    c                    |                      t          j                  }|j        }t	          j        |          }t          |d|dz
  z  dz
            }|j        |k     r|                    ||          }n|j        |k    r|                    d||          }	|	                    |	d          5  | j
                            |t          d           ddd           n# 1 swxY w Y   |j        |k    r|                    ||          }n|}|S )z0Cast src to intp only if value can be maintainedrG   >FrY  )z#Cannot safely convert value to intpN)r   r   r   rH   r   rl  r   sextr  r  r[  r\  r   trunc)
r}   r=   src_tr7  r   
intp_widthintp_irmaxvalr   	is_largers
             rC   safecast_intpz#_parse_shape.<locals>.safecast_intp  sL   ''
33\
*Z(('Q*q.%8A$=??;##,,sG,,CC[J&&++Cf==I599  !11Z<                
 {Z''mmC11
s   /"CC!$C!rG   r   r   r  )znegative dimensions not allowedN)r   r   r   r   r   rL  r   r
   r   ri   r9   get_constant_genericr8   r  r8  r[  r\  r   )r}   r=   rD  r   r  rp   passed_shapesr  r   r   rx  is_negs               rC   _parse_shaper    s     * "em$$ G gsB
CCD"eo.....x,WcFFFF B BmmGWafa@@AAAA''Q??DT{{  $$S&+t<< &11 	 	--%I  	 	 	 	 	 	 	 	 	 	 	 	 	 	 	
 Ms   "D==E	E	c                 b    |j         d         }|d         }|j        }|t          | |||          fS )zL
    Parse the arguments of a np.empty(), np.zeros() or np.ones() call.
    r   )r   r   r  )r}   r=   r[   r   arrshapetypearrshaper]  s          rC   _parse_empty_argsr    s8     8A;LAwHoGL'<JJJJrE   c                     |j         d         }t          |t          j                  rK t	          |          | ||d                   }t          j        ||j        |j                  }|j	        |fS |j	        dfS )z_
    Parse the arguments of a np.empty_like(), np.zeros_like() or
    np.ones_like() call.
    r   r
  r   r   )
r   r   r   r   rx   r
   r   re   rp   r   )r}   r=   r[   r   arytyper   r  s          rC   re  re    sz    
 hqkG'5;'' #!j!!'7$q'BBB%gsyMMM&&""rE   c                 n    t          |t          j                  rd|  d}t          j        |          d S )NzIf np.z0 dtype is a string it must be a string constant.)r   r   UnicodeTyper	   r   )fnamer{   r   s      rC   _check_const_str_dtyper  $  sB    %*++ &NuNNN %%%& &rE   c                 8    |j         } ||||          }d }||fS )Nc                 x    t          | |||          \  }}t          | |||          }|                                S rB  )r  r  r   r  r=   r[   r  r]  r  r   s          rC   rf  znumpy_empty_nd.<locals>.codegen/  s:    +E7CHHUGWf==}}rE   instance_type)r  ty_shapety_dtypety_retty_refty_rettyr[   rf  s          rC   numpy_empty_ndr  *  s8    )H
(8X|
4
4C   <rE   c                    t          d|           |t          u s7t          |t          j                  r|j        t          u st          |          rt          j        }nt          |          }t          |           }|'|%t          j
        ||d          t          ffd	}|S d|  d| d}t          j        |          )Nr  r   r  c                 &    t          | |          S rB  )r  )re   r{   rQ  s     rC   r   zol_np_empty.<locals>.implD  s    !%666rE   z.Cannot parse input types to function np.empty(r  r  )r  floatr   r   Function
typing_keyr   doublety_parse_dtypety_parse_shaper   r	   r   )re   r{   nb_dtyperp   r   r   rQ  s         @rC   ol_np_emptyr  6  s    7E***	E5>	*	* 	/4/?5/H/H 0I<!%((%  D 0(cBBB# 	7 	7 	7 	7 	7 	7PuPPPPP %%%rE   c                 8    |j         } ||||          }d }||fS )Nc                 x    t          | |||          \  }}t          | |||          }|                                S rB  )re  r  r   r  s          rC   rf  z$numpy_empty_like_nd.<locals>.codegenQ  s:    0fMMUGWf==}}rE   r  )r  ty_prototyper  r  r  r[   rf  s          rC   numpy_empty_like_ndr  L  s8    )H
(<<
8
8C   <rE   c                    t          d|           t          |          st          |          }n$t          | t          j                  r| j        }n| }|^t          | t          j                  r-| j        dk    r| j        nd}|                     ||d          n4t	          j        |dd          nd|  d| d	}t          j
        |          dfd
	}|S )Nr  rZ  r   F)r{   r  rb  r   z3Cannot parse input types to function np.empty_like(r  r  c                 &    t          | |          S rB  )r  )r
  r{   rQ  s     rC   r   zol_np_empty_like.<locals>.impll  s    "3u555rE   rB  )r  r   r  r   r   r   r{   r  r\  r	   r   )r
  r{   r  r  r   r   rQ  s         @rC   ol_np_empty_liker  X  s   <///u !%((	C	%	% 9c5;'' 	2#&:#4#4SZZ#FHH8FUHKKEEK!S11EE0 #0 0',0 0 0 %%%6 6 6 6 6 6KrE   c                 8    t          j        |          }d }||fS )Nc                      t          |j        d                   | ||d                   }t          j        ||j        |                    |j        |j                  d           d S r   )rx   r   r
   rf  r   r   r   r   )r  r=   r[   r  r   s        rC   rf  z(_zero_fill_array_method.<locals>.codegenu  sb    %j!%%eWfQi@@w'++clCJ*O*O	 	 	 	 	rE   )r   r+  )r  rY   r[   rf  s       rC   _zero_fill_array_methodr  q  s,    
*T

C   <rE   
_zero_fillc                     d }|S )z?Adds a `._zero_fill` method to zero fill an array using memset.c                 $    t          |            d S rB  )r  rf  s    rC   r   z ol_array_zero_fill.<locals>.impl  s    %%%%%rE   r   )rY   r   s     rC   ol_array_zero_fillr   |  s    & & &KrE   c                 :    t          d|           t          fd}|S )Nrf  c                 Z    t          j        | |          }|                                 |S Nr  )rz  r  r  )re   r{   r
  s      rC   r   zol_np_zeros.<locals>.impl  s+    huE***
rE   )r  r  re   r{   r   s      rC   ol_np_zerosr    s0    7E***     KrE   c                 .    t          d|           dd}|S )N
zeros_likec                 Z    t          j        | |          }|                                 |S r  )rz  r  r  )r  r{   r
  s      rC   r   zol_np_zeros_like.<locals>.impl  s+    mAU+++
rE   rB  r  r  s      rC   ol_np_zeros_liker
    s-    <///    KrE   c                 .    t          d|           dd}|S )N	ones_likec                     t          j        | |          }|j        }t          t	          |                    D ]}d||<   |S Nr  rG   rz  r  r  r8   r   )r  r{   r
  arr_flatr   s        rC   r   zol_np_ones_like.<locals>.impl  sJ    mAU+++8X'' 	 	CHSMM
rE   rB  r	  r  s      rC   ol_np_ones_liker    s-    ;...    KrE   c                 v    t          d|           t          |          st          |          n|dfd	}|S )Nfullc                     t          j        |           }|j        }t          t	          |                    D ]}|||<   |S rB  rz  r  r  r8   r   )re   
fill_valuer{   r
  r  r   r  s         rC   r  zimpl_np_full.<locals>.full  sH    huh''8X'' 	' 	'C&HSMM
rE   rB  )r  r   r  )re   r  r{   r  r  s       @rC   impl_np_fullr    s\    65)))u !%((      KrE   c                 .    t          d|           dd}|S )Nr  c                     t          j        | |          }|j        }t          t	          |                    D ]}|||<   |S rB  r  )r  r  r{   r
  r  r   s         rC   r  z$impl_np_full_like.<locals>.full_like  sG    mAu%%8X'' 	' 	'C&HSMM
rE   rB  r	  )r  r  r{   r  s       rC   impl_np_full_liker    s.    ;...    rE   c                 .    t          d|           dd}|S )Nonesc                     t          j        | |          }|j        }t          t	          |                    D ]}d||<   |S r  r  )re   r{   r
  r  r   s        rC   r   zol_np_ones.<locals>.impl  sJ    huE***8X'' 	 	CHSMM
rE   rB  r	  r  s      rC   
ol_np_onesr    s/     65)))    KrE   c                     t          d|           t          |          st          |          nt          j        dfd	}|S )Nidentityc                 h    t          j        | | f          }t          |           D ]	}d|||f<   
|S r  )rz  rf  r8   )r  r{   r
  rm   r  s       rC   r   z"impl_np_identity.<locals>.identity  sA    h1vx((q 	 	AC1II
rE   rB  )r  r   r  r   r  )r  r{   r   r  s      @rC   impl_np_identityr"    s^    :u---u  !%((<     
 OrE   c                     d S rB  r   NMs     rC   _eye_none_handlerr'    r	  rE   c                 H    t          |t          j                  rd }nd }|S )Nc                     | S rB  r   r$  s     rC   r   z$_eye_none_handler_impl.<locals>.impl      HrE   c                     |S rB  r   r$  s     rC   r   z$_eye_none_handler_impl.<locals>.impl  r*  rE   r   r   r  )r%  r&  r   s      rC   _eye_none_handler_implr-    s>    !U^$$ 	 	 	 		 	 	KrE   c                 B   |t          |t          j                  rt          j        t
                    nYt          |t          j        t          j        f          rt          t          |d|                    nt          j        |          d dt
          ffd	}|S )Nr{   r   c                     t          | |          }t          j        | |f          }|dk    r0t          | ||z
            }t	          |          D ]}d||||z   f<   n/t          | |z   |          }t	          |          D ]}d|||z
  |f<   |S r  )r'  rz  rf  r  r8   )	r%  r&  r   r{   _Mr
  drm   r  s	           rC   r   znumpy_eye.<locals>.impl  s    q!$$h2w##66ArAvA1XX " " !Aq1uH" AE2A1XX " " !AE1H
rE   )
r   r   r  rz  r{   r  	DTypeSpecr  r   r  )r%  r&  r   r{   r   r  s        @rC   	numpy_eyer3    s     }
5%.99}Xe__	EEOU\:	;	; geWe4455Xe__!5       KrE   c                     t          |           st          j        d          t          | t          j                  r#| j        dvrt          j        d          dd}|S d S )N#The argument "v" must be array-like)rG   r_  zInput must be 1- or 2-d.r   c                 ~   | j         dk    r| j        }|d         t          |          z   }t          j        ||f| j                  }|dk    r&t          ||z
            D ]}| |         ||||z   f<   n%t          ||z             D ]}| |         |||z
  |f<   |S | j        \  }}|dk     r||z   }|dk    r||z
  }t          t          ||          d          }t          j	        || j                  }|dk    r#t          |          D ]}| |||z   f         ||<   n"t          |          D ]}| ||z
  |f         ||<   |S r  )
rp   re   r  rz  rf  r{   r8   r  r  r  )r   r   r   r  rh  rm   rowscolss           rC   	diag_implzimpl_np_diag.<locals>.diag_impl  sy   v{{GaD3q66Mh1vqw//66"1q5\\ - -()!Aq1uH- #1q5\\ - -()!AE1H
W
dq55!8Dq55!8DD$++hq!'**66"1XX - -!"1a!e8A- #1XX - -!"1q5!8A
rE   r  )r   r	   r   r   r   r   rp   NumbaTypeError)r   r   r9  s      rC   impl_np_diagr;    s~    A H !FGGG!U[!! 6'(BCCC	 	 	 	6 ? rE   c                    t          | t          j                  sd}t          j        |          t          | j        t          j                  sd}t          j        |          t          |           dz  fd}|S )Nz5The argument "dimensions" must be a tuple of integersr  c                     t          j        f| z   t           j                  }d}| D ]N}t          j        |t           j                                      t          ||                    }|||<   |dz  }O|S )Nr  r   rG   )rz  r  r  aranger]  r/   )
dimensionsr   rm   rx  r   r%  re   s        rC   r   znumpy_indices.<locals>.implD  s    htj(999 	 	C)Crx00088eQ,, C CFFAA
rE   )r   r   r  r	   r   r{   r   r   )r?  r   r   r%  re   s      @@rC   numpy_indicesr@  7  s    j%.11 &E %%%j&66 &E %%%JA1HE
 
 
 
 
 
 KrE   c                     t          |           sd}t          j        |          t          |t          t
          j        f          sd}t          j        |          dd}|S )Nr5  z#The argument "k" must be an integerr   c                 t   t          j        |           } |                                 } t          |           }t	          |          }||z   }t          j        ||f| j                  }t          j        d|           }t          j        d|          }t          |          D ]}| |         |||z   ||z   f<   |S r   )	rz  r{  re  r   r  rf  r{   maximumr8   )	r   r   r   abs_kr  r   rm   jts	            rC   r   znumpy_diagflat.<locals>.impl]  s    JqMMGGIIFFAIh1vqw''Jq1"Jq!q 	% 	%A !!CAq1u
rE   r  )r   r	   r   r   r   r   r   )r   r   r   r   s       rC   numpy_diagflatrG  S  sr    A &3 %%%a#u}-.. &3 %%%    KrE   c                    |dv sJ |dk    r:d}t          d|           D ]&}d|z  }|d| dd                    |           d	z  }'n9d
}t          d|           D ]&}d|z  }|d| dd                    |           dz  }'t          j        |          }t	          |t                                 t                      d|          }t          |          S )N)r  rj  r  zv
            def _getitem(a, idx, axis):
                if axis == 0:
                    return a[idx, ...]
        rG   ):z
                elif axis == z:
                    return a[r  z, idx, ...]
            z|
            def _setitem(a, idx, axis, vals):
                if axis == 0:
                    a[idx, ...] = vals
        z:
                    a[z, idx, ...] = vals
            r  )r8   r  textwrapdedentexecglobalsr'   )rp   r~  rD  rm   lsts        rC   "generate_getitem_setitem_with_axisrO  n  s1   )))))y
 q$ 	 	A1*C  "iinn   BB	 q$ 	 	A1*C  yy~~   BB
 
		BWYY	:t::	BBrE   takec                 ~  	 t          j        |          rt          | t          j                  r t          |t          j                  rdd}|S t          | t          j                  r-t          |t          j                  r|j        dk    dfd	}|S t          | t          j                  r,t          |t          j        t          j        f          rdd}|S d S d S t          | t          j                  rAt          |t          j                  r'd| j	        dz
  z  	t          	fd            dfd	}|S t          | t          j                  rat          |t          j        t          j        t          j        f          r2| j	        }t          |d	          t          |d
          dfd	}|S d S d S )Nc                     || j         dz
  k    s|| j          k     rt          d          |                                 |         S )NrG   Index out of bounds)r   
IndexErrorre  )r  r   r   s      rC   	take_implznumpy_take.<locals>.take_impl  sC    afqj))Ww->->$%:;;;wwyy))rE   r  c                 z   t          j        |j        | j                  }	r|                                }n|}t          j        |          }d}|                                 }|D ];}|| j        dz
  k    s|| j         k     rt          d          ||         ||<   |dz   }<|                    |j	                  S )Nr  r   rG   rS  )
rz  r  r   r{   r\  r  re  rT  r]  re   )
r  r   r   rh  walkeritrm   r  rM  F_orders
            rC   rU  znumpy_take.<locals>.take_impl  s    hw|17;;; %$\\^^FF$FYv&&wwyy  AAFQJ''1w;;()>???!!WCFAAA{{7=111rE   c                 T    t          j        |          }t          j        | |          S rB  )rz  r   rP  )r  r   r   converts       rC   rU  znumpy_take.<locals>.take_impl  s#    (7++wq'***rE   r  rG   c                 Z   t                    }d}|t          | j                  k     r| j        |         dk    sJ | j                    t          t          | j                            D ]+}| j        |         }||k    rt	          |||          }|dz  },|                     |          S r  )r   r   re   r8   r/   r]  )r  r   rI  rE  r   r   rF  s         rC   _squeezeznumpy_take.<locals>._squeeze  s    Ahhc!'ll**qwt}/A/A/A17/A/A/A QW..  CAd{{+CA66Qyy~~%rE   c                     t          j        | |f|          }| j        dk    r|d         S |dk     r
|| j        z  } ||          S )Nru  rG   r   )rz  rP  rp   )r  r   r   r  r]  s       rC   rU  znumpy_take.<locals>.take_impl  sU    GAz5556Q;;Q4K!88AFNDx4(((rE   r  rj  c                 ~   |dk     r
|| j         z  }|dk     s|| j         k    rd| d| j          }t          |          t          | j        |t	          |                    }t          j        || j                  }t          t	          |                    D ]#} | ||         |          } 	||||           $|S )Nr   zaxis z) is out of bounds for array of dimension r  )	rp   r   r/   re   r   rz  r  r{   r8   )
r  r   r   r   re   r   rm   rN  _getitem_setitems
           rC   rU  znumpy_take.<locals>.take_impl  s    !88AFND!88tqv~~44 4 4+,64 4C$S//)%agtS\\BBhuAG444s7||,, . .A GAJ55AHS!T1----
rE   rB  )r
   r   r   r   r   r   r  r  rL  rp   r'   rO  )
r  r   r   rU  rp   rY  r`  ra  r]  rF  s
        @@@@@rC   
numpy_takerb    s6    4   Ua%% 	*Wem*L*L 	* * * * a%% 	*Wek*J*J 	n+G2 2 2 2 2 2 a%% 	7UZ$ABB	+ + + + 	 	 	 	 a%% 	*Wem*L*L 	
#A
 	& 	& 	& 	& 	&) ) ) ) ) ) a%% 	7U[%*eo$NOO	 6D9$	JJH9$	JJH       /	 	 	 	rE   c                  b   d | D             }t          d |D                       rt          j        }n|t          d |D                       rt          j        }nVt	          t          ddt          j        t                    j        z  z            }d |D             }t          ||gz             }|S )Nc                 F    g | ]}t          |t          j                  |S r   r,  r  s     rC   r   z!_arange_dtype.<locals>.<listcomp>  s)    CCCAZ5>%B%BCaCCCrE   c              3   J   K   | ]}t          |t          j                  V  d S rB  r  r  s     rC   rE  z _arange_dtype.<locals>.<genexpr>  s.      
8
8A:a''
8
8
8
8
8
8rE   c              3   J   K   | ]}t          |t          j                  V  d S rB  )r   r   Floatr  s     rC   rE  z _arange_dtype.<locals>.<genexpr>  s.      88AZ5;''888888rE   zint%sr  c                 6    g | ]}t          j        |          S r   )r   	unliteralr  s     rC   r   z!_arange_dtype.<locals>.<listcomp>  s"    ???1EOA..???rE   )
rF  r   
complex128r   r  rz  r{   r   r   r  )r   boundsr{   NPY_TYunliteral_boundss        rC   _arange_dtypern    s    CCCCCF

8
8
8
8
888 2 	88888	8	8 2 1rx}}/E+E FGG @????$y011LrE   c                ^  	 t          |t          j                  r|j        }t          |t          j                  r|j        }t          |t          j                  r|j        }|t          j        }|t          j        }|t          j        }t          | t          j                  rrt          |t          j        t          j        f          rLt          |t          j        t          j        f          r&t          |t          j        t          j        f          sd S t          |t          j                  rt          | ||          n|j	        t          d | ||fD                       	t          | dd           t          |dd           t          |dd           d	fd	}|S )Nc                 B    g | ]}t          |t          j                  S r   r  r  s     rC   r   znp_arange.<locals>.<listcomp>#  s4     5 5 5 "!U]33 5 5 5rE   r   c                   n| }n|}n|}||nd}|d|}	}n||}	}|dk    rt          d          |	|z
  |z  }
t          t          j        |
j                            }du rEt          t          j        |
j                            }t          t          ||          d          }nt          |d          }t          j	        |          }|}t          |          D ]}|||z  z   ||<   |S )NrG   r   zMaximum allowed size exceededT)r   r   mathceilr   r"  r  r  rz  r  r8   )r&  r  r  r{   	lit_startlit_stoplit_step_step_start_stopnitems_cnitems_rnitems_ir   r
  r   rm   start_value
step_value
stop_value
true_dtypeuse_complexs                    rC   r   znp_arange.<locals>.impl*  s(   #.#:KK	!+!7::T!+!7::T$0ayEFF%xEFA::<===FNe+ty//00 $49X]3344HXx00!44FF1%%Fhvz**v 	' 	'AAI&CFF
rE   r  )r   r   Optionalr9   r+  r  r  r2  rn  r{   rF  r  )
r&  r  r  r{   r   r}  r~  r  r  r  s
        @@@@@rC   	np_aranger    s   $'' y$'' y%(( 
|z|z}
uel++ tenel;<<tenel;<< 55>5?"CDD
 	%(( !"5$55

[
 5 5!&d 35 5 5 6 6K %$77K55J55J         < KrE   c                 V   t          d | |fD                       sd S t          |t          t          j        f          sd}t          j        |          t          d | |fD                       r&t          j	        rt          j
        nt          j        nt          j        dfd	}|S )Nc              3   J   K   | ]}t          |t          j                  V  d S rB  )r   r   r  r  s     rC   rE  z!numpy_linspace.<locals>.<genexpr>M  s.      FFz#u|,,FFFFFFrE   r  c              3   J   K   | ]}t          |t          j                  V  d S rB  r  r  s     rC   rE  z!numpy_linspace.<locals>.<genexpr>T  r  rE   r  c                     t          j        |          }| dz  } |dz  }|dk    r|S |dz
  }|dk    r9|| z
  }t          j        ||          }t          d|          D ]}| ||z  z   ||<   n| |d<   |dk    r||d<   |S )Ng      ?r   rG   r  )rz  r  divider8   )	r&  r  r  r
  divdeltar  rm   r{   s	           rC   r  z numpy_linspace.<locals>.linspace]  s    hsE"" cz!88JAg775LE9UC((D1c]] , ,!d(+A, CF77CG
rE   r  )r  r   r   r   r   r	   r   rF  r   USE_LEGACY_TYPE_SYSTEMrj  np_complex128r   )r&  r  r  r   r  r{   s        @rC   numpy_linspacer  K  s    FFFFFFF cC/00 &5 %%%

C
CeT]
C
C
CCC ( 	($EE'EE     , OrE   c           
         |j         d         } t          |          | ||d                   }t          j        ||j                  }|j        }t          | |||          }|j        }	|j        }
|j        dv sJ |j        |j        k    r%t          j	        ||
|	|j
        |j        d           nt          j        ||j                  }t          j        ||j                  }|                     t          j                  }t          j        |||          5 }t          j        | ||	|||j        |          }t          j        | ||
|||j        |          }|                    |                    |          |           ddd           n# 1 swxY w Y   t)          | ||j        |                                          S )z
    Array copy.
    r   r
  r  rG   r   N)r   rx   r
   r   re   r   r  r   r  
raw_memcpyr   r   r   r   r   r   r6  r  r  r>   r"   r   )r}   r=   r[   r   r  r   r  rettyperh  r*  r  r,  r  r   r   r"  r9  s                    rC   _array_copyr  v  s    hqkG
*W

gwd1g
>
>
>C!'3955FoG
'7F
;
;CxHI>T!!!!~''7Ix<q	2 	2 	2 	2 	2 *7CK@@+GS[AA''
33w77 	;7/(0607I IG 0'91718J JH MM',,w//:::	; 	; 	; 	; 	; 	; 	; 	; 	; 	; 	; 	; 	; 	; 	; GWcos}}OOOs   A(FFFc                     t          |t          j                  sJ |j        dk    rdnd}|                    |d          } ||          }|t
          fS )Nr  r   F)r  rb  )r   r   r   r  r\  r  )rg  r  r  rh  r[   s        rC   _array_copy_intrinsicr    sZ    a%%%%%HOOSSF
&&&
/
/C
#a&&CrE   z
array.copyc                 &    t          | |||          S rB  )r  r  s       rC   
array_copyr    s    wd333rE   c                 @    t          | t          j                  rd }|S )Nc                      t          |           S rB  )r  r  s    rC   
numpy_copyz#impl_numpy_copy.<locals>.numpy_copy  s    (+++rE   rC  )r  r  s     rC   impl_numpy_copyr    s+    !U[!! ,	, 	, 	,rE   c           	      R   |j         }|j        d         }|j        |k    s
J d            |j        dk    r|j        dk    sJ  t	          |          | ||d                   } t	          |          | |          }|                     |t          j        t          j        d          d          }	| 	                    |t          j        t          j        d          |j
        f          }
t          ||j        |	|
|j
        |j        |j                   t          | |||                                          S |j        |j        k    s|j        dk    r!|j        dv rt          | |||d                   S |j        dk    r|dv sJ |dk    rt"          nt$          }t'          || |||d                   }|                    |          5 \  }}|5  t          | |||d                   }|j        }d	d	d	           n# 1 swxY w Y   |5  t-          | |||          }|j        }d	d	d	           n# 1 swxY w Y   d	d	d	           n# 1 swxY w Y   |                    |j                  }|                    ||           |                    ||           |S t-          | |||          S )
zd
    Common logic for layout conversion function;
    e.g. ascontiguousarray and asfortranarray
    r   z return-type has incorrect layoutrG   r
  r  r  rZ  r   N)r   r   r  rp   rx   r  r   r  r   r  r   r   r   r   r   r!   r   r   r   rT  r   blockr  phir9   add_incoming)r}   r=   r[   r   output_layoutrQ  r   r   rh  re   r   
check_funcr3  thenorelseout_thenthen_blk
out_orelse
orelse_blkret_phis                       rC   _as_layout_arrayr    sx   
 OEHQKE<=(((*L(((zQzQjQ@@@j11,,U^EJ22D
 
 $$W%*^EJ%B%B&)l_6 6 	sCHeWcl{CJ	0 	0 	0 '5#--//JJJ
,%,
&
&
aELD$8$8 '5$q'BBB <3 !D((((*73*>*>JJ.z/6/6/4/3Aw	8 8I
 ++ 	/~f - -0'515a :  :H&}H- - - - - - - - - - - - - - -
  / /!,WgsD!I!IJ!(J/ / / / / / / / / / / / / / /	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ kk(-00G  8444  Z888N wd;;;sZ   I G:.I:G>	>IG>	IH-!I-H1	1I4H1	5IIIc                     t          t          j                  st          j                  |                    j        t          |j        d                    } ||          }|fdfS )NrG   )r  rp   c                 6    t          | |||j                  S )N)r  )r  r   )r  r  r   r  r  s       rC   r  z,_as_layout_array_intrinsic.<locals>.<lambda>  s%    #3	1a-"=$? $? $? rE   )	r   r   r&   r	   RequireLiteralValuer\  r   r  rp   )rg  r  r  rh  r[   s     `  rC   _as_layout_array_intrinsicr    s}    mU%899 8(777
&&3#afa..&
I
IC
#a

C ? ? ? ? ? ?rE   c                     t          |           st          j        d          t          | t          j        t          j        f          rd }nt          | t          j                  rd }|S )Nrc  c                 N    t          j        t          j        |                     S rB  )rz  ascontiguousarrayr   r  s    rC   r   z%array_ascontiguousarray.<locals>.impl  s    '444rE   c                 "    t          | d          S Nr   r  r  s    rC   r   z%array_ascontiguousarray.<locals>.impl      -a555rE   r   r	   r   r   r   r  r  r   r  s     rC   array_ascontiguousarrayr    s|    A H !FGGG!elEM344 6	5 	5 	5 	5	Au{	#	# 6	6 	6 	6KrE   c                     t          |           st          j        d          t          | t          j        t          j        f          rd }|S t          | t          j                  rd }|S d S )Nrc  c                 N    t          j        t          j        |                     S rB  )rz  asfortranarrayr   r  s    rC   r   z"array_asfortranarray.<locals>.impl  s    $RXa[[111rE   c                 "    t          | d          S )Nr  r  r  s    rC   r   z"array_asfortranarray.<locals>.impl  r  rE   r  r  s     rC   array_asfortranarrayr    s    A H !FGGG!elEM344 	2 	2 	2	Au{	#	# 	6 	6 	6 rE   zarray.astypec           
      >   |j         d         } t          |          | ||d                   }t          j        ||j                  }|j        }t          | |||          }|j        }	|j        }
t          j        ||j                  }t          j        ||j                  }| 	                    t          j                  }t          j        |||          5 }t          j        | ||	|||j        |          }t          j        | ||
|||j        |          }t          | |||          }|                     |||j        |j                  }t%          | ||||           d d d            n# 1 swxY w Y   t'          | ||j        |                                          S r  )r   rx   r
   r   re   r   r  r   r   r   r   r   r6  r  r  r   r   r{   r   r"   r   )r}   r=   r[   r   r  r   r  r  rh  r*  r  r,  r  r   r   r"  r9  items                     rC   array_astyper    s    hqkG
*W

gwd1g
>
>
>C!'3955FoG
'7F
;
;CxHI&w<<K'==L##EJ//F		7FF	3	3 	>w+GWh,2K,3NGE E ,Wgy-3\-4^WF F '7G<<||GT7='-HH7GWdH===	> 	> 	> 	> 	> 	> 	> 	> 	> 	> 	> 	> 	> 	> 	> GWcos}}OOOs   BE++E/2E/c                 8    |j         } ||||          }d }||fS )Nc           	         |j         d         }|j        } t          |          | ||d                   }t          |          } || |          }|j        }	t	          | |          }
t          |j        j        |
          }|                    |j	        |j                  }|
                    ||          }t          j        ||          }|                    |d          5  d}| j                            |t           |f           d d d            n# 1 swxY w Y   t          j        ||                    ||          g          }t          j        ||g          }|                    |j        |                     |	                    d                              }t/          ||||||j        |j                   |                                }t7          | ||j        |          S )Nr   r
  FrY  z.buffer size must be a multiple of element sizer   r8  )r   r   rx   r   r   r   r   r9   r   r   sremr
   is_not_nullr  r[  r\  r   rj   sdivr1  r   r   r   r   r   r   r   r!   )r}   r=   r[   r   buftyr   r  
out_ary_tyout_aryout_datamodelr   ll_itemsizer.  remis_incompatibler   re   r   r   r   s                       rC   rf  znp_frombuffer.<locals>.codegen?  s$   jQ@@@&&
*Wg..*//s|0(;;SZ66 ll6;//!-gs;;___U_;; 	K 	KBC--gzC6JJJ	K 	K 	K 	K 	K 	K 	K 	K 	K 	K 	K 	K 	K 	K 	K "7W\\&+-N-N,OPP$W{m<<Hg,,]-C-CF-K-KLL
 
 	w "& +"{!j	+ 	+ 	+ 	+ !! '3?CHHHs   $%DDDr  )rg  bufferr{   rQ  rD  r[   rf  s          rC   np_frombufferr  :  s<    		B
"VUE
"
"C#I #I #IH <rE   c                    t          d|           t          | t          j                  r| j        dk    rd|  }t          j        |          |t          u s7t          |t          j                  r|j	        t          u st          |          rt          j        }nt          |          }|t          j        |dd| j                   nd|  d| d}t          j        |          t          ffd		}|S )
N
frombufferr   z+Argument "buffer" must be buffer-like. Got rG   )r{   rp   r  rb  z3Cannot parse input types to function np.frombuffer(r  r  c                 &    t          | |          S rB  )r  )r  r{   rQ  s     rC   r   z impl_np_frombuffer.<locals>.impl}  s    VUE222rE   )r  r   r   r   r  r	   r   r  r  r  r   r  r  r   r?  )r  r{   r   r  r   rQ  s        @rC   impl_np_frombufferr  f  s,   <///fel++ &v}/C/CDFDD %%%	E5>	*	* 	/4/?5/H/H 0I<!%(((3)/%79 9 93 &3 3*/3 3 3 %%%  3 3 3 3 3 3KrE   c                     t          |          rt          dd           dfd	}|S t          |t          j                  rt          d|          dfd	}|S d S )Nr   c                      | |          S rB  r   rk   re   r{   intrinsic_cfarrays      rC   r   zimpl_carray.<locals>.impl      $$S%000rE   c                      | |          S rB  r   r  s      rC   r   zimpl_carray.<locals>.impl  r  rE   rB  r   get_cfarray_intrinsicr   r   r2  rk   re   r{   r   r  s       @rC   impl_carrayr        5 1#t<<	1 	1 	1 	1 	1 	1	E5?	+	+ 1#u==	1 	1 	1 	1 	1 	1 rE   c                     t          |          rt          dd           dfd	}|S t          |t          j                  rt          d|          dfd	}|S d S )Nr  c                      | |          S rB  r   r  s      rC   r   zimpl_farray.<locals>.impl  r  rE   c                      | |          S rB  r   r  s      rC   r   zimpl_farray.<locals>.impl  r  rE   rB  r  r  s       @rC   impl_farrayr    r  rE   c                 0     t            fd            }|S )Nc                 P   |t           j        u rd }n<t          |t           j                  r|j        }nd| d}t          j        |          	|d}t          j        |          |}nat          	t           j                  r-	j        }|#||k    rd| d| d}t          j        |          nd	 d}t          j        |          t          |          }|d| d}t          j        |          t          j	        ||
          }t          |||          }|t          fS )Nz pointer argument expected, got ''z*explicit dtype required for void* argumentzmismatching dtype 'z' for pointer type 'zinvalid dtype spec 'zinvalid shape ')r   r  r   CPointerr{   r	   r:  r2  r  r   r%   
np_cfarray)rg  rk   re   	ptr_dtyper   r{   rp   rQ  r[   dtype_r  s            rC   r  z0get_cfarray_intrinsic.<locals>.intrinsic_cfarray  sT   %-IIU^,, 	-	II;S;;;C',,,> B+C000EE00 	-LE$)););MEMMsMMM+C0002222C',,,e$$<,E,,,C',,,E400sE**JrE   r*   )r  r  r  s   `` rC   r  r    s4         Y> rE   c                     |j         dd         \  }}|dd         \  }}|j        }|j        dv sJ  t          |                     }	t	           |          }
t          j        |
          }t          |t          j	                  rt          j
        |          }n|f}|f} fdt          ||          D             }|}g }|j        dk    r1|D ]-}|                    |                               ||          }.nQt          |          D ]-}|                    |                               ||          }.|                                                     |                     |j                                                            }t)          |	||||d           |	                                }t-           |j        |          S )zR
    numba.numpy_support.carray(...) and
    numba.numpy_support.farray(...).
    Nr_  r  c                 Z    g | ]'\  }}                     ||t          j                  (S r   r  )r   rK  r  r=   r}   s      rC   r   znp_cfarray.<locals>.<listcomp>  sA     9 9 9&% ll7E65:>> 9 9 9rE   r  r  )r   r   r  rx   r   r
   r   r   r   rL  r   r   ri   r   r  rz  r1  rz   r{   r  r   r   r"   )r}   r=   r[   r   r)  r  rk   re   r   r  r   r  r  offr   r   r   r   s   ``                rC   r  r    s   
 Xbqb\NE7bqbJCOE<4j11GGU++H.**K'5?++ %gu55*9 9 9 9 9#&w#7#79 9 9F CG|s 	& 	&ANN3++c1%%CC	& &!! 	& 	&ANN3++c1%%CC??3"00==HHJJL LD 7"'    



CGWcosCCCrE   c                 H   t          |t          j                  r-|                     t          j        t          |                    S t          |t          j                  r@|                     t
          t          t          j        |                    } |||f          S J rB  )	r   r   rL  r   r   r   r  rQ   r%   )r}   r=   seqtyseqr  s        rC   _get_seq_sizer    s    %)) ##EJE

;;;	E5>	*	* ''Yuz5-J-JKKx#(((rE   c                      |j                              t          j        t	          |t
          j                             fd}|S )zK
    Return a getitem() implementation that doesn't incref its result.
    c                 f     | |          }j         rj                            | |           |S rB  )r   r   decref)r=   r   rh  r}   r  rQ  s      rC   wrapz$_get_borrowing_getitem.<locals>.wrap  s>    l7D)) 	4Kws333
rE   )r{   rQ   r  r  r%   r   r   )r}   r  r  r  rQ  s   `  @@rC   _get_borrowing_getitemr    se     KE''(8(1%
(K(KM ML       KrE   c           	      6                          t          j                  }t          |d           fd}g }||}	}t	          |          D ]<}
|
dk    r |||	          \  }}	|                    t           ||	                     =t          |          S )zF
    Compute the likely shape of a nested sequence (possibly 0d).
    r   c                     t          | t          j                  r3t          |           dk    rdS | d                             |d          fS t          |           }| j         ||f          fS )Nr   NN)r   r   rL  r   rS  r  r{   )r  r  r  r=   r}   r   s      rC   get_first_itemz.compute_sequence_shape.<locals>.get_first_item  sw    eU_-- 	C5zzQ!zQx!6!6sA!>!>>>1'5AAL;WsDk B BBBrE   )r   r   r   r   r8   ri   r  r   )r}   r=   rp   r  r  r   r  r  innertyinnerrm   r   s   ``         @rC   compute_sequence_shaper    s     ##EJ//FFADC C C C C C C FCUG4[[ G Gq55+^GU;;NGUmGWguEEFFFF==rE   c                 D      fd fd |||           dS )z?
    Check the nested sequence matches the given *shapes*.
    c                  J    j                              t          d           d S )N)zincompatible sequence shape)r[  r\  r   )r=   r}   s   rC   _failz#check_sequence_shape.<locals>._fail8  s4    ))':*J	L 	L 	L 	L 	LrE   c                 .   t          |          dk    rd S t          | |          }|d         }                    d||          }                    |d          5                d d d            n# 1 swxY w Y   t          |          dk    rd S t	          | t
          j                  rot          |           }t          j	        |          5 }| j
        } |||j        f          }	 ||	|dd                     d d d            d S # 1 swxY w Y   d S t	          | t
          j                  rTt          t          |                     D ]5}
| |
         }                    ||
          }	 ||	|dd                     6d S J |             )Nr   rX  FrY  rG   )r   r  r  r  r   r   r  r  r
   r  r{   r   rL  r8   rS  )r  r  r  r   expectedrU  r  r  r  r  rm   r  r=   check_seq_sizer}   s              rC   r  z,check_sequence_shape.<locals>.check_seq_size<  s3   v;;!FWguc::!9&&tT8<<__Xe_44 	 	EGGG	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 v;;!FeU^,, 	1'5AAL"7D11 ;T+$WsDJ.?@@wvabbz:::; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ;
 u// 	3u::&& ; ;(--c155wvabbz::::; ; eOOOs$   A66A:=A:0DDDNr   )r}   r=   r  r  r  r  r  s   ``   @@rC   check_sequence_shaper  3  sn    
L L L L L L       : N5#v&&&&&rE   c                 V    	  fd		 fd ||d           dS )zl
    Assign a nested sequence contents to an array.  The shape must match
    the sequence's structure.
    c           
          t          j        	j        | d          }                    ||j                  }t          ||           d S r  )r
   r  r  r   r{   r   )
r   rO  r   rk   r	  r=   r}   r   r  r   s
       rC   assign_itemz-assign_sequence_to_array.<locals>.assign_itemc  se    '$(-g%Q Q Qll7C<<7GUC55555rE   c                    t          |          dk    r7t          | t          j        t          j        f          rJ  || |           d S |d         }t          | t          j                  ryt          |           }t          j        |          5 }| j        } |||j	        f          } |||dd          ||j	        fz              d d d            d S # 1 swxY w Y   d S t          | t          j                  ryt          t          |                     D ]Z}	| |	         }                    ||	          }                    t          j        |	          }
 |||dd          ||
fz              [d S J |             r  )r   r   r   r  rL  r  r
   r  r{   r   r8   rS  r   r   )r  r  r  r   r   r  r  r  r  rm   r   assignr  r=   r}   s              rC   r  z(assign_sequence_to_array.<locals>.assigni  s   v;;!!%%.%/)JKKKKKK,,,FayeU^,, 	1'5AAL"7D11 LT+$WsDJ.?@@wvabbz7dj]3JKKKL L L L L L L L L L L L L L L L L L
 u// 	3u::&& G G(--c155,,UZ;;wvabbz7eX3EFFFF	G G eOOOs   :CC!Cr   Nr   )
r}   r=   r   r  r   r	  r  r  r  r  s
   ``````  @@rC   assign_sequence_to_arrayr  \  s    6 6 6 6 6 6 6 6 6 6       2 F5#vr"""""rE   c                     t          | |          \  }}t          |          r|}nt          |          }|d S t          j        ||d          S r  )r4   r   r  r   r   )rg  rO  r{   rp   	seq_dtypes        rC   np_array_typerr    sW    ,Y??OD)5 u%%=F;udC(((rE   c                 j    t          d|           t          | ||          } |||          }d }||fS )Nr   c           
      t   |j         }|j        }|j        d         }|d         }t          | ||||          }t	          |          |k    sJ t          | ||||           t          | |||          }	t          | ||	j        ||	j	        |||           t          | ||j         |	                                          S r   )r   rp   r   r  r   r  r  r  r   r   r"   r   )
r}   r=   r[   r   r	  rp   r  r  r  r
  s
             rC   rf  znp_array.<locals>.codegen  s    z1g'$sKK6{{d""""Wguc6BBBWguf== '38V!$eUC	A 	A 	A  #/ #1 1 	1rE   )r  r  )rg  objr{   rh  r[   rf  s         rC   np_arrayr    sM    7E***
C
/
/C
#c5//C1 1 1" <rE   c                     t          d|           t          |           st          j        d          t	          |          s%t          |          d}t          j        |          dd}|S )Nr   z(The argument "object" must be array-likez:The argument "dtype" must be a data-type if it is providedc                 "    t          | |          S rB  )r  )rO  r{   s     rC   r   zimpl_np_array.<locals>.impl  s    &&&rE   rB  )r  r   r	   r   r   r  )rO  r{   r   r   s       rC   impl_np_arrayr    s    7E***F## 2  "1 2 2 	2u &."7"7"?J %%%' ' ' 'KrE   c                 
   |                     d          }|                     |          }|                    d||          }|                    ||                    ||          |          }|                    |                    d||          |                    d||                    }|                    |d          5  d|z  }	| j                            |t          |	f           d d d            n# 1 swxY w Y   |S )Nr   r  r  FrY  z%s(): axis out of bounds)	r9   r  r  r  r  r  r[  r\  rT  )
r}   r=   r   rp   r   r   ll_ndimis_neg_axisaxis_out_of_boundsr   s
             rC   _normalize_axisr    sI   99Q<<DiiooG %%c466K>>+w{{4'A'A4HHD !Ct,,D$002 2 
+E	:	: G G(94))':vFFFG G G G G G G G G G G G G G G Ks   (C88C<?C<c           
         t          |          |dz
  k    sJ t          j        t          j        |          }t          j        ||          }t          j        d          }t          |dz
            D ]}t          j        |          }	|                    d|	|          }
||         }|                    |
|	                    |	|          |	          }|
                    |t          j        ||d|                     |
                    |t          j        ||d|                     t          j        ||                    |                    S )z
    Compute shape with the new axis inserted
    e.g. given original shape (2, 3, 4) and axis=2,
    the returned new shape is (2, 3, 1, 4).
    rG   r  r   r   r   r  r
   r   rW   r8   r  r  r  r  rh   r   r>   )r}   r=   
orig_shaperp   r   ll_shtyr  r+  rx  ll_dim
after_axisr4  r   s                rC   _insert_axis_in_shaper    s8    z??dQh&&&&l7>400G '22F
.

C TAX I I$$((vt<<
_nnZ$[[55#% % 	b'.w3GGHHHH MM#w+GVQEEFFFf)=)=>>>rE   c           
         t          |          |dz
  k    sJ t          j        t          j        |          }t          j        ||          }t          j        d          }t          j        d          }t          |dz
            D ]}	t          j        |	          }
|                    d|
|          }|                    ||	                    |
|          |
          }|
                    ||	         t          j        ||d|                     |
                    |t          j        ||d|                     t          j        ||                    |                    S )zD
    Same as _insert_axis_in_shape(), but with a strides array.
    rG   r   r  r  )r}   r=   orig_stridesrp   r   r  r   r+  r   rx  r  r  r   s                rC   _insert_axis_in_stridesr    sR    |q((((l7>400G!'733G
.

C>!D TAX F F$$((vt<<
nnZ$[[55#% % 	l3'*7GQDD	F 	F 	F 	F
 MM$,Wgq$GGHHHg)>)>???rE   c           	         |j         }|j        }|j        d         } t          |          | ||d                   } t          |          | |          }	t	          j        ||j                  }
t	          j        ||j                  }t          | ||
||          }t          | ||||          }t          |	|j        |||j        |j        |j                   |	                                S )z/
    np.expand_dims() with the given axis.
    r   r
  r8  )r   rp   r   rx   r
   r   re   r   r  r  r   r   r   r   r   r   )r}   r=   r[   r   r   rQ  rp   r	  r
  rh  r  r   
new_shapesnew_stridess                 rC   expand_dimsr"    s     OE:DHQKE
*U

GWDG
<
<
<C
*U

GW
-
-C!'3955F"7CK88G&wtLLJ)'7GT4PPK3#&L;*& & & & ==??rE   c                     |j         dk    r|j        nd}|                    |j         dz   |          } |||          }d }||fS )NrG   rZ  r[  c                     |                      ||d         |j        d         t          j                  }t	          | |d|j        j        |          }t          | ||||          }t          | ||j        |          S )NrG   znp.expand_dims)	r   r   r   r   r  r   rp   r"  r!   )r}   r=   r[   r   r   rh  s         rC   rf  znp_expand_dims.<locals>.codegen(  sr    ||GT!Wchqk5:FFw1A"3T; ; '7Ct<< '3?CHHHrE   )rp   r  r\  )rg  r  r   r  rh  r[   rf  s          rC   np_expand_dimsr%  "  s_    1QXX#F
&&afqj&
0
0C
#a,,CI I I <rE   c                     t          | t          j                  sd|  }t          j        |          t          |t          j                  sd| }t          j        |          d }|S )Nz)First argument "a" must be an array. Got z(Argument "axis" must be an integer. Got c                 "    t          | |          S rB  )r%  )r  r   s     rC   r   z!impl_np_expand_dims.<locals>.impl=  s    a&&&rE   )r   r   r   r	   r   r   )r  r   r   r   s       rC   impl_np_expand_dimsr(  3  sz    a%% &=!== %%%dEM** &??? %%%' ' 'KrE   c                 8     t            fd            fdS )Nc                     |fd|D             fd}t          t                    dk    rt          j                  nd         t          j                            |                    |fS )Nc                 b    g | ]+}|                     t          |j                             ,S )rY  )r\  r  rp   )r   r  minimums     rC   r   z-_atleast_nd.<locals>.impl.<locals>.<listcomp>F  s3    HHHC#((CHg 6 6(77HHHrE   c                 <    t          
	          t          j        |d                   } fdt          |          D             }t	          |          dk    r                     |j        |          }n|d         }t           |j        |          S )Nr   c           	      6    g | ]\  }}} |||          S r   r   )r   r
  r	  rQ  r=   r}   	transforms       rC   r   z>_atleast_nd.<locals>.impl.<locals>.codegen.<locals>.<listcomp>L  sG     H H H)UE IgwUEBB H H HrE   rG   )_atleast_nd_transformr
   r   r   r   r  r   r!   )r}   r=   r[   r   arrsretsrh  r/  r-  r  r,  rG  s   ``     @rC   rf  z*_atleast_nd.<locals>.impl.<locals>.codegenH  s    -gt<<I'a99DH H H H H H-0vv-F-FH H HD 4yy1}}((#/4HH1g$WgsLLLrE   rG   r   )r%   r   r   r  StarArgTuple
from_types)typingcontextr   rf  r-  rG  r  r,  s      @@rC   r   z_atleast_nd.<locals>.implC  s    HHHH4HHH	M 	M 	M 	M 	M 	M 	M 	M FaV,,,VAY+66t<<> >?FG 	GrE   c                       |  S rB  r   )r   r   s    rC   r  z_atleast_nd.<locals>.<lambda>X  s    t rE   r  )r,  r  r   s   ``@rC   _atleast_ndr7  B  sD    G G G G G YG( %$$$$rE   c                 @      t                    k    sJ  fd}|S )z`
    Return a callback successively inserting 1-sized dimensions at the
    following axes.
    c           	         t          
          D ]s}|dz   }|j        |k     rat          j        	|                   }|                    |j        dz             }t          | |t          j        ||          |f|          }|}t|S )NrG   rY  )r8   rp   r
   r   r\  r"  r   r%   )r}   r=   r
  r	  rQ  rm   rp   r   newarrtyr  min_ndims            rC   r/  z(_atleast_nd_transform.<locals>.transformb  s    x 	! 	!Aq5DzD  ~d1g.. ::5:>:::!'7"("28U"C"CcV"&( ( !
rE   )r   )r;  r  r/  s   `` rC   r0  r0  [  sC    
 s4yy          rE   c                  Z    t          d | D                       rt          ddg          S d S )Nc              3   J   K   | ]}t          |t          j                  V  d S rB  rC  r  s     rC   rE  z np_atleast_1d.<locals>.<genexpr>t  .      
8
8C:c5;''
8
8
8
8
8
8rE   rG   r   r  r7  r  s    rC   np_atleast_1dr@  r  s=    

8
84
8
8
888 #1qc"""# #rE   c                  \    t          d | D                       rt          dddg          S d S )Nc              3   J   K   | ]}t          |t          j                  V  d S rB  rC  r  s     rC   rE  z np_atleast_2d.<locals>.<genexpr>z  r>  rE   r_  r   r?  r  s    rC   np_atleast_2drC  x  s?    

8
84
8
8
888 &1q!f%%%& &rE   c                  \    t          d | D                       rt          dg d          S d S )Nc              3   J   K   | ]}t          |t          j                  V  d S rB  rC  r  s     rC   rE  z np_atleast_3d.<locals>.<genexpr>  r>  rE   r2  )r   r   r_  r?  r  s    rC   np_atleast_3drF  ~  s?    

8
84
8
8
888 )1iii((() )rE   c	                    t          |          t          |          cxk    r't          |          cxk    rt          |          k    sn J t          j        d          }	t          | |||          }
t          j        ||
j                  }g }|D ]}|	}t          t          ||                    D ]s\  }\  }}|                    d|	                    |          |          }|
                    ||          }|                    ||                    ||          |          }t|                    |           |
j        }t          |||||          D ]\  }}}}}|j        }t          j        ||t          j        |j                  }|5 }t          j        | |||||j        |          }t%          | |||          }|                     |||j        |j                  }t          j        | |||||j        |          }t+          | ||||           ddd           n# 1 swxY w Y   t          j        |||          }|
S )z2
    Concatenate arrays along the given axis.
    r   r  )orderN)r   r
   r   r  r   r   r  r   r  r9   r   r  r  ri   r   r6  r  r  r   r   r{   r   r   )r}   r=   r   r-  r1  
arr_shapesarr_stridesrQ  
ret_shapesr   rh  ret_stridescopy_offsetsarr_shr  rx  r   r  is_axisaddendret_datar	  r
  arr_starr_datar6  r   r"  r   r9  s                                 rC   _do_concatenaterT    s    v;;#d))JJJJs:JJJJ#k:J:JJJJJJJ>!D '5*
=
=C&w<<K L 	$ 	$#,S-E-E#F#F 	, 	,C$))$		#EEG[[v..F^^G$+KK$?$?$*, ,FF 	F#### xH.1&$
2=|/M /M B B*sFFF8 %gvw~,1L: : :	  		?'/(0605gG GG GWeW==C,,wU[%+FFC0'81;[16wH HH wX>>>		? 		? 		? 		? 		? 		? 		? 		? 		? 		? 		? 		? 		? 		? 		? &w&AAJs   BH  H$	'H$	c                     |j         } fdt          ||          D             }t           d||          }fd|D             }fd|D             }fd|d         D             }	t          |          D ]                    d|                              |          }
|	         }                    |          }fd|d	d          D             }                    |
          5 \  }}|5  t          j	        j
        ||gz             }                    ||           d d d            n# 1 swxY w Y   |5  t          j        }|D ]-}                    |                    d||                    }.                                        |          d
          5   j                            t&          dz  f           d d d            n# 1 swxY w Y   d d d            n# 1 swxY w Y   d d d            n# 1 swxY w Y   fd|	D             }	t)           |||||||		  	        }t+           ||                                          S )Nc                 L    g | ] \  }} t          |          |           !S r
  r  r   r  r  r=   r}   s      rC   r   z#_np_concatenate.<locals>.<listcomp>  D     - - -Q JsOOGWA666 - - -rE   np.concatenatec                 D    g | ]}t          j        |j                  S r   )r
   r   re   r   r
  r=   s     rC   r   z#_np_concatenate.<locals>.<listcomp>  s(    KKKs'&w	::KKKrE   c                 D    g | ]}t          j        |j                  S r   r
   r   r   r\  s     rC   r   z#_np_concatenate.<locals>.<listcomp>  s(    NNN#7'==NNNrE   c                 :    g | ]}t          j        |          S r   )r
   r   r   r4  r=   s     rC   r   z#_np_concatenate.<locals>.<listcomp>  s6     + + + +GR88 + + +rE   r   r  c                      g | ]
}|         S r   r   )r   r4  rx  s     rC   r   z#_np_concatenate.<locals>.<listcomp>  s    999B3999rE   rG   FrY  z<np.concatenate(): input sizes over dimension %d do not matchc                 :    g | ]}                     |          S r   )r>   r`  s     rC   r   z#_np_concatenate.<locals>.<listcomp>  s%    888r',,r""888rE   )rp   r   r  r8   r  r9   r>   r   r>  r?  r  r  r
   r@  r  r  r  r[  r\  r   rT  r"   r   )r}   r=   r-  r1  rQ  r   rp   rI  rJ  rK  rO  ret_shape_ptrret_shother_shapeson_axison_other_dimr4  is_okrh  rx  s   ``                 @rC   _np_concatenateri    s   :D- - - - -fd++- - -D 7G-=tTJJD LKKKdKKKJNNNNNNNK
+ + + +&qM+ + +J T{{ > >%%dDIIcNNDAA"3m,,9999*QRR.999__W%% 	>)@'< 1 1%K F8+- - b-000	1 1 1 1 1 1 1 1 1 1 1 1 1 1 1  	> 	>(& P PB#LL)0)<)<T2v)N)NP PEE__W\\%%8%8_GG > >%5557:; => > >> > > > > > > > > > > > > > >	> 	> 	> 	> 	> 	> 	> 	> 	> 	> 	> 	> 	> 	> 	>	> 	> 	> 	> 	> 	> 	> 	> 	> 	> 	> 	> 	> 	> 	>$ 9888Z888J
'7D $
K- -C GWeS]]__EEEs   /H
55D6*H
6D::H
=D:>H
A'G3*&G	G3G  G3#G $G3'H
3G77H
:G7;H

H	H	c                 	    |j         }t          j        d          }t          j        d          }t          j        t          |                    }	 fdt	          ||          D             }t           d||          }t          j        |d         j                  }
|dd          D ]}t          j        }t	          t          j        |j                  |
          D ]\  }}	                    |
                    d||                    }                                        |          d          5   j                            t          d           d d d            n# 1 swxY w Y   ˈfd	|D             }t!          j        t          j        |          t          j                  }t          j                  }t'          |dz
            D ]}t          j        |          }
                    d
||          }|
|         }                    |                    ||          |          }                    |t          j        |d|                                         |t          j        |d|                                         |t          j        |d|                                         |	t          j        |d|                     t          j                            |                    }|gt          |          z  }t          j                            |                    }fdt'          t          |                    D             }t'          |dz
            D ]}t          j        |          }
                    d
||          }                    |                    ||          |          }t'          t          |                    D ]?}                    ||         |         t          j        ||         d|                     @t'          t          |                    D ]3}                    |t          j        ||         d|                     4fd|D             }t3           |||||||	  	        }t5           ||                                          S )Nr   rG   c                 L    g | ] \  }} t          |          |           !S rW  r  rX  s      rC   r   z_np_stack.<locals>.<listcomp>  rY  rE   np.stackr  FrY  )z5np.stack(): all input arrays must have the same shapec                 D    g | ]}t          j        |j                  S r   r^  r\  s     rC   r   z_np_stack.<locals>.<listcomp>  s(    OOO3G(#+>>OOOrE   r  c                 :    g | ]}t          j                  S r   r  )r   rm   r=   r  s     rC   r   z_np_stack.<locals>.<listcomp>-  s6     0 0 0 (':: 0 0 0rE   c                 `    g | ]*}t          j                            |                    +S r   )r
   r   r>   )r   r5  r=   s     rC   r   z_np_stack.<locals>.<listcomp>B  sB     . . . )'7<<3C3CDD . . .rE   )rp   r
   r   r   r   r  r   re   r@  r  r  r  r  r[  r\  r   r   r  rW   r8   r  r  r  rh   r>   rT  r"   r   )r}   r=   r-  r1  rQ  r   rp   r   r+  
ll_narraysr  r
  rh  r4  orig_shr  input_shapesrK  rx  r  r  r   input_stridesrm   rh  r  s   ``                       @rC   	_np_stackrt    sh   :D>!D
.

CD		**J- - - - -fd++- - -D 7GZtDDD %gtAw}==JABBx P P w3GSYGG)+ + 	P 	PKBLL(;(;D"g(N(NOOEe!4!4UCC P P!11ZNP P PP P P P P P P P P P P P P P P	P POOO$OOOL
 l7>400G&w88L$Wg66J TAX M M$$((vt<<
_nnZ$[[55#% % 	b'.waMMNNNb'.w
AsKKLLLL MM#w+G\1dKKLLLMM*g273=34379 9 : : :
 'l1K1KLLL >CII-L%gw||J/G/GHHJ0 0 0 0 0#CII..0 0 0M TAX 	5 	5$$((vt<<
nnZ$[[55#% % s4yy!! 	5 	5AMM,q/#.!.wa8H!/24 45 5 5 5	5 3t99 8 8dG0-:JA157 7 	8 	8 	8 	8. . . .,. . .M '7D $m- -C GWeS]]__EEEs   >"E,,E03E0c                     |t          |t          j                  sd S t          | d|          \  }}|dk    rd}t	          j        |          t          |          }t          j        |||          S )NrZ  r   z.zero-dimensional arrays cannot be concatenated)r   r   r   r5   r	   r:  r6   r   )rg  r)  r   r{   rp   r   r  s          rC   np_concatenate_typerrv  L  s~    
4 ? ? 	 &i&6@ @KE4qyy>#C((()&11F;udF+++rE   c                     t          | ||          }t          |t          j                  sJ  |||          }d }||fS )Nc           
          |                      ||d         |j        d         t          j                  }t	          | |t          |j        d                   t          j        ||d                   |j        |          S r  )	r   r   r   r   ri  r   r
   r   r   r}   r=   r[   r   r   s        rC   rf  znp_concatenate.<locals>.codegend  sh    ||GT!Wchqk5:FFw#CHQK00&3GT!WEE"#	% % 	%rE   )rv  r   r   r   )rg  r)  r   rh  r[   rf  s         rC   np_concatenaterz  ^  sW    
y&$
7
7Cc5;'''''
#fd

C% % % <rE   c                 F    t          | t          j                  rdd}|S d S )Nr   c                 "    t          | |          S rB  )rz  r)  r   s     rC   r   z!impl_np_concatenate.<locals>.implr  s    !&$///rE   r  r   r   rL  r)  r   r   s      rC   impl_np_concatenater  o  s9    &%/** 	0 	0 	0 	0 rE   c                 h    |D ].}|j         dk     s|j         dk    rd}t          j        |          /dS )NrG   r_  z7np.column_stack() is only defined on 1-d and 2-d arrays)rp   r	   r:  )r}   r   r)  r  r   s        rC   _column_stack_dimsr  w  sH     - -6A::!KC',,, $ 1rE   c                     t          | d|t                    \  }}t          |          }t          j        |||          } ||          }d }||fS )Nznp.column_stack)dim_chooserc                 j   t          |j        d                   }t          j        ||d                   }g }g }|                     t
          j        d          }t          ||          D ]\  }	}
|	j        dk    r+|	                    |	           |	                    |
           ;|	j        dk    sJ |	
                    d          }t          j        ||	          }t          | |||
f|          }|	                    |           |	                    |           t          | ||||j        |          S )Nr   rG   r_  rY  )r   r   r
   r   r   r   r   r   rp   ri   r\  r   r%   r"  ri  r   )r}   r=   r[   r   orig_arrtys	orig_arrsr-  r1  r   r	  r
  r  
expand_signewarrs                 rC   rf  z np_column_stack.<locals>.codegen  s0   38A;''($q'::	##EJ22k955 	$ 	$JE3zQe$$$C     zQ


**#-eU;;
$WgzC64PPe$$$F####w"6 6 	6rE   )r5   r  r6   r   r   )rg  rI  r{   rp   r  rh  r[   rf  s           rC   np_column_stackr    sq    %i&72DF F FKE4 *#..F
+eT6
*
*C
#c((C6 6 64 <rE   c                 D    t          | t          j                  rd }|S d S )Nc                      t          |           S rB  )r  rI  s    rC   r   zimpl_column_stack.<locals>.impl  s    "3'''rE   r~  rI  r   s     rC   impl_column_stackr    s4    #u'' 	( 	( 	( rE   c           
          t          | |t          |j        d                   t          j        ||d                   |j        |          S )z/
    np.stack() with the given axis value.
    r   )rt  r   r   r
   r   r   ry  s        rC   _np_stack_commonr    sG     Wg#(1+&&)'47;;_	  rE   c                     t          | d|          \  }}t          d |D                       rdnd}t          j        ||dz   |          } |||          }d }||fS )Nrl  c              3   ,   K   | ]}|j         d k    V  dS )r  N)r  r  s     rC   rE  z"np_stack_common.<locals>.<genexpr>  s(      88AC888888rE   r  r   rG   c                     |                      ||d         |j        d         t          j                  }t	          | ||||          S r  )r   r   r   r   r  ry  s        rC   rf  z np_stack_common.<locals>.codegen  s;    ||GT!Wchqk5:FF#tTBBBrE   )r5   r  r   r   )	rg  r)  r   r{   rp   r  rh  r[   rf  s	            rC   np_stack_commonr    s     &i&0&: :KE48888888ASScF
+eTAXv
.
.C
#fd

CC C C <rE   c                 F    t          | t          j                  rdd}|S d S )Nr   c                 "    t          | |          S rB  )r  r}  s     rC   r   zimpl_np_stack.<locals>.impl  s    "64000rE   r  r~  r  s      rC   impl_np_stackr    s9    &%/** 	1 	1 	1 	1 rE   c                     t          | ||          \  }}t          ||          }t          |          }t          j        |||          }|S rB  )r5   r  r6   r   r   )rg  r   r)  ndim_minr{   rp   r  rh  s           rC   NdStack_typerr    sK    %iFCCKE4tXD)&11F
+eT6
*
*CJrE   c                 J    t          | d|d          } ||          }d }||fS )Nz	np.hstackrG   c                     |j         d         }|d         j        }|dk    r3|                     t          j        d          t          | |||          S |dk    rdndfd}|                     ||||          S )Nr   rG   c                 0    t          j        |           S rt  rv  r}  s    rC   np_hstack_implz3_np_hstack.<locals>.codegen.<locals>.np_hstack_impl  s    ~f48888rE   r   rp   r   r   r   r  r  )r}   r=   r[   r   rH  rp   r  r   s          @rC   rf  z_np_hstack.<locals>.codegen  s    Qx}199''
A66D#GWc4FFF
 		11qD9 9 9 9 9 ++G^S$OOOrE   r  rg  rI  rh  r[   rf  s        rC   
_np_hstackr    s@    
	;Q
7
7C
#c((CP P P& <rE   c                 D    t          | t          j                  rd }|S d S )Nc                      t          |           S rB  )r  r  s    rC   r   zimpl_np_hstack.<locals>.impl      c??"rE   r~  r  s     rC   impl_np_hstackr    4    #u'' 	# 	# 	# rE   c                 J    t          | d|d          } ||          }d }||fS )Nz	np.vstackr_  c                     |j         d         }|d         j        }|dk    rd }n<|dk    r3|                     t          j        d          }t          | ||||          S d }|                     ||||          S )Nr   c                 P    t          j        t          j        |           d          S r  )rz  r"  hstackr)  s    rC   np_vstack_implz3_np_vstack.<locals>.codegen.<locals>.np_vstack_impl  s    ~bi&7&7;;;rE   rG   c                 .    t          j        | d          S )Nr   ru  rv  r  s    rC   r  z3_np_vstack.<locals>.codegen.<locals>.np_vstack_impl      ~f15555rE   r  )r}   r=   r[   r   rH  rp   r  r   s           rC   rf  z_np_vstack.<locals>.codegen  s    Qx}199< < < < QYY''
A66D#GWc4FFF6 6 6 ''dKKKrE   r  r  s        rC   
_np_vstackr    s@    
	;Q
7
7C
#c((CL L L& <rE   c                 D    t          | t          j                  rd }|S d S )Nc                      t          |           S rB  )r  r  s    rC   r   zimpl_np_vstack.<locals>.impl  r  rE   r~  r  s     rC   impl_np_vstackr    r  rE   c                 J    t          | d|d          } ||          }d }||fS )Nz	np.dstackr2  c                    |j         d         }|j        }|d         j        }|dk    rd }|                     ||||          S |dk    r|                     t
          j        d          }|                    |j        dz
            }	t          j	        |	g|j         R  }
t          | ||
||          }|                     t
          j        d          }t          j	        ||	          }t          | |||f|          S |dk    r3|                     t
          j        d          }t          | ||||          S d }|                     ||||          S )Nr   c                 T    t          j        |                               ddd          S )NrG   r  )rz  r  r]  r  s    rC   r  z3_np_dstack.<locals>.codegen.<locals>.np_vstack_impl/  s$    y((00Ar:::rE   rG   rY  r_  c                 .    t          j        | d          S )Nr_  ru  rv  r  s    rC   r  z3_np_dstack.<locals>.codegen.<locals>.np_vstack_implF  r  rE   )r   r   rp   r  r   r   r   r\  r   r%   r  r"  )r}   r=   r[   r   rH  rQ  rp   r  r   stack_retty	stack_sig	stack_retr  s                rC   rf  z_np_dstack.<locals>.codegen)  sd   Qx}199; ; ; ++G^S$OOOQYY''
A66D**%*q.*99K(@sx@@@I('9d)-/ /I ''
A66D)%==Jwi\4PPPQYY''
A66D#GWc4FFF6 6 6 ++G^S$OOOrE   r  r  s        rC   
_np_dstackr  $  sA    
	;Q
7
7C
#c((C P  P  PD <rE   c                 D    t          | t          j                  rd }|S d S )Nc                      t          |           S rB  )r  r  s    rC   r   zimpl_np_dstack.<locals>.implQ  r  rE   r~  r  s     rC   impl_np_dstackr  N  r  rE   fillc                     d }|S )Nc                     || d d <   d S rB  r   )r
  r   s     rC   	fill_implzarr_fill.<locals>.fill_implY  s    AAAtrE   r   )r
  r   r  s      rC   arr_fillr  V  s       rE   dotc                     d }|S )Nc                 ,    t          j        | |          S rB  )rz  r  )r
  others     rC   dot_implzarray_dot.<locals>.dot_implb  s    vc5!!!rE   r   )r
  r  r  s      rC   	array_dotr  `  s    " " " OrE   c                 X    t          |           st          j        d| z            d }|S )NzCannot np.fliplr on %s typec                 ~    t          j        |           }|j        dk     rt          d          |d d d d ddf         S )Nr_  r/  r  .rz  r{  rp   r   r  rZ  s     rC   r   znp_flip_lr.<locals>.impln  sF    JqMM 6A::4555TTrT3rE   r  r  r   s     rC   
np_flip_lrr  h  sB     A D !>!BCCC      KrE   c                 X    t          |           st          j        d| z            d }|S )NzCannot np.flipud on %s typec                 x    t          j        |           }|j        dk     rt          d          |d d ddf         S )NrG   zInput must be >= 1-d.r  .r  r  s     rC   r   znp_flip_ud.<locals>.impl  s?    JqMM 6A::45552s|rE   r  r  s     rC   
np_flip_udr  y  sB     A D !>!BCCC   KrE   c                     t          |t          j                  st          j        |          t          |j                  t          j        t          j                   |          }fd}||fS )zY Creates a tuple of slices for np.flip indexing like
    `(slice(None, None, -1),) * sz` r  c                     d }t           j        g}t          j        g|R  }|                     t           j                  }|                               } |          |g}	|                     ||||	          }
|
S )Nc           
      n    |}t          |           D ]"}t          ||t          d d d                    }#|S )Nr  )r8   r/   r3  )lengthempty_tupler   rm   s       rC   r   z6_build_flip_slice_tuple.<locals>.codegen.<locals>.impl  sB    C6]] C C#CE$b,A,ABBJrE   )r   r   r   r%   r   get_constant_undefr  )r}   r=   r%   r   r   inner_argtypes	inner_sigll_idx_typer  
inner_argsr   r   
tuple_types              rC   rf  z(_build_flip_slice_tuple.<locals>.codegen  s    	 	 	  *j1$ZA.AAA	,,UZ8800<<!k$''5
&&wiLL
rE   )	r   r   r  r	   r  r   r   r  slice3_type)r  szr[   rf  r   r  s       @@rC   _build_flip_slice_tupler    s     b%.// -(,,,r  De&7tDDDJ
*R..C     " <rE   c                 n    t          | t          j                  st          j        d| z            d }|S )NzCannot np.flip on %s typec                 :    t          | j                  }| |         S rB  )r  rp   )r  sls     rC   r   znp_flip.<locals>.impl  s    $QV,,urE   )r   r   r   r	   r   r  s     rC   np_flipr    sF     a%% B !<q!@AAA   KrE   c                    t          | t          j        t          j        t          j        f          rdd}|S t          |t          j                  rdd}|S t          |t          j                  r*t          |j        j        t          j                  rdd}|S t          |t          j	                  r$t          d |j        D                       rdd}|S d S d S )Nr   c                 T    t          j        t          j        |           ||          S rt  )rz  array_splitr{  r   indices_or_sectionsr   s      rC   r   znp_array_split.<locals>.impl  s,    >
3#   rE   c                     t          | j        |         |          \  }}t          j        t          j        |dz   g|z  |g||z
  dz
  z  z                       }t          j        | ||          S )NrG   ru  )divmodre   rz  cumsumr   r  )r   r  r   r   r  r   s         rC   r   znp_array_split.<locals>.impl  s{    CIdO-@AAFAsiQ#*S01456! !  G >#wT::::rE   c                 V   t          | j                  }t          dd| j        |          }g }d}|D ]>}t          ||t	          ||                    }|                    | |                    |}?|                    | t          ||t	          |d                                         |S Nznp.splitr   r   )r0   rp   r   r/   r3  ri   r   r  r   	slice_tupr   prevr  r   s           rC   r   znp_array_split.<locals>.impl  s    .sx88I!*fchEEDCD*  #ItU45E5EFF

3s8$$$JJs=D%T:J:JKKLMMMJrE   c              3   J   K   | ]}t          |t          j                  V  d S rB  r   r   r   )r   rF  s     rC   rE  z!np_array_split.<locals>.<genexpr>  s.      PP
1em,,PPPPPPrE   c                 p   t          | j                  }t          dd| j        |          }g }d}t          |          D ]>}t	          ||t          ||                    }|                    | |                    |}?|                    | t	          ||t          |d                                         |S r  )r0   rp   r   r   r/   r3  ri   r  s           rC   r   znp_array_split.<locals>.impl  s    .sx88I!*fchEEDCD%&9::  #ItU45E5EFF

3s8$$$JJs=D%T:J:JKKLMMMJrE   r  )r   r   r  ListTyper  r   IterableTypeiterator_typer  r  r  r   r  r   r   s       rC   np_array_splitr    s(   #
CDD 	 	 	 	 %u}55 0	; 	; 	; 	;  	&(:;;%-8M
 
%
	 
	 
	 
	  	&44PP6I6OPPPPP
	 
	 
	 
	 !   rE   c                     t          | t          j        t          j        t          j        f          rdd}|S t          |t          j                  rdd}|S t          | ||          S )Nr   c                 T    t          j        t          j        |           ||          S rt  )rz  splitr{  r  s      rC   r   znp_split.<locals>.impl  s"    8BJsOO-@tLLLLrE   c                     t          | j        |         |          \  }}|dk    rt          d          t          j        | ||          S )Nr   z0array split does not result in an equal divisionru  )r  re   r   rz  r  )r   r  r   r  r  s        rC   r   znp_split.<locals>.impl   s]    CIdO-@AAFAsaxx F   >(t   rE   ru  r  )r   r   r  r  r  r   r  r  s       rC   np_splitr    s     #
CDD 	M 	M 	M 	M %u}55 C	 	 	 	  c#6TBBBBrE   c                    t          | t          j                  sd}t          j        |          t          |t          j        t          j        t          j        t          j        f          sd}t          j        |          d }|S )N#The argument "ary" must be an array:The argument "indices_or_sections" must be int or 1d-arrayc                 d    | j         dk     rt          d          t          j        | |d          S )Nr_  z3vsplit only works on arrays of 2 or more dimensionsr   ru  rp   r   rz  r  r   r  s     rC   r   znumpy_vsplit.<locals>.impl  s?    8a<< ? A A Ax0q9999rE   r   r   r   r	   r   r   r  r  r   r  r   r   s       rC   numpy_vsplitr        c5;'' &3 %%%)EM5;,1J,H I I &K %%%: : : KrE   c                    t          | t          j                  sd}t          j        |          t          |t          j        t          j        t          j        t          j        f          sd}t          j        |          d }|S )Nr  r  c                     | j         dk    rt          d          | j         dk    rt          j        | |d          S t          j        | |d          S )Nr   z3hsplit only works on arrays of 1 or more dimensionsrG   ru  r  r  s     rC   r   znumpy_hsplit.<locals>.impl/  sb    8q== ? A A A8a<<8C!41====x0q9999rE   r  r  s       rC   numpy_hsplitr  $  s    c5;'' &3 %%%)EM5;,1J,H I I &K %%%: : : KrE   c                    t          | t          j                  sd}t          j        |          t          |t          j        t          j        t          j        t          j        f          sd}t          j        |          d }|S )Nr  r  c                 d    | j         dk     rt          d          t          j        | |d          S )Nr2  z3dsplit only works on arrays of 3 or more dimensionsr_  ru  r  r  s     rC   r   znumpy_dsplit.<locals>.implE  s<    8a<< * + + +x0q9999rE   r  r  s       rC   numpy_dsplitr  :  r	  rE   c                     | |k     S )z7
    Trivial comparison function between two keys.
    r   r  s     rC   
default_ltr  T  s     q5LrE   Fc                     | |j         |f}	 t          |         S # t          $ rW | dk    rt          j        ||d          }|j        }n#| dk    rt          j        ||          }|j        }|t          |<   |cY S w xY w)z6
    Get a sort implementation of the given kind.
    r,   T)lt
is_argsortis_np_arrayr-   )r  r  )	rq   _sortsKeyErrorr,   make_jit_quicksortrun_quicksortr-   make_jit_mergesortrun_mergesort)r~  lt_implr  keyr  funcs         rC   get_sort_funcr  [  s      *
,Cc{   ;/% " " "D %DD[  /%' ' 'D %Dss    AA:9A:c                     t          | t          j                  rt          S t          | t          j                  rt
          S t          S rB  )r   r   rg  r   r  r   r  r  s    rC   lt_implementationr!  s  s<    %%% 	E5=	)	) rE   z
array.sortc                     |j         d         }t          dt          |j                            fd}|                     ||||          S )Nr   r,   )r~  r  c                      |            d S rB  r   r
  	sort_funcs    rC   array_sort_implz#array_sort.<locals>.array_sort_impl  s    	#rE   )r   r  r!  r{   r  )r}   r=   r[   r   r  r&  r%  s         @rC   
array_sortr'  |  si    hqkG;&7&F&FH H HI     ##G_c4HHHrE   c                 R    t          |           st          j        d          d }|S )NzArgument "a" must be array-likec                 V    |                                  }|                                 |S rB  )r\  r  )r  r   s     rC   np_sort_implz"impl_np_sort.<locals>.np_sort_impl  s!    ffhh



rE   r  )r  r*  s     rC   impl_np_sortr+    sC    A 2  "1 2 2 	2   rE   zarray.argsortc                    	 |j         \  }}t          |j        t          |j                  d          		fd}|                    |j         d d                   }|d d         }|                     ||||          S )NT)r~  r  r  c                      |           S rB  r   r$  s    rC   array_argsort_implz)array_argsort.<locals>.array_argsort_impl  s    y~~rE   rG   r  )r   r  r   r!  r{   replacer  )
r}   r=   r[   r   r  r~  r.  innersig	innerargsr%  s
            @rC   array_argsortr2    s     HMGT4#5&7&F&F)-/ / /I     {{!{--HRaRI##G-?$,i9 9 9rE   c                 @    |j         |j         k    s|j        dk    sJ |S )NrZ  )r?  r  )r}   r=   rK  rL  r   s        rC   array_to_arrayr4    s*     >T\))T[C-?-?-?-?JrE   c                     d }t          ||          }|                     ||||g          }t          | ||j        |          S )Nc                 ,    |                      d          S r   )rP  r  s    rC   r   zarray0d_to_scalar.<locals>.impl  s    vvayyrE   )r%   r  r#   r   r}   r=   rK  rL  r   r   r[   r   s           rC   array0d_to_scalarr8    sS       D&
!
!C

"
"7D#u
=
=CgwEEErE   c                     d }t          ||          }|                     ||||g          }t          | ||j        |          S )Nc                 ,    t          | d                   S r  r  r  s    rC   r   z array_to_unichrseq.<locals>.impl  s    1R5zzrE   )r%   r  r!   r   r7  s           rC   array_to_unichrseqr;    sS       D&
!
!C

"
"7D#u
=
=CWgsDDDrE   c                     t           )zR
    An intrinsic returning a derived array with the given shape and strides.
    r   )r  re   r   s      rC   reshape_uncheckedr=    s
     rE   c                     d fd}|S )Nc                 h    t          | t          j                  ot          d | D                       S )Nc              3   J   K   | ]}t          |t          j                  V  d S rB  r  r6  s     rC   rE  z>type_reshape_unchecked.<locals>.check_shape.<locals>.<genexpr>  s.      @@QJq%-00@@@@@@rE   )r   r   rL  r  re   s    rC   r(  z+type_reshape_unchecked.<locals>.check_shape  s7    5%/22 A@@%@@@@@	BrE   c                     t          | t          j                  sd S  |          r |          sd S t          |          t          |          k    rd S |                     t          |          d          S )NrZ  r[  )r   r   r   r   r\  )r  re   r   r(  s      rC   typerz%type_reshape_unchecked.<locals>.typer  s|    !U[)) 	F{5!! 	W)=)= 	Fu::W%%Fvv3u::cv222rE   r   )r}   rC  r(  s     @rC   type_reshape_uncheckedrD    s5    B B B3 3 3 3 3 LrE   c                    |j         d         }|j        } t          |          | ||d                   } t          |          | |          }t          j        ||d                   }t          j        ||d                   }	t          ||j        ||	|j        |j                   |	                                }
t          | |||
          S )Nr   rG   r_  r  )r   r   rx   r
   r   r   r   r   r   r   r!   )r}   r=   r[   r   r   rQ  r   r   re   r   r   s              rC   impl_shape_uncheckedrF    s    HQKEOE
*U

GWd1g
6
6C
*U

GW
-
-C $q'22E"7DG44G3"L;    --//CWguc:::rE   c                     |d t           j        fv rt          d             nt          d             |d t           j        fv rt          j        d          t          d             dfd	}|S )Nc                     | j         S rB  rA  rM  re   s     rC   rm  zas_strided.<locals>.get_shape  s	    7NrE   c                     |S rB  r   rI  s     rC   rm  zas_strided.<locals>.get_shape  s    LrE   z,as_strided() strides argument cannot be Nonec                     |S rB  r   )rM  r   s     rC   get_strideszas_strided.<locals>.get_strides  s    NrE   c                 R    t          |  | |           | |                    } | S rB  )r=  )rM  re   r   rm  rL  s      rC   as_strided_implz#as_strided.<locals>.as_strided_impl  s1    a1e!4!4kk!W6M6MNNrE   r  )r   r+  r'   r	   r   )rM  re   r   rN  rm  rL  s       @@rC   
as_stridedrO     s    uz"""		 	 
		 	 
	 	 
		 4$$$
  !OPPP		 	 
		       rE   c                    t          |t          j                  rYt          t	          | j        dz                       t          t	          | j        dz                       t          d             nt          |t          j                  rt          |j        t          j                  rst          t	          | j        t          |          z                       t          t	          | j        t          |          z                       t          d             nt          j        d          t          |          rt          d             nt          |t          j                  rt          d             n^t          |t          j                  r0t          |j        t          j                  rt          d             nt          j        d          d
fd		}|S )NrG   c                     | fS rB  r   window_shapes    rC   get_window_shapez-sliding_window_view.<locals>.get_window_shape'  s
     ?"rE   c                     | S rB  r   rR  s    rC   rT  z-sliding_window_view.<locals>.get_window_shape0  s    rE   z4window_shape must be an integer or tuple of integersc                 :    t          t          |                    S rB  )r   r8   rS  r   rp   s      rC   get_axisz%sliding_window_view.<locals>.get_axis;  s    d$$$rE   c                 (    t          dd||          gS )Nsliding_window_viewr   r   rW  s      rC   rX  z%sliding_window_view.<locals>.get_axis@  s      4fdDII rE   c                      fd|D             S )Nc                 4    g | ]}t          d d|          S )rZ  r   r[  )r   r  rp   s     rC   r   z9sliding_window_view.<locals>.get_axis.<locals>.<listcomp>J  s8     # # # ##8&$JJ # # #rE   r   rW  s     `rC   rX  z%sliding_window_view.<locals>.get_axisH  s.    # # # #!# # # #rE   z2axis must be None, an integer or tuple of integersc                     |          } 
||| j                   }t          |          t          |          k    rt          d          }}t          | j                   D ]:}t	          ||| j        |                   }t	          ||| j        |                   };| j         }t          ||          D ]\  }}|dk     rt          d          ||         |k     rt          d          ||         |z
  dz   }t	          |||          }t	          |||          }t	          ||| j        |                   }|dz  }t          | ||          }	|	S )Nz2Must provide matching length window_shape and axisr   z-`window_shape` cannot contain negative valuesz4window_shape cannot be larger than input array shaperG   )	rp   r   r   r8   r/   re   r   r   r=  )rM  rS  r   	out_shapeout_stridesrm   r0  rx  trimmedrL  rX  rT  shape_bufferstride_buffers             rC   sliding_window_view_implz5sliding_window_view.<locals>.sliding_window_view_implR  s   ''55xdAF33|D		))D  
 !	#qv 	F 	FA%iAGAJ??I'Q	!EEKK F4.. 	 	GBQww C   }s"" J    mc)A-G%iW==I%iC88I'Q	"FFKFAA !I{;;rE   rB  )r   r   r   r   r8   rp   r'   r  r{   r   r	   r   r   )rM  rS  r   rd  rX  rT  rb  rc  s       @@@@rC   rZ  rZ    s     ,.. 
U16A:..//eAFQJ//00		# 	# 
		# 	# \5>
2
2 
|)5=99
U16C,=,=#=>>??eAFS->->$>??@@		  	  
		  	   B
 
 	

 4 
		% 	% 
		% 	% 
D%-	(	( 
		 	 
		 	
 T5>
*
* 

tz5=11

		# 	# 
		# 	#
  @
 
 	
% % % % % % % % %N $#rE   c                 D    t          | t          j                  rd }|S d S )Nc                     | j         dk    rdS | j         dk    r"t          |                     d                    S d}t          |          )Nr   FrG   z[The truth value of an array with more than one element is ambiguous. Use a.any() or a.all())r   rM  rP  r   )r
  r   s     rC   r   zol_bool.<locals>.impl  sH    x1}}uQCHHQKK(((> oo%rE   rC  rx  s     rC   ol_boolrg  |  s6    #u{## 
	& 	& 	& 
 
rE   c                    t          |t          t          j        f          st	          j        d          t          |t          t          j        f          st	          j        d          t          | t          j                  st	          j        d          | j        t          t                              fd}|S )Nz.The second argument "axis1" must be an integerz-The third argument "axis2" must be an integerz'The first argument "a" must be an arrayc                     t          dd|          }t          dd|          }|dk     r|z  }|dk     r|z  }t          ||          }t          |||          }t          j        | |          S )Nznp.swapaxesaxis1axis2r   )r   r/   rz  r  )r  rj  rk  
axes_tuple	axes_listrp   s       rC   r   znumpy_swapaxes.<locals>.impl  s    }gtUCC}gtUCC 199TME199TME"9eU;;
":ue<<
|Az***rE   )
r   r   r   r   r	   r   r   rp   r   r8   )r  rj  rk  r   rm  rp   s       @@rC   numpy_swapaxesrn    s    ec5=122 ,  "+ , , 	,ec5=122 ,  "+ , , 	,a%% L !JKKK 6DeDkk""I+ + + + + + KrE   c                 ~   t          dd| j        |          }t          | j                  }d||<   t	          t          ||j                            D ]B\  }\  }}	|dk    r|	}
n |	dk    r|}
n||	k    rt          d          |}
t          |||
          }Ct          ||| j        |                   }t          j	        | |          } t          j	        ||          }|}t          |          dk    r;t          t          |                    D ]}t          ||| j        |                   }|}t          |          dk    rAt          t          |                    D ]$}t          ||| j        |dz   |z                      }%|j        |         }t          j        ||fz   |z   | j                  }t          d d d           f}t          j        |          D ]f}t          j        |          D ]O}| ||z   |z            }|||z   |z            }|||z   |z            }t          |          D ]}|||                  ||<   Pg|S )Nznp.take_along_axisr   rG   z*`arr` and `indices` dimensions don't matchr   )r   rp   r   re   r  r   r   r/   rz  r  r   r8   r  r{   r3  r  )r
  r   r   Ni_origNk_origindices_broadcast_shape	arr_shaperm   d1d2new_valarr_broadcast_shapeNiNkJr   np_s_iikka_1d
indices_1dout_1drE  s                          rC   _take_along_axis_implr    sy    .$GGD SYIIdO Y!>!>?? 
 
8B77GG1WWGGRxx @   G"/#Q#
 #
 (sy  /#2
3
3Cog'>??G	B
7||as2ww 	4 	4Ar1cil33BB	B
7||as2ww 	? 	?Ar1ciq1&=>>BBdA
(29r>39
-
-C4t$$&Ejnn 0 0*R.. 	0 	0BrEzB'D eb1Jeb)F1XX 0 0 A/q		0		0 JrE   c                    t          | t          j                  st          j        d          t          |t          j                  st          j        d          t          |j        t          j                  st          j        d          t          |          rd}n| j        }||j        k    rt          j        d          t          t          |j                            t          |          rfd}nt          |d           t          |t          j                  st          j        d          |j        }|d	k     r
| j        |z   }|d	k     s|| j        k    rt          j        d
          t          t          |                    t          t          |dz   | j                            fd}|S )Nz)The first argument "arr" must be an arrayz.The second argument "indices" must be an arrayz'The indices array must contain integersrG   z;`indices` and `arr` must have the same number of dimensionsc                 P    t          |                                 |ddd          S )Nr   r   )r  r}  )r
  r   r   rr  s      rC   take_along_axis_implz1arr_take_along_axis.<locals>.take_along_axis_impl  s-    (B)@B B BrE   r   zaxis must be a literal valuer   zaxis is out of boundsc                 ,    t          | ||          S rB  )r  )r
  r   r   rx  ry  rr  s      rC   r  z1arr_take_along_axis.<locals>.take_along_axis_impl  s%    (gtR)@B B BrE   )r   r   r   r	   r   r{   r   r   rp   r   r8   r   r  r6  r   )r
  r   r   arr_ndimr  rx  ry  rr  s        @@@rC   arr_take_along_axisr    s   c5;'' N !LMMMgu{++ > <> > 	>gmU]33 L !JKKK4 87< I
 
 	
 $E',$7$7884 B	B 	B 	B 	B 	B 	B 	v&&&$ 455 	I()GHHH!!888d?D!88tsx''()@AAA5;;538,,--	B 	B 	B 	B 	B 	B 	B  rE   T        c                 b   t          | t          j                  rqt          | t          j                  rdd}nt          | t          j                  rdd}nt          | t          j                  rdd}nt          j        d          t          |           rt          | j	        t          j                  rdd}npt          | j	        t          j                  rdd}nLt          | j	        t          j                  rdd	}n(t          j        d          t          j        d
          |S )NTr  c                     | S rB  r   rM  r\  nans      rC   r   znan_to_num_impl.<locals>.impl      rE   c                    t          j        |           r|S t          j        |           r&t          j        t	          |                     j        S t          j        |           r&t          j        t	          |                     j        S | S rB  )rz  isnanisneginffinfor9   r  isposinfr  r  s      rC   r   znan_to_num_impl.<locals>.impl  sn    8A;; 1J[^^ 18DGG,,00[^^ 18DGG,,00rE   c                     t          j        | j        |          }t          j        | j        |          }t	          ||          S )N)r  )rz  
nan_to_numr   r"  complex)rM  r\  r  r  r  s        rC   r   znan_to_num_impl.<locals>.impl%  s<    M!&c222M!&c222q!}}$rE   z4Only Integer, Float, and Complex values are acceptedc                     | S rB  r   r  s      rC   r   znan_to_num_impl.<locals>.impl1  r  rE   c                    t          j        | j                  j        }t          j        | j                  j        }t          j        |           }|rt          j        |          n|}|j        }t          |j	                  D ]a}t          j
        ||                   r|||<   "t          j        ||                   r|||<   Bt          j        ||                   r|||<   b|S rB  )rz  r  r{   r  r  r{  r\  r  r8   r   r  r  r  )	rM  r\  r  min_infmax_infx_outputoutput_flatrm   s	            rC   r   znan_to_num_impl.<locals>.impl4  s    (17++/(17++/Z]](,4"$kv{++ 1 1AxA// 1),A[^44 1)0A[^44 1)0ArE   c                     t          j        |           }|rt          j        |          n|}t          j        |j        d|           t          j        |j        d|           |S )NF)r\  r  )rz  r{  r\  r  r   r"  )rM  r\  r  r  r  s        rC   r   znan_to_num_impl.<locals>.implE  s\    Z]](,4"fk3????fk3????rE   z4The first argument must be a scalar or an array-likeTr  )
r   r   r  r   rg  r  r	   r   r   r{   )rM  r\  r  r   s       rC   nan_to_num_implr    s   !U\"" =/a'' 	     5;'' 	     5=)) 	% % % % %
 $F   
!		 $/agu}--  	    -- 	      // 	     $F     ". / / 	/KrE   rB  r  r  r  r  )Fr  r  (  rt  r>  rr  r  rJ  llvmliter   llvmlite.irr   numpyrz  numbar   r   
numba.corer   r   r	   r
   r   r   numba.np.numpy_supportr   r   r   r   r   r   r   r   r   r   r   r   r   numba.core.imputilsr   r   r   r   r   r   r    r!   r"   r#   r$   numba.core.typingr%   numba.core.typesr&   numba.core.extendingr'   r(   r)   r*   r+   
numba.miscr,   r-   numba.cpythonr.   numba.cpython.unsafe.tupler/   r0   r1   numba.core.typing.npydeclr2   r  r3   r  r4   r5   r6   rD   rI   rx   r   r   r   r   r   r   r   r   r   r   r   r   r  ArrayIteratorBORROWEDr  r6  r   r<  r  r   r#  r?  rL  rJ  rj  AnyrQ  r   rV  r   r]  rb  rO  rd  rv  r  r  r  r  r  rG  r  r  r  r  r  r:  rE  rX  r`  ri  rn  rx  r}  r  r  r  broadcast_shapesr  r  r  rN  r  r  r  r  VarArgr  r  r  r  r$  r  	geomspacer-  rot90r7  rG  rO  rW  rY  r]  r_  resizern  ri   rw  r  re  r  r  r  r  r  r  r  r  re   r  r   r  uniquer  r  r  r  r  r  r  r  r2  r  r"  
MemoryViewr%  r'  r)  r+  r-  r0  r4  r8  r=  r@  rF  rC  rI  r  r  rM  rT  rX  rV  rZ  r\  rc  rg  ra  ry  r}  DTypeNumberClassr  r  r  r  r  r  r  r  r  r  r  r  r  Bytesr  is_r  r  r  r  r  r  rP  r[  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  NumpyNdIterTyper  eqr  r  r  r  r  r  r  re  r  r  r  r  r  r  r  r  r  r   rf  r  r  r
  r  r  r  r  r  r  r  r  r   r"  r'  r-  eyer3  diagr;  r   r@  diagflatrG  rO  rP  rb  rn  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(  r7  r0  
atleast_1dr@  
atleast_2drC  
atleast_3drF  rT  ri  rt  rv  rz  rh  r  r  r  column_stackr  r  r  stackr  r  r  r  r  r  vstackr  	row_stackr  dstackr  r  r  r4  r  r5  r  r  flipr  r  r  r  r  vsplitr  hsplitr  dsplitr  r  r  r  r!  r'  r  r+  argsortr2  r4  UnicodeCharSeqrg  r  r  NPTimedelta
NPDatetimer8  r;  r=  type_callablerD  rF  libstride_tricksrO  rZ  rM  rg  r3  rn  r  take_along_axisr  r  r  r   rE   rC   <module>r     sA)   
                              * * * * * * * * H H H H H H H H H H H H H H H H; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; P O O O O O O O O O* * * * * * * * * * * * * * * * * * * * * * * * * * ( ' ' ' ' ' * * * * * *A A A A A A A A A A A A A A + + + + + + + + ! ! ! ! ! ! L L L L L L L L 5 5 5 5 5 5E E E E E E E E E E E E E E# # #6 6 69 9 9x( ( (- - -M M M	 	 	
 
 

  
  
  B B B BJH H H&     
 
.  , y%,''  ('.; ; ;* z5.//w  - - !  0/-6  $A4 A4 A4 A4H   ; ; ;* xu}==xu??E E @? >=E xu??E E @?E0 xuy%)DD%6 %6 ED%6P sEL!!F F "!F |U[))8 8 *)8 6]?EK;;) ) <;)(/" /" /" /" /"f /" /" /"d/- /- /- /- /-G /- /- /-d    W   >:- :- :- :- :-' :- :- :-zN- N- N- N- N-' N- N- N-bB- B- B- B- B-7 B- B- B-JL L L L L6 L L L^(G (G (GV xu{;;; ; <;;&' ' 'T  H H H
 
 
:$ :$ :$z" " "J! ! !.     4   ,   " 5 5 5>- - - 
"/'& '& '&T 3 3 3  
"
% % %P 
"
6 6 6r^% ^% ^%H  &  %+..; ; /.;
 
 
  %+u??3E 3E @?3El  %+|u|EI/F/FGGF F HGF
 
",    u{C  9 9 ! 9& 
"+    
",I I I IX 
"(   4! ! !H; ; ;< U_===E =E >==E@ \U\%)-D-DEE> > FE>
 6Xbj   
 Xbj   
")+ + +\ 
")   2 }ek**  +*, rx%%G G &%G ,,  -, 
 
 
    
"'v v v vr f%%   &%{ { {| 
"(   
"'   
")   
"))1 )1 )1X   " 5;11  21   	 	 	 

9---( ( .-(V |U[%/::E E ;:EH u{G$$: : %$:
 u{G$$u)): : *) %$: u{I&&u++: : ,+ '&: u{F##u((: : )( $#:
 u{F##: : $#: u{J''u,,: : -, (': u{H%%u**: : +* &%: u..: : /.:
 u00: : 10:
 u00: : 10:
 u,,: : -,: u{H%%	9 	9 &%	9 u &)): : *): Eu~..Eu}--; ; .- /.;  4 u{G$$8 8 %$8 u..u00	: 	: 10 /.	: u00
: 
: 10
:  u{F##Q Q $#Q u{F##Q Q $#Q 4M 4M 4Mn f%%k**  +* &%% % %
 #ek6 " ": . . . "ek6 " ": . . . !2EI>>( ( ?>(. u{##4; 4; $#4;n e.ABBO O CBO u|$$$= $= %$$=N u|$$D D %$D: u/BCCA A DCA u/CDDE E EDE u/BEINN	% 	% ON	% u/CUYOO
% 
% PO
%" ; ; ; 3 3 3 9 9 9 x|U[%+66
G 
G 76
G  EK,,  -,9 9 9> > > IM6:# # # #D '+O O O OE E EP
> > >BT T Tn u{F##P P $#P z5.//w  E E !  0/E x!4emDDE E EDE x!4emy % % % sE'((  )( r~u{++E E ,+E" z5566w  C C !  76C xem4455rz<5<6677
E 
E 87 65
E x))rz5?++E E ,+ *)E* z5122w  7 7 !  327 ry%)$$> > %$>& z5011w  7 7 !  217 x{EK55F F 65FL L L^ ek;//  0/* * * 
 
 
- - -`K K K# # #& & &    
"(" & & & &*    
"-   0    l++  ,+ 
"("     
"-    
",
 
 
 
 
"'     
",
 
 
 
 
"'    
"+   	 	 	 %&&  '& BF1E    2 
"'# # # #L 
"*  6 
"+   4        F 
"'f%%W W W &% Wt  4 
")@ @ @ @F 
"+' ' ' 'T"P "P "PJ    |U[))4 4 *)4 
"'  >< >< ><B ? ? ? 
"

 
  
 
"
   ~u{EO<<~u{E,?@@P P A@ =<P: ( ( (V 
"-%*    6 
&    
&   ! ! !H1D 1D 1Dh    "  <&' &' &'R&# &# &#R) ) )   2 
"(     &? ? ?:@ @ @:  8     
".  % % %2  . 
"-# # #
 
"-& & &
 
"-) ) )
: : :z/F /F /FdVF VF VFr, , ,$     
".      " " "J 
"/        
"(        4 
")     4 
")   FHHR\>*** & & &R 
")   5;//  0/ 5;..  /. 
")    
")      : 
"'
 
 
 
".; ; ; ;| 
"(C C C C4 
")  & 
")  * 
")  , 
     0   |U[))
I 
I *)
I 
"'	 	 	 U-@AArz5;(;<<9 9 =< BA9& EK%%  &% EK-..EK%%EK''EK''EK''EK*++EK)**F F +* ,+ (' (' (' &% /.F EK-..E E /.E   *++  ,+"  %+uPP; ; QP;* BF(344   548 BF(<==[$ [$ [$ >=[$| 
$   
"+  > 8 8 8v 
"
(  (  ( V 
"-? ? ? ? ? ?rE   