
    pi\             
       f0   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lAmBZBmCZC ddl3mDZD ddlEmFZGmHZImJZJmKZKmLZL d ZMd ZNd ZOd ZPd ZQd ZRd ZSd ZTd ZU	 dVdZVd ZWd ZX e5eX      d        ZY e$d ej                        d!        Z[d" Z\ e$d#ej                         e*e.j                        d$               Z_	 dVd%Z`d& Zad' Zb e$ej                  ej                  ej                         e$ej                  ej                  ej                        d(               Zf e$ej                  ej                  ej                        d)        Zh e$ej                  ej                  ej                  ej                        d*        Zk e$elej                        d+        Zm e$d,ej                        d-        Zoe"d.k  r$ e$d/ej                  ej                        d0        Zp G d1 d2eq      Zr G d3 d4er      Zs G d5 d6er      Zt G d7 d8er      Zu G d9 d:er      Zv G d; d<er      Zw G d= d>eq      Zxd? Zy e$ej                  ej                  ej                        d@        ZzdA Z{dB Z|dC Z}dD Z~dE ZdF ZdG ZdH Ze7dI        Ze7dJ        Ze4dK        ZdL Z e5e
j                        dM        Ze4dN        Z e5e
j                        dO        Z e5e
j                        dP        ZdQ Z e5edRS      dT        Z e5edUS      dV        ZdW ZdX Z e$dYej                        dZ        Zd[ Z e$dYej                  ej                        d\        Z e$dYej                   ej,                  ej                              d]        Z e5e
j0                        dVd^       Z e%ej                  d_      d`        Z e5e
j6                        dWda       Z e5e
j:                        dWdb       Z e5e
j>                        dXdc       Zdd Zde Z e$dfej                  ej                        dg        Z e$dfej                   ej,                  ej                              dh        Ze"dik  r e5e
jJ                        dj        Zn e5e
jJ                        dk        Z e5e
jN                        dl        Z e5e
jR                        dVdm       Z e$dnej                        do        Z e$e
jX                  ej                        dp        Z e$dqej                        dr        Ze4ds        Ze4dt        Z e5e
jb                        dVdu       Z e6ej                  dv      dYdw       Zdx Z e5e
jj                        dy        Z e5e
jn                        dz        Z e5e
jr                        d{        Z e5e
jv                        d|        Ze4d}        Z ejl                  ej                  d~      d        Ze7d        Zd Z e5edRS      d        Z e$dej                  ej                        d        Z e%ej                  d      d        Z e%ej                  d       e%ej                  d      d               Z e%ej                  d       e%ej                  d      d               Z e%ej                  d       e%ej                  d      d               Z e%ej                  d      d        Z e%ej                  d       e%ej                  d      d               Z e%ej                  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j                  d      d        Z e%ej                  d      d        Z e(ej                  ej                         e(ej                  ej                        d               Zd Z e%ej                  d      d        Z e%ej                  d       e%ej                  d      d               Z e%ej                  d      d        Z e%ej                  d      d        Z e%ej                  d      d        Zd Z e6ej                  d       e6ej                  d      d               Zd Z  e%ej                  d      e߫         e%ej                  d      e߫        e$dej                  ej                        d        Z e&ej                        d        Z e$dej                  ejd                        d        Z e&ej                        d        Z e'ej                        d        Z e$dej                  ejd                        d        Z e$dej                  ej                        d        Z e$dej                  ejd                  ej                        d        Z e$dej                  ej                  ej                        d        Z e)ej                        d        Z e)ej                        d        Z e)ej                        d        Z e$ej                  ej                  ej                        d        Z e8ej                  d      d        Zd Zd Z	 	 dYdÄZ	 dVdĄZdń ZdƄ ZdǄ Z e%ej                  dȫ      dɄ        Z e$d#ej                         e*e.j                        dʄ               Z e$ej                  ej                  ej                        d˄        Z e$ej                  ej                  ej                  ej                        d̄        Z e$elej                        d̈́        Z  e$e
j                  ej                        d΄        Z e$d#ej                         e*e.j                        dτ               Z e$e ej,                  ej                               e$e
j
                   ej,                  ej                              dЄ               Z e$eej                         e$e
j
                  ej                        dф               Z e$d#ej                         e*e.j                        d҄               Z	 e$e
j                  ej                        dӄ        Z e$d#ej                         e*e.j                        dԄ               Z e$ej                  ej                  ej                        dՄ        Zdք Z eDej                  ddUS      d؄        Zdل Ze7dڄ        Zdۄ Zd܄ Zd݄ Zdބ Ze7d߄        Z e5e
j2                        efd       Ze7d        Z e5e
j:                        dVd       Ze7d        Z e6ej                  d      d        Z  e5e
jB                        efd       Z" e5e
jF                        dVd       Z$ e5e
jJ                        dVd       Z& e5e
jN                        dVd       Z( e5e
jR                        dVd       Z* e5e
jV                        dVd       Z, e5e
jZ                        dVd       Z.d Z/ ejj                  e/      d        Z0 ejj                  e
jb                        ddefd       Z2 e5e
jf                        dZd       Z4 e5e
jj                        d        Z6 e5e
jn                        dZd       Z8d Z9 e5e
jt                         e6ej                  d      dVd              Z;d Z< e5e
jz                        dYd       Z> e5e
j~                        dWd       Z@d ZAe7d        ZB e$dej                        d        ZC e5e
j                        d        ZEd ZFe7d        ZG e5e
j                        d         ZI e5e
j                        d        ZK e$dej                  ej                         e$dej                  ejd                        d               ZLe7d        ZM e6ej                  d      d        ZNe7d        ZO e5e
j                        eddfd	       ZQ e5e      dVd
       ZR e5e      dVd       ZSd ZTd ZUd ZVd ZWd ZXd ZYd ZZd Z[e7d        Z\ e5e
j                        dVd       Z^d Z_d Z`d Zad Zbe7d        Zc e5e
j                        d        Zdd Zed Zf e5e
j                        d        Zh e5e
j                        d        Zj e5e
j                        d         Zld! Zmd" Znd# Zod$ Zpe7d%        Zq e5e
j                        dZd&       Zsd' Zte7d(        Zu e5e
j                        d)        Zwd* Zxe7d+        Zy e5e
j                        dZd,       Z{d- Z|e7d.        Z} e5e
j                        d/        Ze7d0        Z e5e
j                        d1        Ze"d.k\  r  e5e
j                        e       e7d2        Z e5e
j
                        d3        Z ejl                  ej                  d4      d5        Z ejl                  ej                  d6      d7        Z e5e
j                        d8        Z e5e
j                        d9        Ze7d:        Z e5e
j                        d;        Z e5e
j                         dZd<       Z e5e
j$                        dZd=       Z e5e
j(                        d>        Z e5e
j,                        d?        Z e5e
j0                        d@        Zi ZdA Zd[dBZdC Z e$dDej                        dE        Z e5e
j>                        dF        Z e$dGej                  ejd                         e$e
jB                  ej                  ejd                        dH               Z e(ej                  ej                        dI        Z e(ej                  ejH                         e(ej                  ejJ                         e(ej                  ej                         e(ej                  ejL                         e(ej                  ejN                         e(ej                  ejP                         e(ej                  ejR                        dJ                                                  Z e(ej                  ejH                        dK        ZdL Z ejZ                  e      dM        Z e$eej                  ej                  ej                        dN        Z ejj                  e
j`                  jb                  jd                        d\dO       Z ejj                  e
j`                  jb                  jf                        dVdP       Z e5e      dQ        Z e5e
jl                        dR        Ze4dS        Z e5e
jr                        dT        Z e5e
jv                        d]dU       Zy(^  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)_make_constant_bytes
bytes_type)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                  j                  |      }|j	                  d|       y)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         S/opt/services/ai/voice_agent/venv/lib/python3.12/site-packages/numba/np/arrayobj.pyset_range_metadatarF   .   sK    
 tyy+6tyy+68N		$	$^	4Bgr"    c                 ^    d|j                   j                  dz
  z  dz
  }t        | |d|       y)zF
    Mark the result of a load instruction as positive (or zero).
       r   N)r;   widthrF   )r?   r@   rB   s      rE   mark_positiverK   9   s.     1,-2Kwa5rG   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                   <     e Zd Z fdZefd       Z xZS )make_array.<locals>.ArrayStructc                 d   t        
	      }	 | j                  j                  d|      }| j                  j                  	   }| j                  |      }|#t        j                  | j                  |d      }n|} || j                  |f      }||fS # t        $ r t        |   |      cY S w xY w)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          rE   rV   z*make_array.<locals>.ArrayStruct._make_refsO   s    OZ8C@!]]77SI

 88DI''	2G{#//w6:<	  	 T]]YL9Cc>! ' @[$:3??@s   B B/.B/c                 H   | j                   }dk(  rj                  | d      S | j                  d      }g }t              D ]H  }t	        j
                  ||d|      }|j                  |      }|j                  |       t        ||       J t	        j                  ||      S )z\
            Override .shape to inform LLVM that its elements are all positive.
            r   shape)
rZ   __getattr___get_ptr_by_namer:   r
   gep_inboundsr@   appendrK   
pack_array)	r[   r?   ptrdimsidimptrr@   basendims	          rE   rg   z%make_array.<locals>.ArrayStruct.shapec   s    
 mmGqy''g66 ''0CD4[ - --gsAqA||F+D!gt,	- %%gt44rG   )__name__
__module____qualname__rV   propertyrg   __classcell__)rc   rb   rd   rq   rr   re   s   @rE   rb   rN   M   s    	"( 
	5 
	5rG   rb   )as_arrayr
   create_struct_proxyrr   )rd   rb   rq   rr   re   s   `@@@@rE   
make_arrayrz   A   sE     !))O&&7DD+5 +5d +5Z rG   c                 Z    | j                  |j                        }| j                  |      S )zB
    Return the item size for the given array or buffer type.
    )get_data_typedtypeget_abi_sizeof)contextrd   lltys      rE   get_itemsizer   }   s+       !1!12D!!$''rG   c                 `    |j                   rdnd}| j                  ||j                  ||      S )z3
    Load the item at the given array pointer.
    NrI   align)alignedunpack_valuer}   )r   r?   arraytyrm   r   s        rE   	load_itemr      s6     OODE&+   - -rG   c                 b    |j                   rdnd}| j                  ||j                  |||      S )z4
    Store the item at the given array pointer.
    NrI   r   )r   
pack_valuer}   )r   r?   r   valrm   r   s         rE   
store_itemr      s1     OODEgw}}c3eLLrG   c                     |j                   r;| j                  |||t        j                        }t	        j
                  |||      }|S | j                  |||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         rE   fix_integer_indexr      s]     ||ll7C

;d3 J ll7C<JrG   c                    t        |t        j                        rn|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   Arrayrr   r}   Integerrz   r   data)r   r?   r   r   idxaryidxvals         rE   normalize_indexr      sv     %%%**/%++u}}555"E"7GS97GUFKK@{{F""czrG   c                     t        |      r4t        t        ||      D cg c]  \  }}t        | |||       c}} \  }}||fS c c}}w )z^
    Same as normalize_index(), but operating on sequences of
    index types and values.
    )lenzipr   )r   r?   index_typesindicesr   r   s         rE   normalize_indicesr      s[    
 7|"7:;7P%')3 &5Wgu58&: %'  (W 	%'s   A
c                 "   | j                   }| j                  }| j                  }	t        j                  t        j
                  dd      }
|j                  |
   }t        |j                        }t        |	j                        }||z  |k7  r6||z
  }d| j                   dt        |      dkD  rdnd d| d}t        |      |*t        |j                  |	j                  d
            d	      }|j                  t        j                        }t!        |t"        t$        f      rt'        j(                  |||      }t!        |t"        t$        f      rt'        j(                  |||      }t!        |t*              r ||      }t-        |||||      }|.t        |j                  |	j                  d            d	      |d<   n||d<   |j/                  t        j                  d      }t'        j0                  |||j2                  j4                        }|D ]  }|j7                  ||dg      } ||d<   t        |j9                               }||k7  rt        dj;                  ||z
              |j=                         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.
    rI   CzThe datamodel for type z is missing fields  .Nmeminfo)rg   stridesr   itemsizer   parentnswflagsnitemszmissing {0}) rR   rZ   
_datamodelr   r   float64rW   set_fields_fe_typer   
ValueErrorr   get_value_typeget_typer   r   tuplelistr
   rl   intdictget_constantunpack_tupler;   countmulkeysformatitemssetattr)arrayr   rg   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                           rE   populate_arrayr      s{    nnGnnG  I [[37N$+$>$>~$N!7??@O9,,- 	**>!$44((8 9!'lQ.sB7q	Do711y)+,02 ##EJJ/F%%'""7E6:'E4=)$$Wgv>(C (#u " 	#E ~"7#9#9x($*+/1h !h!!%**a0F))'5%**:J:JKN ;VU5':;E(O UZZ\"J_$--o
.JKLL  1q! LrG   c                 n   |j                   }|j                  }|j                  t        j                  d      }t        j                  ||j                  | j                        }|D ]  }|j                  ||dg      } ||_
        |j                  t        j                  t        ||             |_        y)z
    Update some auxiliary information in *array* after some of its fields
    were changed.  `itemsize` and `nitems` are updated.
    rI   r   r   N)rR   rZ   r   r   r   r
   r   rg   rr   r   r   r   r   )arytyr   r   r?   r   r   r   s          rE   update_array_infor     s    
 nnGnnG !!%**a0F))'5;;

KN ;VU5':;EL))%***6w*FHENrG   c                     t               )z/Constrain axis values to valid positive values.rT   )	func_namearg_namerr   axiss       rE   normalize_axisr     s    

rG   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                 F    |dk  r||z  }|dk  s||k\  rt              |S Nr   r   )r   r   rr   r   r   s       rE   implz&normalize_axis_overloads.<locals>.impl%  s/    !8DLD!8tt|S/!rG   )r   r&   r	   TypingErrorliteral_value)r   r   rr   r   r   r   s        @rE   normalize_axis_overloadsr     sr    i/  !CDDh.  !BCC ""
#;x/E/E.F G4 	4 
 KrG   getiterc                    |j                   \  }|\  }| j                  ||j                        }| j                  t        j
                  d      }t        j                  ||      }||_        ||_	        | j                  r| j                  j                  |||       |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              rE   getiter_arrayr   0  s    IWGU!!'3??;G

A.D(($7HGMGM 7GU3



C 7GS__c
BCJrG   c           
         t        j                  ||j                  |j                        }t        j                  ||j                  |j                        }|j                  |d   |      }t        j                  ||j                  |      }	|dd }
|dd }t        |t        j                        r"t        | |||||	|
|      }|j                         S |
rJ t        | |||	      S )z1 Evaluate `ary[idx]`, where idx is a single int. r   r   rI   N)r
   r   rg   rr   r   r   pointer_addr   r   r   Buffer	make_viewr   r   )r   r?   r   r   aryr   shapesr   offsetdataptrview_shapesview_stridesretarys                rE   _getitem_array_single_intr  H  s     !!'399EJJGF""7CKKuzzJG[[S)F!!'388V<G*K12;L+u||,7GUC"K?!! '5'::rG   iternextc           	      p   |j                   \  }|\  }|j                  }| j                  |||      } t        |      | ||j                        }	t        j                  ||	j                  d      \  }
|j                  |j                        }|j                  d||
      }|j                  |       |j                  |      5  t        | ||j                  ||	|      }|j                  |       t        j                   ||      }|j#                  ||j                         d d d        y # 1 sw Y   y xY w)NvaluerI   r   <)r   rd   r   rz   r   r
   r   rg   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                  rE   iternext_arrayr  ]  s    xxHVFTG!!'6!>G
*W
gwgmm
DC""7CIIQ?GFLL'E""3v6H
X		" -)Wf//#u
 	e((%8fgmm,- - -s   AD,,D5c           	         | j                  t        j                  d      }| j                  t        j                  d      }t        j                  ||j
                  |j                        }	t        j                  ||j                  |j                        }
g }g }g }t        |D cg c]  }t        |      s| c}      }d}t        ||      D ]  \  }}|t        j                  u rm|j                  t        |      z
  dz   |z   }t        |      D ]@  }|j                  |       |j                  |	|          |j                  |
|          |dz  }B t        |t        j                        r| j!                  |||      }t#        j$                  | |||       t#        j&                  |||	|          |j                  |j(                         t#        j*                  ||      }t#        j,                  |||
|         }|j                  |       |j                  |       nt        |t        j.                        rBt1        | ||||	|         }|rt        j2                  | |||	|   |       |j                  |       nAt        |      r(|j                  |       |j                  |       |dz  }nt5        d|      |dz  } ||j                  k  sJ ||j                  k  r=|j                  |	|          |j                  |
|          |dz  }||j                  k  r=t        j6                  | ||||dd      }|||fS c c}w )z
    Perform basic indexing on the given array.
    A (data pointer, shapes, strides) tuple is returned describing
    the corresponding view.
    r   rI   r  unexpected index type: F
wraparoundboundscheck)r   r   r   r
   r   rg   rr   r   r   r   r   ellipsisr:   rk   r   	SliceTyper   r.   guard_invalid_slice	fix_slicestartget_slice_length
fix_strider   r   do_boundscheckrT   get_item_pointer)r   r?   r   r   r   r   r  r   oner   r   output_indicesoutput_shapesoutput_stridesr   num_newaxesaxindexvalr   	n_missingro   sliceshstr   r  s                             rE   basic_indexingr1  y  s    

A.D


uzz1
-C!!'399ejjAF""7CKKDGNMNkFs[5EsFGK	
Bw4  %ENN"

S\1A5CI9% %%d+$$VBZ0%%gbk2a	
 eU__-''h'GE''%GgufRj9!!%++.))'59B##GUGBK@B  $!!"%u}}-#GWeX$*2J0C&&wfRj"M!!#&  %!!$'!GB%U&LMM
aA F 
uzz/VBZ(gbk*
a uzz/ &&w'527ULG ]N33a Gs   &M7Mc           	           t        |      | |      }t        |||||j                  |j                  |j                         |S )zF
    Build a view over the given array with the given parameters.
    r   rg   r   r   r   r   )rz   r   r   r   r   )	r   r?   r   r   r   r   r   r   r  s	            rE   r   r     sF    
 %Z$Wg6F6"LL;;**& MrG   c           
          t        | |||||| j                        \  }}}	t        |t        j                        r"t        | |||||||	      }
|
j                         S |rJ t        | |||      S )zp
    Return the result of indexing *ary* with the given *indices*,
    returning either a scalar or a view.
    r  )r1  enable_boundscheckr   r   r   r   r   r   )r   r?   r   r   r   r   r   r  r  r  r  s              rE   _getitem_array_genericr7    s     	w['#*#=#=	? 'G[, +u||,7GUC"K?!! '5'::rG   c           	          |j                   \  }}|\  }}|j                  dk\  sJ  t        |      | ||      }t        | ||j                  |||f|f      }t        | ||j                  |      S )z4
    Basic indexing with an integer or a slice.
    rI   )r   rr   rz   r7  r   r!   	r   r?   r]   r   r   r   r   r   r   s	            rE   getitem_arraynd_intpr:    su     88LE5HC::??
*U
GWc
2C
 '3??!&eXv?CWgsDDrG   c           
      z   |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   P   K   | ]  }t        |t        j                           y wNr   r   r   ).0tys     rE   	<genexpr>z&getitem_array_tuple.<locals>.<genexpr>  s     
=2:b%++&
=   $&)r   rz   r   r
   r   r   r   anyfancy_getitemr7  r   r!   )r   r?   r]   r   r   tuptyr   tupr   r   r   s              rE   getitem_array_tuplerG    s    
 88LE5HC
*U
GWc
2C++K""7Cs5zBG,Wg-8'CK 
=
==WgsD"Cg? 	? !'3??!&['CCWgsDDrG   c           	         |j                   \  }}}|\  }}}	t        |t        j                        r.|j                  }
t	        j
                  ||t        |            }n|f}
|f} t        |      | ||      }t        | ||
|      \  }
}	 t        | ||||
|| j                        \  }}}t        |      }|rt        | ||||
|      S | j                  ||	||j                        }	t!        | |||	       y# t        $ r d}Y Mw xY w)zH
    array[a] = scalar_or_array
    array[a,..,b] = scalar_or_array
    r   r5  TN)r   r   r   	BaseTupler
   r   r   rz   r   r1  r6  boolrT   fancy_setslicer   r}   r   )r   r?   r]   r   r   r   valtyr   r   r   r   r   r  r   r   use_fancy_indexings                   rE   setitem_arrayrN    s&    ((E5%MCc%)kk&&w3u:Fh&
*U
GWc
2C -Wg-8'CK*7GUCg'.'A'AC 	! "&\ gwT)74 	4 ,,wUEKK
8CwW5  "!"s   
 C5 5DDc                     |j                   \  }|\  }t        |      } || ||      }|j                  }|j                  |d      }t	        | ||j
                  |      S r   )r   rz   rg   extract_valuer#   r   )	r   r?   r]   r   r   r   arysttyshapearyr   s	            rE   	array_lenrS  5  s\    xxHUFSG
'7C
(CyyH


!
,CgwEErG   z
array.itemc           	      l   |j                   \  }|\  } t        |      | ||      }|j                  }|j                  |j	                  d||j                  d            d      5  d}| j                  j                  |t        |f       d d d        t        | |||j                        S # 1 sw Y   !xY w)N!=rI   Flikelyz>item(): can only convert an array of size 1 to a Python scalar)r   rz   r   r  r  r;   	call_convreturn_user_excr   r   r   )r   r?   r]   r   r   r   r   r   s           rE   
array_itemrZ  @  s    XXFEDC
*U
GWc
2CZZF	,,T66;;q>J % 
 
' GN))':vFG
 Wguchh77G Gs   %%B**B3   r   zarray.itemsetc           	         |j                   \  }}|\  }}||j                  k(  sJ  t        |      | ||      }|j                  }|j	                  |j                  d||j                  d            d      5  d}	| j                  j                  |t        |	f       d d d        t        | ||||j                         | j                         S # 1 sw Y   2xY w)NrU  rI   FrV  z/itemset(): can only write to an array of size 1)r   r}   rz   r   r  r  r;   rX  rY  r   r   r   get_dummy_value)
r   r?   r]   r   r   rL  r   r   r   r   s
             rE   array_itemsetr_  P  s    xxuS###j#6__W00vv{{1~N$)  + 	KCC--gzC6J	K
 	7GUC:&&((	K 	Ks   8%CCc                   4    e Zd ZdZd Zd Zd Zd Zd Zd Z	y)	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   r[   s    rE   preparezIndexer.preparek  
    
 "!rG   c                     t         )z=
        Return this dimension's size as an integer.
        r   rc  s    rE   get_sizezIndexer.get_sizer  
     "!rG   c                     t         )z;
        Return this dimension's shape as a tuple.
        r   rc  s    rE   	get_shapezIndexer.get_shapex  rh  rG   c                     t         )z}
        Return a half-open [lower, upper) range of indices this dimension
        is guaranteed not to step out of.
        r   rc  s    rE   get_index_boundszIndexer.get_index_bounds~  re  rG   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   rc  s    rE   	loop_headzIndexer.loop_head  s
     "!rG   c                     t         )z)
        Finish indexation loop.
        r   rc  s    rE   	loop_tailzIndexer.loop_tail  rh  rG   N)
rs   rt   ru   __doc__rd  rg  rj  rl  rn  rp   rG   rE   ra  ra  e  s%    
""""	""rG   ra  c                   :    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
y	)
EntireIndexerz:
    Compute indices along an entire array dimension.
    c                     || _         || _        || _        || _        || _        | j                   j                  t        j                        | _        y r=  )	r   r?   r   r   dimr   r   r   ll_intp)r[   r   r?   r   r   rv  s         rE   __init__zEntireIndexer.__init__  s?    
||225::>rG   c                 $   | j                   }|j                  | j                  j                  | j                        | _        t        j                  || j                        | _	        |j                         | _        |j                         | _        y r=  )r?   rP  r   rg   rv  r   r
   rY   rw  r   append_basic_blockbb_startbb_endr[   r?   s     rE   rd  zEntireIndexer.prepare  sc    ,,))$((..$((C	(($,,?
224002rG   c                     | j                   S r=  r   rc  s    rE   rg  zEntireIndexer.get_size  s    yyrG   c                     | j                   fS r=  r  rc  s    rE   rj  zEntireIndexer.get_shape  s    		|rG   c                 <    | j                  d      | j                  fS r   rw  r   rc  s    rE   rl  zEntireIndexer.get_index_bounds      Q++rG   c                    | j                   }| j                   j                  t        | j                  d      | j                         |j                  | j                         |j                  | j                         |j                  | j                        }|j                  |j                  d|| j                        d      5  |j                  | j                         d d d        ||fS # 1 sw Y   ||fS xY wNr   >=FrV  )r?   r  r   rw  r   branchr{  position_at_endr@   r  r  r   r|  )r[   r?   	cur_indexs      rE   rn  zEntireIndexer.loop_head  s    ,,8DLL!4djjAt}}%.LL,	__W00y$))L$)  + 	(NN4;;'	( )##	( )##s   C..C:c                    | j                   }t        j                  ||j                  | j                              }|j                  || j                         |j                  | j                         |j                  | j                         y r=  )
r?   r
   r  r@   r   r  r  r{  r  r|  r[   r?   
next_indexs      rE   rp  zEntireIndexer.loop_tail  s^    ,,,,Wgll4::6NO
j$**-t}}%,rG   Nrs   rt   ru   rq  rx  rd  rg  rj  rl  rn  rp  rr  rG   rE   rt  rt    s*    ?3,
$-rG   rt  c                   :    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
y	)
IntegerIndexerz0
    Compute indices from a single integer.
    c                     || _         || _        || _        | j                   j                  t        j
                        | _        y r=  )r   r?   r   r   r   r   rw  )r[   r   r?   r   s       rE   rx  zIntegerIndexer.__init__  s1    ||225::>rG   c                      y r=  rr  rc  s    rE   rd  zIntegerIndexer.prepare      rG   c                 .    t        | j                  d      S NrI   )r   rw  rc  s    rE   rg  zIntegerIndexer.get_size  s    a((rG   c                      yNrr  rr  rc  s    rE   rj  zIntegerIndexer.get_shape  s    rG   c                     | j                   | j                  j                  | j                   | j                               fS r=  )r   r?   addrg  rc  s    rE   rl  zIntegerIndexer.get_index_bounds  s,    $,,**488T]]_EFFrG   c                     | j                   d fS r=  )r   rc  s    rE   rn  zIntegerIndexer.loop_head  s    xx~rG   c                      y r=  rr  rc  s    rE   rp  zIntegerIndexer.loop_tail  r  rG   Nr  rr  rG   rE   r  r    s+    ?)GrG   r  c                   :    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
y	)
IntegerArrayIndexerz;
    Compute indices from an array of integer indices.
    c                     || _         || _        || _        || _        || _        |j
                  dk(  sJ | j                   j                  t        j                        | _	        y r  )
r   r?   r   r   r   rr   r   r   r   rw  )r[   r   r?   r   r   r   s         rE   rx  zIntegerArrayIndexer.__init__  sO    
	zzQ||225::>rG   c                    | j                   }t        j                  || j                  j                        d   | _        t        j                  || j                        | _        |j                         | _
        |j                         | _        y r   )r?   r
   r   r   rg   idx_sizerY   rw  	idx_indexrz  r{  r|  r}  s     rE   rd  zIntegerArrayIndexer.prepare  sf    ,,,,Wdkk6G6GHK ,,WdllC224002rG   c                     | j                   S r=  r  rc  s    rE   rg  zIntegerArrayIndexer.get_size  s    }}rG   c                     | j                   fS r=  r  rc  s    rE   rj  zIntegerArrayIndexer.get_shape   s    rG   c                 <    | j                  d      | j                  fS r   r  rc  s    rE   rl  z$IntegerArrayIndexer.get_index_bounds  r  rG   c                    | j                   }| j                   j                  t        | j                  d      | j                         |j                  | j                         |j                  | j                         |j                  | j                        }|j                  |j                  d|| j                        d      5  |j                  | j                         d d d        t        | j                  || j                  j                   | j                  | j"                  |      }t%        | j                  || j                  j                   || j&                        }||fS # 1 sw Y   xY wr  )r?   r  r   rw  r  r  r{  r  r@   r  r  r  r|  r  r   r   r}   r   r   r   )r[   r?   r  r   s       rE   rn  zIntegerArrayIndexer.loop_head  s   ,,8DLL!4dnnEt}}%.LL0	__i?  
 	( NN4;;'		( *LL'4::#3#3TZZ
 "$,,"&**"2"2E499Fi	( 	(s   E''E0c                    | j                   }t        j                  ||j                  | j                              }|j                  || j                         |j                  | j                         |j                  | j                         y r=  )
r?   r
   r  r@   r  r  r  r{  r  r|  r  s      rE   rp  zIntegerArrayIndexer.loop_tail  sb    ,,,,W-4\\$..-IK
j$..1t}}%,rG   Nr  rr  rG   rE   r  r    s*    ?3 , *-rG   r  c                   :    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
y	)
BooleanArrayIndexerz>
    Compute indices from an array of boolean predicates.
    c                     || _         || _        || _        || _        |j                  dk(  sJ | j                   j                  t        j                        | _        t        | j                  d      | _
        y NrI   r   )r   r?   r   r   rr   r   r   r   rw  r   r   )r[   r   r?   r   r   s        rE   rx  zBooleanArrayIndexer.__init__*  sZ    
zzQ||225::>T\\1-	rG   c                    | j                   }t        j                  || j                  j                        d   | _        t        j                  || j                        | _        t        j                  || j                        | _	        |j                         | _        |j                         | _        |j                         | _        y r   )r?   r
   r   r   rg   r   rY   rw  r  r   rz  r{  bb_tailr|  r}  s     rE   rd  zBooleanArrayIndexer.prepare3  s    ,,(($++2C2CDQG	 ,,WdllC(($,,?
224113002rG   c           	         | j                   }t        j                  || j                        }t        j                  || j
                        5 }|j                  |      }t        | j                  || j                  j                  | j                  | j                  |j                        }|j                  ||j                  ||j                              }|j!                  ||       d d d        |j                  |      S # 1 sw Y   xY wr=  )r?   r
   r   r   	for_ranger   r@   r  r   r   r}   r   r   r  zextr;   r  )r[   r?   r   loopcpreds         rE   rg  zBooleanArrayIndexer.get_size<  s    ,,))'499=w		2 	$dU#A,gtzz'7'7

DKKD Aw||D!&&9:AMM!U#	$ ||E""	$ 	$s   BDDc                 $    | j                         fS r=  rg  rc  s    rE   rj  zBooleanArrayIndexer.get_shapeK      !!rG   c                 <    | j                  d      | j                  fS r   r  rc  s    rE   rl  z$BooleanArrayIndexer.get_index_boundsN  s     Q++rG   c                    | j                   }| j                   j                  | j                  | j                         | j                   j                  | j                  | j                         |j                  | j                         |j                  | j                         |j                  | j                        }|j                  | j                        }|j                  |j                  d|| j                        d      5  |j                  | j                         d d d        t        | j                  || j                  j                   | j                  | j"                  |      }|j                  |j%                  |            5  |j                  | j&                         d d d        t)        j*                  ||      }|j                  || j                         ||fS # 1 sw Y   xY w# 1 sw Y   KxY w)Nr  FrV  )r?   r  r   r  r   r  r{  r  r@   r  r  r   r|  r  r   r   r}   r   not_r  r
   r  )r[   r?   r  	cur_countr  
next_counts         rE   rn  zBooleanArrayIndexer.loop_headS  st   ,,499dnn5499djj1t}}%.LL0	LL,	__W00y$))L$)  + 	(NN4;;'	( )LL'4::#3#3TZZ
 __W\\$/0 	)NN4<<(	) ,,Wi@
j$**-)##	( 	(	) 	)s   G'G3'G03G<c                    | j                   }|j                  | j                         |j                  | j                         t	        j
                  ||j                  | j                              }|j                  || j                         |j                  | j                         |j                  | j                         y r=  )r?   r  r  r  r
   r  r@   r  r  r{  r|  r  s      rE   rp  zBooleanArrayIndexer.loop_tailk  s    ,,t||$-,,W-4\\$..-IK
j$..1t}}%,rG   Nr  rr  rG   rE   r  r  %  s*    .3#",
$0-rG   r  c                   :    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
y	)
SliceIndexerz(
    Compute indices along a slice.
    c                     || _         || _        || _        || _        || _        || _        || _        | j                   j                  t        j                        | _
        t        | j                  d      | _        y r   )r   r?   r   r   rv  r   r.  r   r   r   rw  r   r   )r[   r   r?   r   r   rv  r   r.  s           rE   rx  zSliceIndexer.__init__{  s_    


||225::>T\\1-	rG   c                    | j                   }|j                  | j                  j                  | j                        | _        t        j                  | j                  || j                  | j                         t        j                  || j                  | j
                         t        j                  || j                  j                        | _        t        j                   || j"                        | _        t        j                   || j"                        | _        |j)                         | _        |j)                         | _        y r=  )r?   rP  r   rg   rv  dim_sizer.   r  r   r   r.  r   r
   
is_neg_intstepis_step_negativerY   rw  r   r   rz  r{  r|  r}  s     rE   rd  zSliceIndexer.prepare  s    ,,--dhhnndhhG##DLL'4::$(JJ	0'4::t}}= ' 2 27DJJOO L(($,,?
(($,,?
224002rG   c                 V    t        j                  | j                  | j                        S r=  )r.   r"  r?   r.  rc  s    rE   rg  zSliceIndexer.get_size  s    ''djjAArG   c                 $    | j                         fS r=  r  rc  s    rE   rj  zSliceIndexer.get_shape  r  rG   c                 d    t        j                  | j                  | j                        \  }}||fS r=  )r.   get_slice_boundsr?   r.  )r[   loweruppers      rE   rl  zSliceIndexer.get_index_bounds  s*    //djjIue|rG   c           	      (   | j                   }| j                   j                  | j                  j                  | j                         | j                   j                  | j
                  | j                         |j                  | j                         |j                  | j                         |j                  | j                        }|j                  | j                        }|j                  | j                  |j                  d|| j                  j                        |j                  d|| j                  j                              }|j                  |d      5  |j                  | j                          d d d        ||fS # 1 sw Y   ||fS xY w)Nz<=r  FrV  )r?   r  r.  r!  r   r   r   r  r{  r  r@   selectr  r  stopr  r|  )r[   r?   r  r  is_finisheds        rE   rn  zSliceIndexer.loop_head  s*   ,,4::++TZZ8499djj1t}}%.LL,	LL,	nnT%:%:%,%8%8y9=&J%,%8%8y9=&JK
 __[_7 	(NN4;;'	()##	()##s   FFc                    | j                   }|j                  |j                  | j                        | j                  j
                  dg      }|j                  || j                         t        j                  ||j                  | j                              }|j                  || j                         |j                  | j                         |j                  | j                         y )Nr   r   )r?   r  r@   r   r.  r  r  r
   r  r   r  r{  r  r|  )r[   r?   r  r  s       rE   rp  zSliceIndexer.loop_tail  s    ,,[[djj!94::??(-w ! 0
j$**-,,Wgll4::6NO
j$**-t}}%,rG   Nr  rr  rG   rE   r  r  v  s+    	.3B"$$-rG   r  c                   4    e Zd ZdZd Zd Zd Zd Zd Zd Z	y)	FancyIndexerz4
    Perform fancy indexing on the given array.
    c           
      :   || _         || _        || _        t        j                  ||j
                  |j                        | _        t        j                  ||j                  |j                        | _        | j                   j                  t        j                        | _        g | _        g }t        |D cg c]  }t        |      s| c}      }	d}
d}t!        ||      D ]  \  }}|t        j"                  u rY|j                  t        |      z
  dz   |	z   }t%        |      D ],  }t'        |||||
      }|j)                  |       |
dz  }
|dz  }. rt+        |t        j,                        r7|j/                  |||      }t1        |||||
||      }|j)                  |       nDt+        |t        j2                        r;t5        ||||| j                  |
         }t7        |||      }|j)                  |       nt+        |t        j8                        r t;        |      |||      }t+        |j<                  t        j2                        rt?        ||||| j                  |
         }n5t+        |j<                  t        j@                        rtC        ||||      }nJ |j)                  |       n:t        |      r!| j                  j)                  |       |
dz  }
ntE        d|      |
dz  }
|dz  } |
|j                  k  sJ |
|j                  f       |
|j                  k  r5t'        |||||
      }|j)                  |       |
dz  }
|
|j                  k  r5t        |      |j                  k(  sJ t        |      |j                  f       || _#        y c c}w )Nr   rI   r  )$r   r?   r   r
   r   rg   rr   r   r   r   r   r   rw  newaxesr   r   r   r  r:   rt  rk   r   r  r   r  r   r   r  r   rz   r}   r  Booleanr  AssertionErrorindexers)r[   r   r?   r   r   r   r   r  r   r*  r+  new_axr,  r   r-  ro   indexerr.  r   r   s                       rE   rx  zFancyIndexer.__init__  s%   
**7CIIuzzJ++GS[[%**M||225::>+J3S9I3JK"7K8 (	OHe&!JJW59KG	y)  A+GWeS"MGOOG,!GBaKF	 
  %1++GUHE&wR',e5(E5==1'%(,B9('3?(E5;;/*E*7GXFekk5==91'72726++b/CG  U]];1'727AG 1(U###F+a$E%KLL!GBaKFQ(	V UZZ1"ejj!115::o#GWeS"EGOOG$!GB 5::o
 8}

*GS]EJJ,GG* m Ks   6NNc                 \   | j                   D ]  }|j                           | j                  j                  t        j
                  d      }| j                   D cg c]  }|j                          }}| j                  D ]  }|j                  ||f        t        |d      | _
        y c c}w )NrI   rr  )r  rd  r   r   r   r   rj  r  insertsumindexers_shape)r[   ro   r&  	res_shapes       rE   rd  zFancyIndexer.prepare  s     	AIIK	 ll''

A6 -1MM:qQ[[]:	:  	(AQ'	( ")R0 ;s   B)c                     | j                   S )z?
        Get the resulting data shape as Python tuple.
        )r  rc  s    rE   rj  zFancyIndexer.get_shape  s     """rG   c           	          t        |      | j                  j                  k(  sJ | j                  }t        j
                  }| j                  d      }| j                  d      }|}|}t        | j                  | j                  |      D ]  \  }	}
}|j                  ||j                  d|
|            }|	j                         \  }}|j                  ||      }|j                  ||j                  ||            }|j                  d||      }|j!                  ||j#                  |||            }|j!                  ||j#                  |||            } |j!                  ||      }|j#                  |||      }|j#                  |||      }||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   rI   ==r
  )r   r   rr   r?   r
   	false_bitrw  r   r  r  or_icmp_unsignedrl  r   subr  r  r  )r[   r   r   r?   is_emptyr   r&  r  r  r  rg   stridelower_indexupper_indexlower_offsetupper_offsetis_downwardss                    rE   get_offset_boundszFancyIndexer.get_offset_bounds  s    7|tzz...,,$$||All1o&)$--9L9L*1'3 	>"GUF{{8#*#8#8ud#KMH (/'?'?'A$K";;v{;L";;vw{{;/LML"..sFDALKK '|/;/;!=>E KK '|/;/;!=>E	>& E8,xu5xu5e|rG   c                 B    t        d | j                  D         \  }}||fS )Nc              3   <   K   | ]  }|j                           y wr=  )rn  )r?  ro   s     rE   rA  z+FancyIndexer.begin_loops.<locals>.<genexpr>B  s     E!Es   )r   r  )r[   r   countss      rE   begin_loopszFancyIndexer.begin_loopsA  s$    Et}}EFrG   c                 X    t        | j                        D ]  }|j                           y r=  )reversedr  rp  )r[   ro   s     rE   	end_loopszFancyIndexer.end_loopsE  s#    $--( 	AKKM	rG   N)
rs   rt   ru   rq  rx  rd  rj  r  r  r  rr  rG   rE   r  r    s(    @!D1&#$LrG   r  c                 b   t        j                  ||j                        }t        j                  ||j                        }	|j                  }
t        | |||||      }|j                          |j                  }|j                         }t        | |||      }|j                  }t        j                  || j                  t        j                  d            }|j                         \  }}t        j                  | ||
||	|j                   |d| j"                  	      }t%        | |||      }|j'                  |      }|j)                  ||g      }t+        | ||||       t        j,                  ||      }|j/                  ||       |j1                          t3        | |||j5                               S )Nr   Fr  )r
   r   rg   r   r   r  rd  r   rj  _empty_nd_implr   r   r   r   r  get_item_pointer2layoutr6  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_rm   r   curnext_idxs                         rE   rD  rD  J  s    !!'3995F""7CKK8G88D7GUC&1GOO __F""$J
'6:
>CxxH''(/(<(<UZZ(KMG $$&JGQ 
#
#GWdFG$)LL'e070J0JLC GWeS
1C ,,w
C
++h
&Cwc2&&w4HMM(G$GWfcmmoFFrG   c           
      "   |j                   \  }}|\  }} t        |      | ||      }|j                  dk(  rFt        | |||      \  }}t	        | ||j
                  |||f|f      }t        | ||j
                  |      S t        | ||||||f|f      S )z3
    Advanced or basic indexing with an array.
    r   )r   rz   rr   r   r7  r   r!   rD  r9  s	            rE   fancy_getitem_arrayr   u  s    
 88LE5HC
*U
GWc
2CzzQ$WgucB
s$Wgs%*C%C6C '3??CHH WgsD"C%C6; 	;rG   c           	         |j                   }|j                  d      }|j                  d      }|j                  dv r"|}	|j                  ||j                        }
|	|
fS |}	|}
t        |j                        D ]  }|j                  ||   |j                  ||   |            }|j                  d||      }|j                  ||j                  |
|      |
      }
|j                  ||	|j                  |	|            }	 |j                  |
|      }
|j                  d|j                  |      }|j                  |||
      }
|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   rI   CFr  r  )r   r;   r  r   r   r:   rr   r  r  r  r  )r   r?   arrtyarrr   r   r   r   r&  r  r  ro   max_axis_offset
is_upwardsr  s                  rE   offset_bounds_from_stridesr    sX    ||H==D
))A,C||t Hcjj10 %<+ uzz" 	OA &kk'!**1++fQi*EGO ,,T?DIJNN:#*;;uo#FOENN:#('++e_*MOE	O E8,&&tSZZ>xu5xu5%<rG   c                     |j                  ||j                        }|j                  ||      }|j                  ||      }||fS )z
    Given [lower, upper) byte offsets and a base data pointer,
    compute the memory pointer bounds as pointer-sized integers.
    )ptrtointr;   r  )r   r?   r  r  r   data_ptr_as_intr!  ends           rE   compute_memory_extentsr    sD    
 &&tUZZ8OKK/E
++ou
-C#:rG   c                 F    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	            rE   get_array_memory_extentsr    s2     .gws.4g?LE5!'7E5$GGrG   c                 n    |j                  |j                  d||      |j                  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          rE   extents_may_overlapr    s>     ,,c7E2c7E2K rG   c                 2    j                   dt        j                        d j                  d      5  j	                  |j
                  |j                        } j                  j                  |      }	|	j                   j                  |	      }	j                  |	        j                  t        j                        }
t        j                  |
      5 }t        j                   j                   |      }t        j                   |	|      }j                  j#                  |      |       d d d        d d d         fd} fd}||fS # 1 sw Y   .xY w# 1 sw Y   2xY w)Nr   FrV  c                    t        j                  
      }j                  d      5 \  }}|5  j                  t        j                  j                        	| d      |       d d d        |5  j                  t        j                  j                  | d      |       d d d        d d d        t        j                  |            S # 1 sw Y   pxY w# 1 sw Y   :xY w# 1 sw Y   >xY w)NFrV  r  )r
   rY   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       rE   src_getitemz&maybe_copy_source.<locals>.src_getitem  s   %%gu5__Xe_4 	8L) --gw.5ll9.E.9<.9>9>	@
   --gw.8+.3llN9>@ 	  '5',,w2GHH  	 	s:   C5=C.
C588C)0C5C&	"C5)C2	.C55C>c                      j                  d      5  j                        } j                  |       } j                  j	                  |        d d d        y # 1 sw Y   y xY w)NFrV  )r  r@   bitcastr   free)r   r?   r   r  r(  	voidptrtys    rE   src_cleanupz&maybe_copy_source.<locals>.src_cleanup	  sZ    __Xe_4 	,<<	*D??43DKKWd+	, 	, 	,s   A AA')r;   r
   r   r  r   r   r   r   allocater+  r  r   r   r   	loop_nestr  r  r@   )r   r?   r(  r'  srcr%  r&  r$  	allocsizer   r   r   r  dest_ptrr)  r.  r  r   r!  r"  r#  r-  s   ```` ```        @@@@@@rE   maybe_copy_sourcer4    sn   MMEK))'8<IKL	%	0 ; KKcjj9	{{##GY7II	tU+dI& ''

3w
F; 	;w//(0:K05gGG 00'41<l1<gGH MM',,w/:	;;,I I(, , ##I	; 	;; ;s&   	B)F2A"FFF
	FFc                    | j                  t        j                  d      }| j                  t        j                  d      }t        |      t        |      kD  r-t        |      t        |      z
  }|g|z  |z   }|g|z  |z   }||fS t        |      t        |      k  rt        |      t        |      z
  }|d| D cg c]  }|j	                  d||       }	}t        j                  |j                  |	t        j                        }
|j                  |j                  |
      d      5  d}| j                  j                  |t        |f       ddd       ||d }||d }||fS c c}w # 1 sw Y   xY w)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   rI   Nr  FrV  z,cannot broadcast source array for assignment)r   r   r   r   r  	functoolsreducer  r
   true_bitr  r  rX  rY  r   )r   r?   r   r   target_shaper   r&  nd_diffr/  
dim_is_oneacceptedr   s               rE   _bc_adjust_dimensionr=    sy    Q/D


u{{A
.C <3v;&l#c&k16)&7"W," 7? 
\	S[	(f+L 11 &x 02 ++D"c: 2
 2##GLL*$+$4$46 __W\\(3E_B 	K@C--gzC6J	K !'(#7?2
	K 	Ks   :E"'%E''E0c           
         g }g }| j                  t        j                  d      }| j                  t        j                  d      }t        ||      D 	
cg c]  \  }	}
|j	                  d|	|
       }}	}
|D 
cg c]  }
|j	                  d|
|       }}
t        ||      D cg c]  \  }}|j                  ||       }}}t        |||      D 	
cg c]  \  }}	}
|j                  ||	|
       }}	}}
t        ||      D 
cg c]  \  }}
|j                  |||
       }}}
||fS c c}
}	w c c}
w c c}}w c c}
}	}w c c}
}w )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   rI   rU  r  )r   r   r   r   r  r  r  )r   r?   r   r   r9  	bc_shapes
bc_stridesr   r&  taroldmismatch
src_is_onexypredsps                    rE   _bc_adjust_shape_stridesrI  8  sX    IJQ/D


u{{A
.C !$L& 9;C ##D#s3 ;H ;AGH#'%%dC5HJH,/*,EFDAqW\\!QFEF$'|V$DF F QS 3, FI F !$E7 35a ..D#. 5J 5j  ;HFF5s   D(8D.#D3D9E c           	         t        j                  ||j                        }t        j                  ||j                        }t	        | ||||      \  }}t        | ||||      \  }}|j                  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rr   r  r3  )r
   r   rg   r   r=  rI  copyr   rz   r   r   rl   r   r   r   )	r   r?   arrtyper  r9  r   r   new_arrtypenew_arrs	            rE   _broadcast_to_shaperQ  O  s     !!'3995F""7CKK8G*7GVW+79OFG.w/6FOFG,,C$5c,BK%j%gw7G7 ++GV<"--gw?LL;;**& rG   c                 ^    |j                  |j                  dd      } |||      }d }||fS )NrK  T)rr   r  readonlyc                 n   |\  }}|j                   d   } t        |      | ||      }t        j                  ||      }t	        | ||||      \  }}t        |dt        | j                  |j                  j                  d            d              |j                         }	t        | ||j                  |	      S )Nr   r   )r   rz   r
   r   rQ  r   r   r   r   r   r   r!   r   )
r   r?   r]   r   r1  shape_r'  r  destr   s
             rE   codegenz$_numpy_broadcast_to.<locals>.codegenn  s    Vj#6%%gv6%gwsFL4 	h&&t'?'?'IJ! 	 nn '3??CHHrG   )rM  r   )	typingctxr   rg   retr]   rW  s         rE   _numpy_broadcast_torZ  i  s8    
**%++cD*
AC
eU
CI <rG   c                 D    |j                  d      } ||      }d }||fS )NTrS  c                     |\  }|j                   d   } t        |      | ||      }t        j                  |j                  j
                        |_        |j                         }t        | ||j                  |      S r   )	r   rz   r
   get_null_valuer   r;   r   r!   r   )r   r?   r]   r   r1  r'  rV  r   s           rE   rW  z#get_readonly_array.<locals>.codegen  sh     z% '37,,T[[-=-=>nn '3??CHHrG   )rM  )rX  r  rY  r]   rW  s        rE   get_readonly_arrayr_    s/     ((D(
!C
c(CI <rG   c                    | j                   }t        |      }t        |      }||kD  rt        d      |D ]  }|dk  s	t        d       d}||z
  }||k  r1||   }||   }	||	k(  s|dk(  r|dz  }|dz  }nt        d      ||k  r0y y )NzDinput operand has more dimensions than allowed by the axis remappingr   z4all elements of broadcast shape must be non-negativerI   z=operands could not be broadcast together with remapped shapes)rg   r   r   )
r   
dest_shape	src_shapesrc_ndim	dest_ndimr   	src_index
dest_indexsrc_dimdest_dims
             rE   _can_broadcastri    s    I9~HJI) 1 2 	2 -!8 , - -- IX%J
h
I&j) h'Q,NI!OJ 4 5 5 h
rG   c                 \    t        j                  |       } t        | |       t        | |      S r=  )npasarrayri  rZ  r   rg   s     rE   _default_broadcast_to_implrn    s'    JJuE5% ue,,rG   c           	      d   t        |       st        j                  d      t        |t        j
                        rd }|S t        |t        j                        rAt        |j                  t        j
                        sd}t        j                  |      t        S t        |t        j                        ra|j                  dkD  rRt        |D cg c]  }t        |t        j                         c}      sd| d}t        j                  |      t        S t        |t        j                        rc|j                  dk(  rTt        | t        j                        xr | j                  dk(  }t        |       s|rd }|S d}t        j                  |      d	|z  }t        j                  |      c c}w )
Nz-The first argument "array" must be array-likec                 0    t        j                  | |f      S r=  )rk  broadcast_torm  s     rE   r   z numpy_broadcast_to.<locals>.impl  s    ??55(33rG   z7The second argument "shape" must be a tuple of integersr   "z," object cannot be interpreted as an integerc                 B    t        j                  |       } t        |       S r=  )rk  rl  r_  rm  s     rE   r   z numpy_broadcast_to.<locals>.impl  s     

5))%00rG   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}   rn  Tupler   allIntegerLiteralr   rr   r   )r   rg   r   r   typis_scalar_arrays         rE   numpy_broadcast_torz    sa   E"   "1 2 	2 %'	4	E5>>	*%++u}}5KC$$S))))	E5;;	'EKK!OUKcJsE$8$89KLeWHIC$$S))))	E5;;	'EKK1,<$UEKK8LUZZ1_% O1
 K DC$$S))   %%+ Ls   !F-c                     t        t        |            D ]O  }|t        |      z
  |z   }||   }|dk  rt        d      |dk(  r/| |   dk(  r|| |<   =| |   |k7  sFt        d       y )Nr   #negative dimensions are not allowedrI   z=shape mismatch: objects cannot be broadcast to a single shape)r:   r   r   )rmrg   ro   r   tmps         rE   numpy_broadcast_shapes_listr    s    3u: 3E
NQAh7BCC!8Q419AaDqTS[ 2 3 33rG   c                  |  	 t        |       D ]  \  }}t        |t        j                        }t        |t        j                        xr$ t        |j
                  t        j                        }t        |t        j                        xr t        |j                        dk(  }|r|r|rd| d| }t        j                  |       d| D ]Y  }t        |t        j                        rt        d      *t        |t        j                        sEt        t        |            [ dk(  rd S dz  		fd}|S )Nr   z	Argument z* must be either an int or tuple[int]. Got rI   c                       yr  rr  r   s    rE   <lambda>z+ol_numpy_broadcast_shapes.<locals>.<lambda>
      rG   rI   c                     dgz  }}t        |       D ]M  }t        |t              rt        |      dkD  rt	        ||       /t        |t
              s@t	        ||f       O t        |      D ]  \  }}t        |||      } |S r  )r   r   r   r   r  r   	enumerater1   )r   r}  rF  argr   elemr~  tup_inits         rE   r   z'ol_numpy_broadcast_shapes.<locals>.impl  s    aAC%d+ >c5)c#hl/1c:S)/1sf=	>
 'q\ 4	T#Cd34JrG   )r  r   r   r   rt  r}   ru  r   r	   r   maxrI  )
r   r   r  is_intis_int_tupleis_empty_tupler   r   r~  r  s
           @@rE   ol_numpy_broadcast_shapesr    s    dO *SC/!#u~~6 1syy%--0 	#C5M#cii.A:M,.se $ C$$S))* 	
A !c5==)Aq	AU__-As3x A	! 	Av!8	 rG   c                     t        |       D ])  \  }}t        |      rt        j                  d| d       d }d }| D ]]  }t	        |t
        j                  t
        j                  f      r|j                  }n|}||}A||k7  sGt        j                  d|         dt        |       D ]  \  }}t	        |t
        j                        rt        |j                        7t	        |t
        j                  t
        j                  t
        j                  f      rt        d      }t        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   rI   zUnhandled type r   c                  `   dgz  }t        |       D ],  }t        |t        j                  |      j                         . }t              D ]  }t        ||||         } g }t        |       D ]:  }|j                  t        j                  t        j                  |      |             < |S r  )	r   r  rk  rl  rg   r:   r1   rk   rq  )r   rg   r   rF  ro   outsr~  r  s         rE   r   z$numpy_broadcast_arrays.<locals>.impl@  s    
 a#D) 	KE'q"**U2C2I2IJ	K q 	2AQa1C	2 #D) 	AEKK

5(93?@	ArG   )r  r   r	   r   r   r   r   rI  r}   ArrayCompatibler  rr   Numberr  )r   r   r  unified_dtypedtr   r~  r  s         @@rE   numpy_broadcast_arraysr    sQ    dO 6S$$$z# 75 &5 6 66
 M	B 4cEKK9:BB Mb $$ &,,06&3 4 44 	
AdO >Sc5001Asxx AellEMM5??KLAq	A$$se%<==> axH( KrG   c                     t         )zTargets should implement this if they wish to specialize the error
    handling/messages. The overload implementation takes two tuples as arguments
    and should raise a ValueError.r   r%  index_shapes     rE   raise_with_shape_contextr  W  
     rG   generic)targetc                     t        | t        j                        r_t        |t        j                        rD| j                  |j                  k(  r*t        | j                  t        j                        rd }|S y y y y )Nc                     t        d      )Nz0cannot assign slice from input of different sizer   r  s     rE   r   z1ol_raise_with_shape_context_generic.<locals>.implg  s    OPPrG   r   r   rt  r}   r   r%  r  r   s      rE   #ol_raise_with_shape_context_genericr  ^  sg     	:u~~.;/K---z''7	Q	 8 	. 	0 	/rG   CPUc                     t        | t        j                        r_t        |t        j                        rD| j                  |j                  k(  r*t        | j                  t        j                        rd }|S y y y y )Nc           	      L   t        |       dk(  r
d| d    d}n,ddj                  | D cg c]  }t        |       c}       d}t        |      dk(  r
d|d    d}n,ddj                  |D cg c]  }t        |       c}       d}d| d| }t        |      c c}w c c}w )	NrI   (r   z,), )zcannot assign slice of shape z from input of shape )r   joinstrr   )r%  r  	shape_strrE  	index_strr   s         rE   r   z-ol_raise_with_shape_context_cpu.<locals>.impls  s    :!#
1b1			:*Fa3q6*F GHJ	;1$A/r2			;*Ga3q6*G HIK	29+ >%;(CS/! +G +Hs   B
-B!
r  r  s      rE   ol_raise_with_shape_context_cpur  l  sf    :u~~.;/K---z''7	"  8 	. 	0 	/rG   c                 ^   ()* |j                   \  }}*|\  }}( t        |       |      }t        j                  |j                        }	t        j                  |j
                        }
|j                  }t         ||||      }|j                          d }t        *t        j                        r*j                  )|j                         } t        *       (      (t         *(|      \  *(t        j                  (j                        }t        j                  (j
                        }(j                  }t        j                  }t!        |      t!        |      k(  sJ t#        ||      D ](  \  }}j%                  |j'                  d||            }* j)                  |d      5   | ||       ddd       t+         *(|||      \  }}|j-                  |
|j.                        \  }}t1         |||      \  }}t3         ||||      }t5         |*(|||      \  }}nt        *t        j6                        r*j                  )|j                         }t!        |      dk(  sJ  j9                  t         t;        t        j<                  *            } |(f      }j'                  d|d   |      }j)                  |d      5   | |f|d   f       ddd        ()*fd}d	 }n
*)(fd
}d } j?                  t        j@                  d      } |jC                         \  }!}"tE        |"      }"|jF                  D ]  }#|"jI                  |#|         |"D $cg c]  }$|$|$	 }%}$ ||%      }& jK                  |&)|j                        }&t        jL                   ||	|
|jN                  |!d jP                  	      }'tS         ||&|'       |jU                           |         jW                         S # 1 sw Y   MxY w# 1 sw Y   /xY wc c}$w )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.
    c           	         | j                   j                  t              }t        j                  t        j
                  t        |            t        j                  t        j
                  t        |            f}|j                  | j                   |i       }| j                  ||      } ||| j                  ||j                  d   |      | j                  ||j                  d   |      f       y Nr   rI   )typing_contextresolve_value_typer  r   rt  int64r   get_call_typerS   
make_tupler   )r   r?   r%  r  fntyargtys	raise_sigfuncs           rE   raise_shape_mismatch_errorz2fancy_setslice.<locals>.raise_shape_mismatch_error  s     %%88$&..c*o>..c+.>?A&&w'='=vrJ	##D)4Ww))'9>>!3D*46))'9>>!3D*578 	9rG   rU  FrV  NrI   r   c                     | \  }j                  t        j                  t        t        j
                              } ||f      S r=  )rS   operatorgetitemr%   r   r   )r  r   getitem_implr?   r   r1  	src_dtyper'  s      rE   r)  z#fancy_setslice.<locals>.src_getitem  sF    !DC"//  )UEJJ7L  #s44rG   c                       y r=  rr  rr  rG   rE   r.  z#fancy_setslice.<locals>.src_cleanup      rG   c                     S r=  rr  )r  r1  s    rE   r)  z#fancy_setslice.<locals>.src_getitem  s    JrG   c                       y r=  rr  rr  rG   rE   r.  z#fancy_setslice.<locals>.src_cleanup  r  rG   r  ),r   rz   r
   r   rg   r   r   r  rd  r   r   r   r}   rj  rQ  r  r   r   r  r  r  r  r  r   r  r  r4  SequencerS   r%   r   r   r   r  r   r  r  r   r  r  r6  r   r  r^  )+r   r?   r]   r   r   r   r   r  r   dest_shapesdest_strides	dest_datar  r  r  r%  r&  r$  shape_errorur   	src_startsrc_end
dest_lower
dest_upper
dest_startdest_endr(  r)  r.  len_implseq_lenr   dest_indicesr  ro   r  r  r   r3  r1  r  r'  s+   ``                                      @@@rE   rK  rK    s0    hhOE1eKCC
*U
GWc
2C&&w		:K''=LI7GUC&1GOO9 %&KK	'')j#6('5#)46
s))'399=
**7CKK@88 '';3z?222
K0 	GDAq!++k&-&9&9$1&EGK	G __[_7 	4&w'24	4
 6gw69:6A8M	7 ")!:!:<;><<"I
J5gw6@*6? A
H 'wG'18= $5Wgx5:C5@($L [ 
E5>>	*KK	 '');1$$$''Yuzz5-IJ7SF+))$AH__[_7 	:&w'(3A'8:	:	5 	5	 			 Q/D"..0L& &\F
 __ a "(9A1=a9N9
n
%C ,,wY
<C (('9)4l).|495<5O5O	QH
 wX6M""$$A	4 	4B	: 	:V :s$   9PP4P*<P*PP'c           
         |j                   d   }|j                   dd  }|d   }|dd  }t        ||      D 	cg c]'  \  }}	| j                  ||	|t        j                        ) }}}	t        j                  |||d   j                        }
t        j                  t        j                  t        |            }t        j                  |j                  ||      }||
f}||fS c c}	}w )Nr   rI   r}   r   )r   r   r   r   r   r
   rl   r;   rt  r   r   r%   r   )r   r?   r]   r   r   dimtysr   rn   r@  r   rg   shapetynew_signew_argss                 rE   vararg_to_tupler    s    HHQKEXXab\F
q'C8D vt,.C LL#r5::6 .D . wd1gll;Enn5::SY?Gsw?GEzHH.s   ,C"zarray.transposec                 >    t        | ||j                  d   |d         S r   )array_Tr   r   r?   r]   r   s       rE   array_transposer  0  s    7GSXXa[$q'::rG   c                     t        |       t        t        |             k7  rt        d      t        |      }| D ]   }||k\  st        |      |kD  st        d       ||    |d d  ||    |d d  y )Nzrepeated axis in transposez2axis is out of bounds for array of given dimension)r   r   r   abs)r   rg   r   rv  rE  s        rE   permute_arraysr  5  sy    
4yCD	N"566
e*C 08s1v| / 0 00
 T{E!HGAJrG   c           
      v   |j                   d   } t        |      | ||d         }|j                   d   |d   }}|j                  |j                  }	}| j	                  t
        j                        }
t        j                  |
|      }||j                  |j                  g}|D cg c]  }t        j                  ||       }}t        ||      D ]  \  }}|j                  ||        t        j                  |	dd      }| j!                  t
        j                  | j#                  |
            }|D cg c]  } t        |      | |       }}t        ||      D ]T  \  }}t%        ||j'                  ||
j)                               | j!                  t
        j                  |      g|g|d        V | j+                  |t,        t/        j0                  t
        j2                  |||      |D cg c]  }|j5                          c}        t        |j6                        | |      }t%        ||j8                  |j;                  |d         |j;                  |d         |j<                  |j>                  |j@                         |j5                         }tC        | ||j6                  |      S c c}w c c}w c c}w )Nr   rI   r   r}   rr   r  r   rg   r   r   r   r\  r3  )"r   rz   r   r}   r   r   r   r   	ArrayTyperg   r   r
   rY   r   r  r   r   r~   r   r+  
as_pointercompile_internalr  r   r%   voidr   r   r   r@   r   r   r   r!   )r   r?   r]   r   r   r   axistyr   num_axisr}   rw  ll_ary_sizearysr  ll_arysr1  dst	np_ary_tynp_itemsizenp_arysnp_aryll_aryarY  r   s                            rE   array_transpose_tupler  D  sg   HHQKE
*U
GWd1g
6C88A;QDFllFLLeH$$UZZ0G,,w1K #))S[[)DBFGQw""7K8GGG g&  Sc3  %a<I&&uzz'.'='=g'FHK AEE1$z)$Wg6EGE gw/ %v#OOFG4F4F4HI%225::xHI +} +#	%% Wn#--ejj.7IO5<=akkm=? &*S__
%gw
7C3 gaj1"<<
3LL;;**& --/CWgsDDO H F  >s   $J,4J1,J6c                 @    t        | |||      \  }}t        | |||      S r=  )r  r  r   r?   r]   r   r  r  s         rE   array_transpose_varargr  {  s(    '#tDGX '7HEErG   c                 |    t        | t        j                        rt        j                  d      |dd}|S dd}|S )Nz#np.transpose does not accept tuplesc                 "    | j                         S r=  	transposer  axess     rE   np_transpose_implz*numpy_transpose.<locals>.np_transpose_impl  s    ;;= rG   c                 $    | j                  |      S r=  r  r  s     rE   r  z*numpy_transpose.<locals>.np_transpose_impl  s    ;;t$$rG   r=  )r   r   rI  r	   r   )r  r   r  s      rE   numpy_transposer    sA    !U__%  !FGG|	! 	% rG   Tc                 4   |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                         |j                         }t        | |||      S )NrI   r3  )rr   rz   r
   r   rg   r   r   r   rl   r   r   r   r   r!   )	r   r?   rx  r	  r   r   rY  r   r   s	            rE   r  r    s    
xx1}jogw6jogw/%%gsyy#((C&&wSXXFsHH$//"F&11'74R4=I #"{{!jj	* mmoWgsC88rG   c                 4   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 integerc                 \    t        j                  | ||      }t        j                  d|      S )Ng      $@)rk  linspacepower)r!  r  numrF  s       rE   r   znumpy_logspace.<locals>.impl  s%    KKtS)xxa  rG   2   )r   r   r  r	   r   r   r   )r!  r  r  r   s       rE   numpy_logspacer    ss    eU\\*  !NOOdELL)  !NOOcC/0  !NOO! KrG   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              r:t        t        j                  t        |       t        |      d             dfd	}|S 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   P   K   | ]  }t        |t        j                           y wr=  r   r   Complexr?  r  s     rE   rA  z"numpy_geomspace.<locals>.<genexpr>       
Cc:c5==)
CrB  c                 F   | dk(  s|dk(  rt        d       	|       }  	|      }t        dk  rz| 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kD  r| |d<   |dkD  r||d<   ||z  S )Nr   &Geometric sequence cannot include zeror[  r  rI   y              ?)r   r   realrk  signimaglog10logspace)
r!  r  r  both_imaginaryboth_negativeout_signlogstartlogstopr  result_dtypes
            rE   r   znumpy_geomspace.<locals>.impl  s'   zTQY !IJJ 'E%Dv%"'**/dii1n!E!#2!5"''$-2:M N!!JJE99D!H "FE 5D (yH775>! xxHhhtnG[[7C8F Qw!q	7!%F2Jf$$rG   c                 \   | 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kD  r| |d<   |dkD  r||d<   ||z  S )Nr   r  r  rI   )r   rk  r  r  r  )r!  r  r  r  r  r   r!  r  s           rE   r   znumpy_geomspace.<locals>.impl  s    zTQY !IJJWWU^r1bggdmr6IJMHu$9xxHhhtnG[[7C8F Qw!q	7!%F2Jf$$rG   r  )r   r   r  r	   r   r   r   rC  r   rk  result_typer   )r!  r  r  r   r   r"  s        @rE   numpy_geomspacer%    s    eU\\*5  %%dELL)4  %%cC/05  %%

CeT]
CC!"..%19$#G H 	%p K+	%* KrG   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.c                 B   |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   rI   r\     )rk  swapaxesfliplrflipudr  )r~  r   s     rE   r   znumpy_rot90.<locals>.impl  s    E6Q4K!V;;ryy|Q22!V99RYYq\**!V99R[[Aq122  rG   r  )	r   r   r   r   r	   r   r   rr   NumbaValueError)r~  r   r   s      rE   numpy_rot90r/    sr     a#u}}-.  !MNNa%  !JKKvvz$$%<==! KrG   c                    | j                  t        j                        }|j                         }| j                  t        j                        }	t        j                  |	||||||||	g      }
t        j                  |j                  |
d      } ||j                        }t        j                  ||j                  d      dd      }t        j                  ||j                  d      dd      } ||      }t        j                  ||dd      }t        j                  ||dd      } |	d      }|j                  ||||||||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_reshaperg   r   r   )r   r   r   r  intcr   FunctionTyper
   get_or_insert_functionr<   rr   rj   ri   callr   )r   r?   r   r   newndnewshape
newstridesrw  ll_intp_starll_intcr  fnndrg   r   
is_f_orderr   s                    rE   _attempt_nocopy_reshaper>    sE    $$UZZ0G%%'L$$UZZ0G??7||% D 
	'	'(F
HB 
	B  #*>*>w*GANE""7C,@,@,K#$a)GENE##GXq!<H%%gz1a@JJ
,,rBw!8ZLL*6 7C JrG   c                     d}d}t        |      D ]  \  }}|dk  r|dz  }|}||z  } |dk(  r| |k7  rt        d      y |dk(  r-|dk(  rd}| dk(  }n| |z  }| |z  dk(  }|st        d      ||<   y t        d      )Nr   rI   z)total size of new array must be unchangedzmultiple negative shape values)r  r   )	origsizerg   num_neg_value
known_sizer+  r   neg_axinferredoks	            rE   normalize_reshape_valuerF  @  s    MJ5! Aq5QMF!OJ z!HII " 
!	?HQB:-HJ&!+BHII f 9::rG   zarray.reshapec           	         |j                   d   }|j                  }|j                   d   }|d   }| j                  t        j                        }t        j                  ||j                        }	 t        |      | ||d         }
t        j                  ||	      }|j                  ||       t        j                  |j                  dd      } t        |      | |      }| j                  t        j                  | j                  |            }t!        ||j#                  ||j%                               | j                  t        j                  |j                        g|g|d        |
j&                  }| j)                  |t*        t-        j.                  t        j0                  t        j2                  |      ||j5                         g       |j                  }t        j                  ||	      }t7        | |||
|||      }|j9                  d||j;                  d            }|j=                  |      5  d}| j>                  jA                  |tB        |f       d d d         t        |      | |      }t!        ||
jD                  |jG                  |      |jG                  |      |
jH                  |
jJ                  |
jL                         |j5                         }tO        | ||j                  |      S # 1 sw Y   xY w)	Nr   rI   r   r  r  r  zincompatible shape for arrayr3  )(r   r   r   r   r   r   r  r   rz   r
   rY   r  r   r}   r   r~   r   r+  r  r   r  rF  r   r%   r  r   r   r>  r  r;   r  rX  rY  rT   r   r@   r   r   r   r!   )r   r?   r]   r   r   rettyr  rg   rw  ll_shaper   r7  shape_ary_ty	shape_aryshape_itemsizer   r6  r8  rE  failr   rY  r   s                          rE   array_reshaperN  ^  s   HHQKEOOEhhqkGGE$$UZZ0G||GW]]3H
*U
GWd1g
6C ""7H5HMM%" ;;W]]3GL(
<(':I))%***1*@*@*IKN9'2D2D2FG!..uzz7==IJ*+*! ::D W&=#--ejj.3kk<I"I$7$7$9:< MME$$Wh7J	 '5#u!):
7B  r2771:6D		 P,))'3FOP *U
GW
-C3 h/"<<
3LL;;**& --/CWgsDDP Ps   4%K33K<c                 @    t        | |||      \  }}t        | |||      S r=  )r  rN  r  s         rE   array_reshape_varargrP    s(    '#tDGX'7H==rG   )r\  rI   c                     d }|S )Nc                 $    | j                  |      S r=  reshape)r  r7  s     rE   np_reshape_implz#np_reshape.<locals>.np_reshape_impl  s    99X&&rG   rr  )r  r7  rU  s      rE   
np_reshaperV    s    	'rG   c                     d }|S )Nc                 $    | j                  |      S r=  rS  )r  rg   s     rE   rU  z#np_reshape.<locals>.np_reshape_impl  s    99U##rG   rr  )r  rg   rU  s      rE   rV  rV    s    	$rG   c                 .   t        |       sd}t        j                  |      t        |t        j
                        r$t        |j                  t        j                        s1t        |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                 0   t        j                  |       } t        j                  |       } t        |t              r4d}t        j                  |      D ]  }||z  }|dk  sd}t        |       n|dk  rd}t        |      |}| j                  dk(  r.t        j                  |      j                  | j                        S | | j                  z   }| }t        |dz
        D ]  }t        j                  || f      } |d | }t        j                  ||      S )NrI   r   z0All elements of `new_shape` must be non-negative)rk  rl  ravelr   r   r   r   zerosastyper}   r:   concatenaterT  )	r  	new_shapenew_size
dim_lengthr   msg2repeatsr   ro   s	            rE   r   znumpy_resize.<locals>.impl  s   JJqMHHQKi'H jj3 *
J&>LC$S/)	* 1}I && H66Q;88I&--agg66I'(w{# 	+A..#q*C	+)8nzz#y))rG   )r   r	   r   r   r   rt  r}   r   )r  r`  r   r   s       rE   numpy_resizere    st     A3  %%	5>>2	7y%--0%  %%*8 KrG   c                    t        |       st        j                  d      t        |      st        j                  d      t        |      rdd}|S t	        |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 r=  )rk  r\  rl  r_  r  valuesr   s      rE   r   znp_append.<locals>.impl  sB    ((2::c?+CXXbjj01F>>3-00rG   z,The third argument "axis" must be an integerc                 4    t        j                  | |f|      S Nr   rk  r_  rh  s      rE   r   znp_append.<locals>.impl  s    >>3-d;;rG   r=  )r   r	   r   r   r   r   r   )r  ri  r   r   s       rE   	np_appendrn    s     C   !NOOF#   ". / 	/ 4	1 K $.$$ &/ 0 0	<KrG   zarray.ravelc                     d }d }|j                   d   j                  dk(  r|}n|}| j                  ||||      }t        | ||j                  |      }|S )Nc                 8    | j                  | j                        S )zNo copy version)rT  r   r   s    rE   
imp_nocopyzarray_ravel.<locals>.imp_nocopy  s    {{388$$rG   c                 "    | j                         S )zCopy version)flattenrq  s    rE   imp_copyzarray_ravel.<locals>.imp_copy	  s    {{}rG   r   r   )r   r  r  r"   r   )r   r?   r]   r   rr  ru  impr   s           rE   array_ravelrw    s_    %
 xx{S  

"
"7Cd
;C
7GS__c
BCJrG   c                 0    d }| j                  ||||      S )Nc                 "    | j                         S r=  )r\  r  s    rE   np_ravel_implznp_ravel.<locals>.np_ravel_impl	  s    wwyrG   )r  )r   r?   r]   r   r{  s        rE   np_ravelr|  	  s      ##G]CFFrG   zarray.flattenc                 d    d }| j                  ||||      }t        | ||j                  |      }|S )Nc                 T    | j                         j                  | j                        S r=  )rM  rT  r   rq  s    rE   rv  zarray_flatten.<locals>.imp	  s    xxz!!#((++rG   )r  r"   r   )r   r?   r]   r   rv  r   s         rE   array_flattenr  	  s8    , 
"
"7Cd
;C
7GS__c
BCJrG   c                    |t        j                  |       n|}t        j                  | ||      \  }}}t        j                  |j                        D ]*  }||   }	||   }
||   }t        t        |	|
      |      ||<   , |S r=  )rk  
empty_likebroadcast_arraysndindexrg   minr  )r  a_mina_maxr   rY  a_ba_min_ba_max_br   val_a	val_a_min	val_a_maxs               rE   _np_clip_implr  &	  s     "k"--
sC//5%@C'CII& ;E
EN	EN	UI.	:E
	; JrG   c                     t        j                  | j                        D ]-  }| |   }||   }|rt        ||      ||<   t	        ||      ||<   / |S r=  )rk  r  rg   r  r  )r  buse_minr   r   r  val_bs          rE   _np_clip_impl_noner  4	  sZ    AGG$ +%%UE*CJUE*CJ+ JrG   c                 &   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 xs t        |t        j
                        }|d u xs 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 )NrZ  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       rE   
np_clip_nnznp_clip.<locals>.np_clip_nnY	  s    EFFrG   c                     |t        j                  |       n|}t        j                  | j                        D ]   }| |   }t	        t        ||      |      ||<   " |S r=  )rk  r  r  rg   r  r  r  r  r  r   rY  r   r  s          rE   
np_clip_ssznp_clip.<locals>.np_clip_ssb	  s[     '*k"--"sCAGG, ;% UE!2E:E
; JrG   c                     |t        j                  |       n|}t        j                  | j                        D ]  }| |   }t	        ||      ||<    |S r=  )rk  r  r  rg   r  r  s          rE   
np_clip_snznp_clip.<locals>.np_clip_snp	  T     +.+bmmA&3ZZ0 3EeHE!$UE!2CJ3 
rG   c                 J    t        j                  | |      }t        | |||      S r=  rk  	full_liker  )r  r  r  r   
a_min_fulls        rE   
np_clip_saznp_clip.<locals>.np_clip_sa}	  s%    
  \\!U3
$Q
E3??rG   c                     |t        j                  |       n|}t        j                  | j                        D ]  }| |   }t	        ||      ||<    |S r=  )rk  r  r  rg   r  r  s          rE   
np_clip_nsznp_clip.<locals>.np_clip_ns	  r  rG   c                 J    t        j                  | |      }t        | |||      S r=  r  )r  r  r  r   
a_max_fulls        rE   
np_clip_asznp_clip.<locals>.np_clip_as	  s%    
  \\!U3
$Qz3??rG   c                     |t        j                  |       n|}t        j                  | |      \  }}t        ||d|      S )NTrk  r  r  r  )r  r  r  r   rY  r  r  s          rE   
np_clip_naznp_clip.<locals>.np_clip_na	  s=    *-+bmmA&3!221e<W)#wcBBrG   c                     |t        j                  |       n|}t        j                  | |      \  }}t        ||d|      S )NFr  )r  r  r  r   rY  r  r  s          rE   
np_clip_anznp_clip.<locals>.np_clip_an	  s=    *-+bmmA&3!221e<W)#wsCCrG   c                     t        | |||      S r=  )r  r  s       rE   
np_clip_aaznp_clip.<locals>.np_clip_aa	  s     %Quc::rG   r=  )	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                     rE   np_clipr  @	  s   A  !FGGuenn- '   #4 6 	6 uenn- '   "4 5 	5 sEKK(K,<E  %% TMFZu~~%FMTMFZu~~%FM	G  5O 5O?		 		 @ 	 @  C D ; rG   clipc                     dd}|S )Nc                 2    t        j                  | |||      S r=  )rk  r  r  s       rE   r   zarray_clip.<locals>.impl	  s    wwq%,,rG   NNNrr  )r  r  r  r   r   s        rE   
array_clipr  	  s    -KrG   c           	      v   |j                   |j                   k(  sJ |j                  |j                  k(  sJ t        |j                        }t        d      t        d      t        d      t        j                  fd}| j                  t        j                  t        | |            }| j                  t        j                  t        | |            }| j                  t        j                  |j                         }	t        j                  ||j                  d      dd      }
t        j                  ||j                  d      dd      }t        j                  t        j                  dd	      }| j                  |      }t        j                  || j                  t        j                  |j                         g      }| j                  | j                  t        j                              }| j                  t        j                  |      }t        j                  ||g      } || |      }t!        ||
|||d
        || |      }t!        |||||d
       |j#                         }|j#                         }|	||||| j                  t        j                  |      g}t%        t        j&                  t        j                  ||t        j                  t        j                  t        j                        }| 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.
    rK  r   Fc                 "   |	k(  r!|d   |k(  r	 
      }n|d   |k(  r       }||k7  r|	k(  s| dk(  ry|
k(  r| dz
  }nd}||k  r!||z  dk7  ry||z  }||xx   |z  cc<   |||<   y||kD  r||   |z  }||z  dk7  ry||z  ||<   |||<   y	 y)Nr  r   FrI   Trr  )r<  rn   r   old_itemsizenew_itemsizer  ro   newdim
bytelength
any_layoutc_layoutf_layoutint8s            rE   rv  z_change_dtype.<locals>.imp	  s     Zr{l*h|+h<'Vz-AR1WXQAA,& |+1!\1FGvG%GAJ"  L( a</J\)a/ L0DG%GAJ  rG   rg   r   r   rI   r  Nr  )rr   r  ordr   r  r   r   r   r
   rj   ri   r   rz   rl   r~   r|   r   r   r%   booleanr  r   r!   r   )r   r?   oldtynewtyr   
new_layoutrv  r  r  r<  
shape_datastrides_datashape_strides_array_typearyclsshape_constantsizeof_intpstrides_constantrK  strides_aryrg   r   r   r]   r   r  r  r  r  s                           @@@@rE   _change_dtyper  	  s    ::###<<5<<'''U\\"JSJ3xH3xH::D.` ''

(4We(DFL''

(4We(DFL 
		ejj%**	5B%%gs/C/CG/L&',J''(+(<(<Y(GAOL  %{{!CP 89F'')0)=)=ejj>Cjj*J )KLN (()>)>uzz)JKK&&uzz;?K))'K=Aw(I9"'+'! '*K;$'+'! !E##%Gwl  Z8:D EMMJJ,,JJJJJJC 
"
"7Cd
;CeS!
GWcoos
CCJrG   c                 L    t        |       st        j                  d      d }|S )Nz+The argument to np.shape must be array-likec                 @    t        j                  |       j                  S r=  )rk  rl  rg   rz  s    rE   r   znp_shape.<locals>.implD
  s    zz!}"""rG   r   r	   r   r  r   s     rE   np_shaper  ?
  s&    A  !NOO#KrG   c                 L    t        |       st        j                  d      d }|S )Nz*The argument to np.size must be array-likec                 @    t        j                  |       j                  S r=  )rk  rl  r   rz  s    rE   r   znp_size.<locals>.implN
  s    zz!}!!!rG   r  r  s     rE   np_sizer  I
  s&    A  !MNN"KrG   c                     d }|S )Nc                    d }t        j                  | j                               }t        |d d       }t	        |dd        D cg c]"  \  }}||   |k7  r |||         r ||      s|$ }}}t        j
                  ||z         S c c}}w )Nc                     | | k(   S r=  rr  )rE  s    rE   isnanz0np_unique.<locals>.np_unique_impl.<locals>.isnanX
  s    Q<rG   rI   )rk  sortr\  r   r  r   )arr  r  headro   rE  tails          rE   np_unique_implz!np_unique.<locals>.np_unique_implW
  s    	  GGBHHJAbqE{#AabE*
!Qtqy%!+%( 
 
 xxt$$	
s   'Brr  )r  r  s     rE   	np_uniquer  U
  s    
% rG   c                    d }t        | t        j                  t        j                  t        j                  t        j
                  t        j                  f      rt        |t        j                        rt        S t        |t        j                  t        j                  f      r&t        |j                  t        j                        r|S t        j                  d      y )Nc                 @   t        j                  |t         j                        }|j                  d   dk(  rt	        | |d         S t        j
                  |dk        rt        d      t        j                  |       }|j                         }|j                  d   }|j                  |j                  k7  rt        d      t        j                  t        j                  |      |j                        }d}t        |      D ]  }||   |||||   z    |||   z  } |S )Nr}   r   rI   r|  z(operands could not be broadcast together)rk  rl  r  rg   np_repeat_impl_repeats_scalerrC  r   r\  emptyr  r}   r:   )	r  rd  repeats_arrayasaaraveln	to_returnposro   s	            rE   !np_repeat_impl_repeats_array_likez4np_repeat.<locals>.np_repeat_impl_repeats_array_likej
  s   

7"((;q!Q&0M!4DEE66-!#$BCCjjmLLO<<=...:< <HHRVVM2#))D	q 	$A6<QiIcC-"223=##C	$ rG   zIThe repeats argument must be an integer or an array-like of integer dtype)r   r   r   ListrI  r  r  r   r  r}   r	   r   )r  rd  r  s      rE   	np_repeatr  e
  s    
, !ekkjjoollmm	  gu}}-00%++uzz!:;'--788  01 	1rG   c                    |dk  rt        d      t        j                  |       }|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  rI   )	r   rk  rl  r\  rg   r  r}   rM  r:   )r  rd  r  r  r  r  ro   s          rE   r  r  
  s    {>??
**Q-CYY[FQA!|xx++	AwwvHHQ[		:	q 	CA9?Ia'kQUg$56	CrG   repeatc                     d }|S )Nc                 .    t        j                  | |      S r=  )rk  r  )r  rd  s     rE   array_repeat_implz'array_repeat.<locals>.array_repeat_impl
  s    yyG$$rG   rr  )r  rd  r  s      rE   array_repeatr  
  s    % rG   c                 :    t        j                  |      }d }||fS )z"Computes the itemsize of the dtypec                     | j                  |j                  d   j                        }| j                  |j                        } || j	                  |            S r   )r|   r   r}   r   r~   )cgctxr?   r]   llargsr   llintps         rE   rW  z%_intrin_get_itemsize.<locals>.codegen
  sJ    ""388A;#4#45$$S__5e**4011rG   )r   r   )tyctxr}   r]   rW  s       rE   _intrin_get_itemsizer  
  s#     **U
C2 <rG   c                      y r=  rr  )r  r}   s     rE   _compatible_viewr   
      rG   c                     d }|S )zDDetermines if the array and dtype are compatible for forming a view.c                    t        |      }|| j                  k7  r| j                  dk(  rd}t        |      	 | j                  dz
  }| j                  |   dk7  }| j
                  dk7  }| j                  |   | j                  k7  }|r|r|rd}t        |      || j                  k  r%|dk(  s| j                  |z  dk7  rd}	t        |	      y | j                  |   | j                  z  }
|
|z  dk7  rd}t        |      y y )Nr   zOChanging the dtype of a 0d array is only supported if the itemsize is unchangedrI   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   rr   r   rg   r   r   )r  r}   
dtype_sizemsg1r   p1p2p3rc  msg3r  msg4s               rE   r   z ol_compatible_view.<locals>.impl
  s   )%0
#vv{7 &&  66A:D!#B1B4AJJ.Brb2 &&AJJ&?ajj:&=&BID$T** 'C
 3J&!+1D %T**	 ,9 $rG   rr  r  r}   r   s      rE   ol_compatible_viewr  
  s    "+F KrG   z
array.viewc                    |j                   d   }|j                  } t        |      | ||d         } t        |      | |      }t        |j                  j
                        }t        |      D ]N  }	t        ||	      }
|	dk(  r.|j                  j                  }|j                  |
|      |_        Bt        ||	|
       P t        dk\  r\| j                  }|j                  t              }|j!                  |g |j                   i       }| j#                  ||      } |||       t%        | ||||      }|j'                  d|t)        |j                  d            }|j+                  |      5  d}| j,                  j/                  |t0        |f       d d d        |j3                         }t5        | ||j                  |      S # 1 sw Y   1xY w)Nr   r   )rI      r  z"new type not compatible with array)r   r   rz   r   r   r   sortedgetattrr   r;   r+  r   r   r  r  r   r  rS   r  r  r   r  rX  rY  r   r   r!   )r   r?   r]   r   r   rH  r   rY  fieldsr   r   r#  r  r  _compatible_view_sigr   rE  rM  r   r   s                       rE   
array_viewr  
  s   HHQKEOOE
*U
GWd1g
6C
*U
GW
-C''(FF^ !c1o;HHMMEsE2CHCC !  &&''(89#11%388rJ##D*>?Wd	ws	;B  r8BGGQ+?@D		 G2))':vFG --/CWgsDDG Gs   +%G  G	r}   c                 >    | j                         }t        | |||      S r=  )r^  r#   r   r?   rx  r	  r   s        rE   array_dtyper    s!    

!
!
#CgwS99rG   rg   c                 `    t        |      } || ||      }|j                  }t        | |||      S r=  )rz   rg   r#   r   r?   rx  r	  r   r   r   s          rE   array_shaper    s5     oGGWe,E
++CgwS99rG   r   c                 `    t        |      } || ||      }|j                  }t        | |||      S r=  )rz   r   r#   r  s          rE   array_stridesr  "  s5     oGGWe,E
--CgwS99rG   rr   c                 r    | j                  t        j                  |j                        }t	        | |||      S r=  )r   r   r   rr   r#   r  s        rE   
array_ndimr  +  s/     

uzz388
4CgwS99rG   r   c                 `    t        |      } || ||      }|j                  }t        | |||      S r=  )rz   r   r#   r  s          rE   
array_sizer  2  s3    oGGWe,E
,,CgwS99rG   r   c                 `    t        |      } || ||      }|j                  }t        | |||      S r=  )rz   r   r#   r  s          rE   array_itemsizer!  :  s5     oGGWe,E
..CgwS99rG   nbytesc                     t        |      } || ||      }|j                  |j                  |j                        }t	        | |||      S )z"
    nbytes = size * itemsize
    )rz   r   r   r   r#   r  s          rE   array_nbytesr$  C  sD     oGGWe,E
++ellENN
3CgwS99rG   
contiguousc                 r    | j                  t        j                  |j                        }t	        | |||      S r=  )r   r   r  	is_contigr#   r  s        rE   array_contiguousr(  O  s-    


u}}cmm
<CgwS99rG   c_contiguousc                 r    | j                  t        j                  |j                        }t	        | |||      S r=  )r   r   r  is_c_contigr#   r  s        rE   array_c_contiguousr,  U  -    


u}}coo
>CgwS99rG   f_contiguousc                 r    | j                  t        j                  |j                        }t	        | |||      S r=  )r   r   r  is_f_contigr#   r  s        rE   array_f_contiguousr1  [  r-  rG   rS  c                 t    | j                  t        j                  |j                         }t	        | |||      S r=  )r   r   r  mutabler#   r  s        rE   array_readonlyr4  a  s/    


u}}#++o
>CgwS99rG   ctypesc                     t        |      } || ||      }t        j                  |      }| j                  ||      }|j                  |_        |j
                  |_        |j                         }t        | |||      S r=  )rz   r   ArrayCTypesr   r   r   r   r!   )	r   r?   rx  r	  r   r   actctinfor   s	            rE   array_ctypesr:  i  sp    oGGWe,E


C
 C  #.F**FK]]FN



CWgsC88rG   r   c                     | j                  |||      }|j                  }|j                  || j                  t        j
                              }t        | |||      S Nr  )r   r   r	  r   r   r   r#   )r   r?   rx  r	  r9  r   s         rE   array_ctypes_datar=  v  sT      #U ;F
++C


3 6 6uzz B
CCgwS99rG   c                     | j                  |||      }|j                  }|j                  || j                  |            }t	        | |||      S r<  )r   r   r+  r   r#   )r   r?   fromtytotyr   r9  r   s          rE   array_ctypes_to_pointerrA    sP       & <F
++C
//#w55d;
<Cgwc::rG   c                     t        |      |||      }t        j                  t        j                  |j                        }|j                  |j                  |j                              }t        t        j                  ||t        j                        }|j                  |j                  |j                  t        j                  |      g}|j                  || ||      }	|	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  )rz   r   rt  r   rr   r~   r   r}   r%   bool_rg   r   r   r  )
checkerr   r?   r   r   tup_intpr   	check_sig
check_argsr'  s
             rE   _call_contiguous_checkrH    s     *U
GWC
8C~~ejj%**5H%%g&<&<U[[&IJH%++x5::FI))S[[&&uzz8<>J(('9)35IrG   r   c                     | j                  |t        j                  |            }||_        |j	                         }| j
                  j                  |||       t        | |||      S r=  )r   r   
ArrayFlagsr   r   r   r   r"   )r   r?   rx  r	  flagsobjr   s         rE   array_flagsrL    s[    ""7E,<,<S,ABHHO



CKKwU+GWc377rG   c                 :   |j                   j                  dk7  r<| j                  |||      }t        t        | ||j                   |j
                        }n9|j                   j                  dk(  }| j                  t        j                  |      }t        | |||      S )Nr   r  )
rd   r  r   rH  r   r   r   r   r  r#   )r   r?   rx  r	  rK  r   r   s          rE   array_flags_c_contiguousrN    s     ~~#&&w5&A$]GW%(^^X__F nn##s*""5==#6gwS99rG   c                 x   |j                   j                  dk7  r<| j                  |||      }t        t        | ||j                   |j
                        }nX|j                   j                  }|j                   j                  dkD  r|dk(  n|dv }| j                  t        j                  |      }t        | |||      S )Nr  r  rI   r  )rd   r  r   rH  r   r   rr   r   r   r  r#   )r   r?   rx  r	  rK  r   r  r   s           rE   array_flags_f_contiguousrP    s    
~~#&&w5&A$Z'%(^^X__F &&"~~22Q6fmFdN""5==#6gwS99rG   r  c                     |j                   t        j                  v rt        | |||d      S |j                   t        j                  v rt        | |||      S t        dj                  t        j                               )Nr  attrzunsupported .real for {})	r}   r   complex_domainarray_complex_attrnumber_domainr!   rT   r   r;   )r   r?   rx  r	  s       rE   array_real_partrW    se    
yyE(((!'7CVLL	e))	) '3>>!"<"C"CDJJ"OPPrG   r  c                 2   |j                   t        j                  v rt        | |||d      S |j                   t        j                  v rt        |j                  d      |      }t        | |||g      \  }}t        | |||      }t        j                  ||j                  |j                  |j                  |j                        d       t        | ||j                   |j#                               S t%        dj'                  t(        j                               )Nr  rR  Tr\  r   zunsupported .imag for {})r}   r   rT  rU  rV  r%   rM  _parse_empty_like_argsr  r
   memsetr   r   r   r   r"   r   r   rT   r   r;   )r   r?   rx  r	  r]   rN  r   r   s           rE   array_imag_partr[    s    
yyE(((!'7CVLL	e))	)$/50'3PWgw?w'++cll69jj+BCD	F#// #1 	1 ""<"C"CDJJ"OPPrG   c                    |dvs|j                   t        j                  vrt        dj	                  |            t        |      } || ||      }|j                   j                  }| j                  | j                  |            }|j                  j                  |      }	| j                  |      j                         }
|j                  |j                  |
      }|dk(  r,|j                  | t!        j"                  d      d      g      }|j%                  |d      } t        |      | |      }t'        ||	      }t)        j*                  |||       t-        | |||j/                               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      rI   rK  r}   r  )r   r   )r}   r   rT  rT   r   rz   underlying_floatr~   r|   r   r;   r   r  r+  r   r  r   IntTyperM  r   r
   copy_structr!   r   )r   r?   rx  r	  rS  r   r   fltysizeof_fltyr   
llfltptrtyr  resulttyr  repls                  rE   rU  rU    sE   8 ##syy8L8L'L!"="D"DT"JKKoGGWe,E 99%%D(()>)>t)DEK~~"";/H ''-88:Jooejj*5G v~++g

2q(9':; xxd3x/H!Z!'73FWx0Dt,Wgx9I9I9KLLrG   conj	conjugatec                     d }|S )Nc                 ,    t        j                  |       S r=  )rk  rg  r  s    rE   r   zarray_conj.<locals>.impl   s    wws|rG   rr  r  r   s     rE   
array_conjrm    s    KrG   c                 "    | j                         S r=  )r^  )r   r?   dtypetydtypevals       rE   
dtype_typerq  (  s    ""$$rG   r;   kindstatic_getitemc                     |j                   }t        |t        j                        r% | j	                  |      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   rH  r   r   s          rE   static_getitem_number_clazzrv  5  s^     OOE%% ,g$$U+D1!'7E3??L""3''rG   c           
         t        |      } || ||      }|j                  }t        |t        j                        st        d|d|d      |j                  |      }|j                  |      }	t        |t        j                        r6|j                  |j                  |j                  |j                  z   d      }
n|j                  |d      }
t        |
      } || |      }| j                  t        j                  |	      }t        j                  ||j                  ||j                  j                         }t        |t        j                        rt        j"                  ||j$                  |j                        }||j$                  D cg c]"  }| j                  t        j                  |      $ c}z  }t        j"                  ||j&                  |j                        }||j&                  D cg c]"  }| j                  t        j                  |      $ c}z  }| j)                  | j+                  |j                              }n8|j$                  }|j&                  }| j)                  | j+                  |            }t-        ||||| j                  t        j                  |      |j.                  |j0                         |j3                         }t5        | ||
|      S c c}w c c}w )	zq
    Generic getattr() implementation for record arrays: fetch the given
    record member, i.e. a subarray.
    z
attribute z of z not definedrK  r  r^  )r   r3  )rz   r}   r   r   RecordrT   typeofr   NestedArrayrM  rr   r   r   r
   r   r   r;   r   rg   r   r~   r|   r   r   r   r   r!   )r   r?   rx  r	  rS  r   r   rectyper}   r   restyrarytyraryconstoffset
newdataptrrg   ro   r   datasizer   s                       rE   array_record_getattrr  M  sR    oGGWe,EiiGgu||,!%)3#0 1 	1NN4 E^^D!F%**+++CHHuzz$9#  G uS1F'7#D&&uzz6:K$$[tyy~~J %**+$$Wekk388Du{{K!'&&uzz15KK&&wsxxHOAG((Q7OO))'*?*?*LM --))'*?*?*FG4""#00XF ==,,( ..
CWguc::' L Ps   'K)8'K.c                 v    |d   }t        |t              st        t        | ||j                  d   |d   |      S r  )r   r  rT   r  r   )r   r?   r]   r   r   s        rE   array_record_getitemr    s:    GEeS!!!#((1+tAwNNrG   c           
         | j                  ||       |j                  |      }|j                  |      }t        |t        j
                        r5t        |      } || |      }|j                  }	|j                  D 
cg c]"  }
| j                  t        j                  |
      $ }}
|j                  D 
cg c]"  }
| j                  t        j                  |
      $ }}
t        j                  |||| j                  |	            }t        ||t        j                   ||      t        j                   ||      | j                  t        j                  |j"                        dd       |j%                         }t'        | |||      S t        j                  |||| j                  |            }|j(                  rdnd}| j+                  ||||      }t'        | |||      S c c}
w c c}
w )zT
    Generic getattr() implementation for records: get the given record member.
    Nr3  rI   )sentry_record_alignmentr   ry  r   r   rz  rz   r}   rg   r   r   r   r
   get_record_memberr|   r   rl   r   r   r!   r   r   )r   r?   rx  r	  rS  r   elemtyr   r   r}   r   r7  r8  newdatar   dptrr   s                    rE   record_getattrr    s   
 ##C.ZZFZZF&%++, 6"GW%LL"AG((Q7 " " nn&ag**5::q9 &
 &++GUF,3,A,A%,HJ$$Wh7&&w
;))%**fkkB	
 mmo '3<<((%)0)>)>v)FH""7FD%@ '3<<-"&s   >'G5'G#c           	         |j                   \  }}|\  }}| j                  ||       |j                  |      }	|j                  |      }
t	        |
t
        j                        r t        j                  |      | ||d         }|j                  }t        j                  |||	|j                  j                        }t        j                  |||| j                  t
        j                  |
j                                yt        j                  |||	| j#                  |
            }| j%                  ||||
      }|j&                  rdnd}| j)                  ||
|||       y)zT
    Generic setattr() implementation for records: set the given record member.
    rI   r  Nr   )r   r  r   ry  r   r   rz  r
   ry   r   r  r;   pointeememcpyr   r   r   r|   r   r   r   )r   r?   r]   r   rS  rx  rL  r  r   r   r  
val_structr1  rV  r  r   s                   rE   record_setattrr    s1   
 JCKFC##C.ZZFZZF&%++,7W007>B1gG
oo((&&),)9)9;wc++EJJF	H ((&&)0)>)>v)FHll7C77FCUCrG   c                     | j                  |j                  d   |d         } || ||j                  d   |d   |d         S )3
    Record.__getitem__ redirects to getattr()
    r   rI   )get_getattrr   )r   r?   r]   r   r   s        rE   record_static_getitem_strr    sE    
 sxx{DG4D#((1+tAwQ@@rG   c                 2   |j                   d   j                  }t        |j                   d   j                        }| j	                  |j
                  ||         }| j                  |j                   d   |      } || ||j                   d   |d   ||         S )r  rI   r   )r   r   r   r  insert_const_stringr<   r  )r   r?   r]   r   r   r  ll_fieldr   s           rE   record_static_getitem_intr    s    
 ((1+
#
#C#((1+$$%F**7>>6#;GHsxx{H5D#((1+tAwsDDrG   static_setitemc                     |j                   \  }}}|\  }}}	t        |j                  ||      }
| j                  ||
      }|J  ||||	f      S )3
    Record.__setitem__ redirects to setattr()
    )r   r%   r   get_setattr)r   r?   r]   r   rectyr  rL  recr   r   getattr_sigr   s               rE   record_static_setitem_strr    s_    
 hhOE1eMCcCOOUE:KsK0D#s$$rG   c                     |j                   \  }}}|\  }}}	t        |j                  ||      }
t        |j                   d   j                        }| j                  ||   |
      }|J  ||||	f      S )r  r   )r   r%   r   r   r  r  )r   r?   r]   r   r  r  rL  r  r   r   r  r  r   s                rE   record_static_setitem_intr    s{    
 hhOE1eMCcCOOUE:K#((1+$$%Fvc{K8D#s$$rG   c                 (    | j                  |||      S )zB
    Create a constant array (mechanism is target-dependent).
    )make_constant_array)r   r?   r@  pyvals       rE   constant_arrayr    s    
 &&wE::rG   c                     t        j                  t        j                  d      |j                        } |t	        |j                                     }t        j                  ||      S )zG
    Create a record constant as a stack-allocated array of bytes.
       )r   r  r`  r"  	bytearraytobytesr
   r   )r   r?   r@  r  ltyr   s         rE   constant_recordr    sH    
 ,,rzz!}ell
3C
i(
)C$$Wc22rG   c                     t        j                  t        |      t         j                        }| j	                  |||      S )zM
    Create a constant array from bytes (mechanism is target-dependent).
    r  )rk  r   r  uint8r  )r   r?   r@  r  bufs        rE   constant_bytesr    s2    
 ((9U#288
4C&&wC88rG   c                 x    |j                   \  }}||k7  rt        j                  S d }| j                  ||||      S )Nc                     | j                   |j                   k(  xrH | j                  |j                  k(  xr- | j                  j                  |j                  j                  k(  S r=  )rg   r   r5  r   r  r  s     rE   array_is_implzarray_is.<locals>.array_is_impl,  sI    177" /		QYY&/.	0rG   )r   r
   r  r  )r   r?   r]   r   atybtyr  s          rE   array_isr  &  s@    xxHC
cz   0
 ##G]CFFrG   __hash__c                     d S )Nc                      y r=  rr  rk  s    rE   r  zol_array_hash.<locals>.<lambda>9  r  rG   rr  rk  s    rE   ol_array_hashr  7  s    rG   c                     t        | d      S )zq
    Return the Structure representation of the given *flatiterty* (an
    instance of types.NumpyFlatType).
    flat_make_flattening_iter_cls)
flatitertys    rE   make_array_flat_clsr  ?  s    
 %Z88rG   c                     t        | d      S )zv
    Return the Structure representation of the given *nditerty* (an
    instance of types.NumpyNdEnumerateType).
    ndenumerater  nditertys    rE   make_array_ndenumerate_clsr  G  s    
 %X}==rG   c                    | j                  t        j                  d      }|j                  d      }	| |j	                  t
        j                  |       t        t        |            D ]  }
t        j                  |||
      }t        j                  ||j                  |            }||
   }|j                  d||      }t        j                  ||      5  |j	                  ||       | ||
       |j                  |	       d d d        |j	                  ||       | ||
        | |j	                  t
        j                  |       |j                  |	       |j!                  |	       y # 1 sw Y   mxY w)Nr   end_incrementr
  )r   r   r   rz  r  r
   
false_byter  r:   rj   r  r@   r  	if_likelyr  	true_byter  )r   r?   rr   rg   r   end_flagloop_continue
loop_breakr   bbendrv  idxptrr   r   	in_boundss                  rE   _increment_indicesr  O  sF   

A.D&&7Eg(((3d$ %%gw<%%gw||F/CDc
''S%8	w	2 	"MM#v&(c"NN5!	" 	dF#!sO" g''2NN5E"	" 	"s   .E//E8	c                     t        j                  ||j                  |j                        }t	        | ||j                  |||       y r=  )r
   r   rg   rr   r  )r   r?   r  r  r   r  rg   s          rE   _increment_indices_arrayr  p  s4      #))UZZ@EwUGXNrG   c                 v   	
  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).
    rI   c                   R    e Zd ZdZd Zd Zej                  d        Zd Z	d Z
d Zy)	$make_nditer_cls.<locals>.BaseSubIterzF
        Base class for sub-iterators of a nditer() instance.
        c                 P    || _         || _        || _        || _        ||z
  | _        y r=  )nditermember_name	start_dimend_dimrr   )r[   r  r  r  r  s        rE   rx  z-make_nditer_cls.<locals>.BaseSubIter.__init__  s+     DK*D&DN"DL)+DIrG   c                 F    t        | j                  | j                  |       y r=  )r   r  r  )r[   rm   s     rE   set_member_ptrz3make_nditer_cls.<locals>.BaseSubIter.set_member_ptr  s    DKK!1!137rG   c                 B    t        | j                  | j                        S r=  )r  r  r  rc  s    rE   
member_ptrz/make_nditer_cls.<locals>.BaseSubIter.member_ptr  s    4;;(8(899rG   c                      y r=  rr  )r[   r   r?   s      rE   init_specificz2make_nditer_cls.<locals>.BaseSubIter.init_specific  r  rG   c                      y r=  rr  r[   r   r?   logical_dims       rE   r  z2make_nditer_cls.<locals>.BaseSubIter.loop_continue  r  rG   c                      y r=  rr  r  s       rE   r  z/make_nditer_cls.<locals>.BaseSubIter.loop_break  r  rG   N)rs   rt   ru   rq  rx  r  r6  cached_propertyr  r  r  r  rr  rG   rE   BaseSubIterr    s:    		,	8 
	"	"	: 
#	:			rG   r  c                   (    e Zd ZdZd Zd Zd Zd Zy)$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                     |j                  t        j                  d      }| j                  t	        j
                  ||             y r   )r   r   r   r  r
   r   )r[   r   r?   r   s       rE   r  z2make_nditer_cls.<locals>.FlatSubIter.init_specific  s3    ''

A6D 9 9'4 HIrG   c                 r    |j                  | j                        }|j                  |j                  |g      S r=  )r@   r  r  r   )r[   r   r?   r   r  r  r   s          rE   compute_pointerz4make_nditer_cls.<locals>.FlatSubIter.compute_pointer  s+    LL1E;;sxx%11rG   c                     || j                   dz
  k(  rN|j                  | j                        }t        j                  ||      }|j                  || j                         y y r  )rr   r@   r  r
   r  r  )r[   r   r?   r  r   s        rE   r  z2make_nditer_cls.<locals>.FlatSubIter.loop_continue  sM    dii!m+T__5//?eT__5	 ,rG   c                 H   |dk(  r=|j                  t        j                  d      }|j                  || j                         y || j
                  dz
  k(  rN|j                  | j                        }t        j                  ||      }|j                  || j                         y y r  )	r   r   r   r  r  rr   r@   r
   r  )r[   r   r?   r  r   r   s         rE   r  z/make_nditer_cls.<locals>.FlatSubIter.loop_break  s}    a++EJJ:dDOO4		A-T__5//?eT__5	 .rG   N)rs   rt   ru   rq  r  r  r  r  rr  rG   rE   FlatSubIterr    s    	
	J	2	6		6rG   r  c                   "    e Zd ZdZ fdZd Zy)+make_nditer_cls.<locals>.TrivialFlatSubIterzx
        Sub-iterator walking a contiguous array in physical order,
        *without* support for broadcasting.
        c                 "    j                   rJ y r=  )need_shaped_indexing)r[   r   r?   r  s      rE   r  z9make_nditer_cls.<locals>.TrivialFlatSubIter.init_specific  s    44444rG   c                 v    t        |      dk  sJ t        |             |j                  |j                  |      S r  )r   r  r   r[   r   r?   r   r  r  s         rE   r  z;make_nditer_cls.<locals>.TrivialFlatSubIter.compute_pointer  s2    w<1$2c'l2$;;sxx11rG   N)rs   rt   ru   rq  r  r  r  s   rE   TrivialFlatSubIterr    s    	
	5	2rG   r  c                       e Zd ZdZd Zy)'make_nditer_cls.<locals>.IndexedSubIterzA
        Sub-iterator walking an array in logical order.
        c                 l    t        |      | j                  k(  sJ t        j                  |||||d      S NFr  )r   rr   r
   r%  r  s         rE   r  z7make_nditer_cls.<locals>.IndexedSubIter.compute_pointer  s:    w<499,,,++GWeS,3G GrG   Nrs   rt   ru   rq  r  rr  rG   rE   IndexedSubIterr    s    		GrG   r  c                       e Zd ZdZd Zy)'make_nditer_cls.<locals>.ZeroDimSubIterz5
        Sub-iterator "walking" a 0-d array.
        c                     |j                   S r=  )r   r  s         rE   r  z7make_nditer_cls.<locals>.ZeroDimSubIter.compute_pointer  s    88OrG   Nr  rr  rG   rE   ZeroDimSubIterr    s    		rG   r  c                       e Zd ZdZd Zy)&make_nditer_cls.<locals>.ScalarSubIterz8
        Sub-iterator "walking" a scalar value.
        c                     |S r=  rr  r  s         rE   r  z6make_nditer_cls.<locals>.ScalarSubIter.compute_pointer  s    JrG   Nr  rr  rG   rE   ScalarSubIterr    s    		rG   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y
)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 ]0  \  }}|\  }}}}d|z  }	||   }
|j                   |
| |	||             2 |S )N)r  indexed0dscalarzindex%d)r  r  r  rk   )r[   l	factoriesro   r  rr  r  r  r  r  factoryr  r  r  r  r  r  s              rE   subitersz(make_nditer_cls.<locals>.NdIter.subiters  s    A080M0M0$2-#0	I $H$5$56 I3.1+i!'!m#D/{IwGH	I
 HrG   c                    |j                  t        j                  d      }|j                  |t        j                  |      |      | _        t        |      D ]K  \  }}t        |t        j                        r!d|z  }t        j                  |||         }	t        | ||	       M | j                  ||||      }t        j                  t        j                        }
d}d}t        |      D ]O  \  }}t        |t        j                        s!|j                  k(  s1||   j                  }||   j                   } n; dk(  sJ |j                  ||
d      }|j                  t        j                  d      }d }t#        ||      D ]  \  }}t        |t        j                        s!|j                  dkD  s1t%        t        j&                  t        j                  t        j                  |j                        |
      }|j)                  ||||j                  |f        t        j*                  ||      }dk(  r|ddd   }|j-                  d	||      }|j/                  |t        j0                  t        j2                        }j4                  s|f}t7        |      k(  sJ t        j8                  ||j:                  
      }t=              D ]+  }t        j>                  |||      }|jA                  ||       - || _!        t        jD                  |||j:                        | _        t        j                  ||      | _#        | jH                  D ]  }|jK                  ||        y)zY
            Initialize the nditer() instance for the specific array inputs.
            r   scalar%dNrr  rI   c                     t        |       }t        |      D ]'  }| |   |t        |      |z
  |z      k7  st        d       y )Nz2nditer(): operands could not be broadcast together)r   r:   r   )rg   
main_shaper  ro   s       rE   check_shapezBmake_nditer_cls.<locals>.NdIter.init_specific.<locals>.check_shape  sO    Jq ?AQx:c*o.AA.E#FF( *> ? ??rG   r  r  r  r  )&r   r   r   r  ru  arraysr  r   r   r
   r   r   _arrays_or_scalarsrt  rr   rg   r   r   r%   noner  r   r  r  r  r  r  r   rY   r;   r:   rj   r  r   rl   	exhaustedr  r  )r[   r   r?   arrtysr  r   ro   r@  r  slotmain_shape_tyr  main_nitemsr  r  r  r]   r   shape_is_emptyr  r   rv  r  subiterr  rr   r  nshapess                           rE   r  z-make_nditer_cls.<locals>.NdIter.init_specific  s	    ''

A6D ",,Wekk&6I-35DK #6* 52!"ekk2",q.K"44WfQiHDD+t45 ,,WgvvNF "NN5::t<MJK%f- 	B5eU[[1ejjD6H!'J"()"2"2K		B qy y$//K
%225::qA? "&&1 K
seU[[1ejj1n#EJJ$)NN5::uzz$J$13C ,,Wk-0399j2IKK ))':>F}" %00{DIN~w7H7H'.'9'9;I 00 &v;')))))'4997KGW~ , --gwDdF+, #DL ++GVTYYGDJ$66w	JDN  == 8%%gw78rG   c                 2   |j                  d      }t        j                  ||j                  | j                              }t        j
                  ||      5  |j                  d       |j                  |       ddd       j                  }t        j                  || j                        }| j                  ||||      }| j                  }|j                  d       | j                  |||||      }	|	D 
cg c]  }
|
j                          }	}
t        |	      dk(  r|j                  |	d          n,|j                  |j!                  |j"                  |	             t        j                  || j$                        }t'        ||t        |      ||| j                  t)        j*                  | j,                  ||      t)        j*                  | j.                  ||             |j                  |       |j1                  |       y# 1 sw Y   xY wc c}
w )zJ
            Compute next iteration of the nditer() instance.
            r  FNTrI   r   )rz  r
   as_bool_bitr@   r  if_unlikelyr  r  r  r   r  r   _make_viewsr   r   r  r  r  rg   r  r6  partial_loop_continue_loop_breakr  )r[   r   r?   r  r  r  r  r  r   viewsr   rg   r  s               rE   iternext_specificz1make_nditer_cls.<locals>.NdIter.iternext_specificJ  s    ..u5E  ++G,3LL,HJI$$Wi8 &  'u%& __F))'4;;?F,,WgvvNFllG T"$$WgwOE,12qQ[[]2E25zQeAh'g00(:M:M168 9 (($**=EwUU&(001D1D1818 :  )001A1A1818 :! NN5!##E*?& & 3s   #H9HHc                     | j                   D ]E  }|j                  |cxk  r|j                  k  s#n &|j                  ||||j                  z
         G y r=  )r  r  r  r  r[   r   r?   rv  r  s        rE   r%  z.make_nditer_cls.<locals>.NdIter._loop_continuet  sG    }} M==C5#++5%%gwcmm8KLMrG   c                     | j                   D ]E  }|j                  |cxk  r|j                  k  s#n &|j                  ||||j                  z
         G y r=  )r  r  r  r  r*  s        rE   r&  z+make_nditer_cls.<locals>.NdIter._loop_breaky  sE    }} J==C5#++5NN7GS3==5HIJrG   c                 <   dgz  }j                   }| j                  }j                  }	t        |	t        j
                        rt        |	      }	n|	g}	t              D 
cg c](  }
|j                  t        j                  |||
            * }}
t        ||      D ]c  \  }}|\  }}}}||j                  |j                   }dk(  r|ddd   }|D ],  }
||
   J | j                  ||||	|
   ||
   ||
   |      ||
<   . e t        d |D              sJ |S c c}
w )z:
            Compute the views to be yielded.
            Nr  r  c              3       K   | ]  }|  y wr=  rr  r?  r   s     rE   rA  z>make_nditer_cls.<locals>.NdIter._make_views.<locals>.<genexpr>  s     (Qq(s   )r  r  r  r   r   rI  r   r:   r@   r
   rj   r   r  r  
_make_viewrv  )r[   r   r?   r   r  r  r'  r  r  rettysro   r  r  r  array_indicessub_indicesr  narraysr  r  s                   rE   r#  z+make_nditer_cls.<locals>.NdIter._make_views~  sN    FW$E((H}}H((F&%//2f  %g0 ||G$8$8'1$MN 0G 0 !$Hh 7 	NW),&1a%g&7&7HS="-dd"3K& NA 8+++#w/5ay/5ay&)W NE!HN	N (%((((L0s   "-Dc                    t        |t        j                        r|j                  dk(  sJ |j	                  |||||      } |j                  |      ||      }	t        ||      }
|j                  |t        j                  t        j                  d      d      }|j                  |t        j                  t        j                  d      d      }t        |	||||
d       |	S )zD
            Compute a 0d view for a given input array.
            r   rr  N)r   )r   r   r   rr   r  rz   r   r  rt  r   r   )r[   r   r?   r   rH  r  r  r  rm   viewr   rg   r   s                rE   r/  z*make_nditer_cls.<locals>.NdIter._make_view  s    
 eU[[1ejjAoEE))'7GUCPC,7%%e,Wg>D#GU3H&&wuzz10M')+E((%..Q2O)+-G 4eWhMKrG   c                    g }t        t        ||            D ]j  \  }\  }}t        |t        j                        r*|j                   |j                  |      |||             M|j                  t        | d|z               l |S )Nr  r  )r  r   r   r   r   rk   rz   r  )	r[   r   r?   r  r  r  ro   r  r  s	            rE   r  z2make_nditer_cls.<locals>.NdIter._arrays_or_scalars  s     A#,S-@#A <<E3eU[[1HH6W//6w7>=@B C HHWT:>:;< HrG   N)rs   rt   ru   rq  r6  r  r  r  r(  r%  r&  r#  r/  r  )
r  r  r  r  r  r  r3  rr   r  r  s
   rE   NdIterr    sO    	 
	"	"	 	 
#	M	8^(	+T	M
	J
	8	(	rG   r7  )rr   r  r   r  r  objectr
   ry   )r  r  r7  r  r  r  r  r  r  r3  rr   r  s   `  @@@@@@@@@rE   make_nditer_clsr9  v  s    
 ==D__F(//"G33dGf 86k 6@2[ 2G G  V V,,X6 Vp MrG   c                 `    | 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y)%make_ndindex_cls.<locals>.NdIndexIterz,
        .ndindex() implementation.
        c                    |j                  t        j                  d      }t        j                  ||j
                  |j                  t        j                              }t        j                  |t        j                        }t              D ]  }t        j                  |||      }|j                  ||       ||   }	|j                  d|	|      }
t        j                  ||
      5  |j                  t        j                  |       d d d         || _        || _        t        j                   |||j
                        | _        y # 1 sw Y   xY wNr   r  r  )r   r   r   r
   rY   r;   r   r  r:   rj   r  r  r"  r  r   r  rl   rg   )r[   r   r?   r   r   r   r  rv  r  r  dim_is_emptyrr   s              rE   r  z3make_ndindex_cls.<locals>.NdIndexIter.init_specific  s'   ''

A6D))'499/6/C/CEJJDH0JKG  11'7;M;MNIT{ 	@ --gwDdF+ "#;&44T8TJ((,? @MM'"3"3Y?@ @	@ #DL&DN ++GVTYYGDJ@ @s   +!EE	c           
      n   |j                  t        j                  d      }|j                  d      }t	        j
                  ||j                  | j                              }t	        j                  ||      5  |j                  d       |j                  |       d d d        t              D cg c]2  }|j                  t	        j                  || j                  |            4 }}|D ]  }	t        ||	        |j                  t	        j                   |||j"                               |j                  d       t	        j$                  || j&                        }
t)        |||
| j                  | j                         |j                  |       |j+                  |       y # 1 sw Y   xY wc c}w )Nr   r  FT)r   r   r   rz  r
   r!  r@   r  r"  r  r  r:   rj   r   rK   r  rl   r;   r   rg   r  r  )r[   r   r?   r  r   r  r  rv  r   r@   rg   rr   s              rE   r(  z7make_ndindex_cls.<locals>.NdIndexIter.iternext_specific  sq   ''

A6D..u5E++G,3LL,HJI$$Wi8 &  'u%& #(+/  ||G$8$89=9<%> ? /G /   -gt,- MM',,WgtyyIJT"(($**dCEwu#||T^^= NN5!##E*'& &/s   8#F%07F2%F/N)rs   rt   ru   rq  r  r(  rr   s   rE   NdIndexIterr<    s    		H,	+rG   rB  )rr   r
   ry   )r  rB  rr   s     @rE   make_ndindex_clsrC    s.    
 ==D5+g11(; 5+n rG   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                   2    e Zd ZdZ fdZ fdZd Zd Zy)6_make_flattening_iter_cls.<locals>.CContiguousFlatIterzZ
            .flat() / .ndenumerate() implementation for C-contiguous arrays.
            c                    |j                  t        j                  d      }t        j                  ||      | _        |j                  | _        	dk(  rt        j                  ||j                  |j                  t        j                  |j                              }t        |j                        D ]+  }t        j                  |||      }|j                  ||       - || _        y y )Nr   r  r  )r   r   r   r
   r   r   r   r  rY   r;   rr   r:   rj   r  r   )
r[   r   r?   r  r  r   r   rv  r  rr  s
            rE   r  zD_make_flattening_iter_cls.<locals>.CContiguousFlatIter.init_specific
  s    ++EJJ:$66wE
 "ll=(%11$11%**ejjIKG  %UZZ0 4!(!5!5gw!LdF34 $+DL )rG   c                 b   |j                   }|j                  }|j                  | j                        }|j	                  d||      }	|j                  |	       t        j                  ||	      5  |j                  |j                  |g      }
t        ||||
      }dk(  r|j                  |       n| j                  }t        |      D cg c](  }|j                  t        j                  |||            * }}t        j                  |||j!                  t"        j$                              }|j                  t        j&                  |||g             t)        |||||       t        j*                  ||      }|j-                  || j                         d d d        y c c}w # 1 sw Y   y xY w)Nr
  r  r@  )rr   r   r@   r   r  r  r
   r  r  r   r   r  r   r:   rj   rl   r|   r   r   make_anonymous_structr  r  r  )r[   r   r?   r  r  r  rr   r   r   r  rm   r	  r   rv  idxvalsidxtuplerr  s                   rE   r(  zH_make_flattening_iter_cls.<locals>.CContiguousFlatIter.iternext_specific#  s   zzTZZ0"..sE6B  *&&w9 5!++chh8C%gwsCEv~e, #',, /4Dk#; (+ $+<<0D0DWELEH1J $K #; #; $+#5#5gw9@9N9N:?**:F$G #99';CU:KMN 1'514g? $33GUCEMM%4-5 5#;5 5s    /AF%-F 8BF% F%%F.c                 X    |j                  |j                  |g      }t        ||||      S r=  )r  r   r   r[   r   r?   r  r  r   rm   s          rE   r  z>_make_flattening_iter_cls.<locals>.CContiguousFlatIter.getitemC  s)    kk#((UG4 '5#>>rG   c                 \    |j                  |j                  |g      }t        |||||       y r=  )r  r   r   r[   r   r?   r  r  r   r	  rm   s           rE   setitemz>_make_flattening_iter_cls.<locals>.CContiguousFlatIter.setitemG  s(    kk#((UG47GUE3?rG   N)rs   rt   ru   rq  r  r(  r  rQ  rr  s   rE   CContiguousFlatIterrF    s    +25@?@rG   rS  c                   4    e Zd ZdZd Z fdZd Zd Zd Zy)+_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                    |j                  t        j                  d      }|j                  }|j                  }t        j                  ||j                  |      }t        j                  ||j                  |j                  t        j                  |j                              }	t        j                  ||j                  |j                  t        j                  |j                              }
t        j                  |t
        j                        }t        |      D ]  }t        j                  ||	|      }t        j                  ||
|      }|j                  ||       |j                  ||       ||   }|j                  d||      }t        j                   ||      5  |j                  t
        j"                  |       d d d         |	| _        |
| _        || _        y # 1 sw Y   xY wr>  )r   r   r   r   rr   r
   r   rg   rY   r;   r   r  r:   rj   r  r  r"  r  r   pointersr  )r[   r   r?   r  r  r   r   rr   r   r   rW  r  rv  r  ptrptrr  r?  s                    rE   r  z9_make_flattening_iter_cls.<locals>.FlatIter.init_specificV  s   ++EJJ:xxzz --gsyy$G!--TYYW-A-A%**BG**.NO #..TYYW-A-A%**BG**.NO $55g6=6H6HJ	 !; DC$11'7CHF$11'8SIFMM$/MM$/  &c{H#*#8#8x#NL ,,WlC Dg&7&7CD DD  ' (!*D Ds    !G!!G*	c           
      H   |j                   }t        j                  ||j                  |      }t        j                  ||j                  |      }| j
                  }	| j                  }
|j                  t        j                  d      }|j                  d      }t        j                  ||j                  | j                              }t        j                  ||      5  |j                  d       |j!                  |       d d d        |j                  d       t        j"                  ||
|dz
        }|j                  |      }t%        ||||      }dk(  r|j'                  |       nyt)        |      D cg c](  }|j                  t        j"                  ||	|            * }}t        j*                  ||      }|j'                  t        j,                  |||g             t/        t)        |            D ]>  }t        j"                  ||	|      }t        j0                  ||j                  |            }||   }||   }|j3                  d||      }t        j4                  ||      5  |j7                  ||       t        j"                  ||
|      }|j                  |      }t        j8                  |||      }|j7                  ||       t)        |dz   |      D ]+  }t        j"                  ||
|      }|j7                  ||       - |j!                  |       d d d        |j7                  ||       A |j7                  t        j:                  | j                         |j!                  |       |j=                  |       y # 1 sw Y   xY wc c}w # 1 sw Y   }xY w)Nr   r  FTrI   r  r
  )rr   r
   r   rg   r   r   rW  r   r   r   rz  r!  r@   r  r"  r  r  rj   r   r  r:   rl   rJ  r  r  r  r  r  r   r  r  )r[   r   r?   r  r  r  rr   r   r   r   rW  r   r  is_exhaustedlast_ptrrm   r	  rv  rK  rL  r  r   r   r  r  rX  	inner_dimrr  s                              rE   r(  z=_make_flattening_iter_cls.<locals>.FlatIter.iternext_specificw  s7   zz --gsyy$G!..wTJ,,==++EJJ:2259  '22W\\$..9 ;((,? *$$U+NN5)*   & #//4!8Lll8,!'7E3?6>MM%( +0+7 $'  '||G,@,@AHAD-F  G 7G 7  '11'7CHMM55g7?6GIJ $E$K0 0C$11'7CHF!11'29,,v2FHC #3KE$S\F ' 3 3Ce DI **7I> .c62!(!5!5gx!M%ll62%11'3Gc62).sQw)= 7I%,%9%9':B:C&EF $MM#v6	7
  u-. MM$//04 g//@u%''.k* *7&. .s   #N7-N*B2NNN!	c           	         |j                   }t        j                  ||j                  |      }t        j                  ||j                  |      }g }	t        t        |            D ];  }
|	j                  |j                  |||
                |j                  |||
         }= |	j                          t        j                  |||j                  |||j                  |	      }|S )Nr   )rr   r
   r   rg   r   r  r:   rk   uremudivreverser  r   r  )r[   r   r?   r  r  r   rr   r   r   r   rv  rm   s               rE   _ptr_for_indexz:_make_flattening_iter_cls.<locals>.FlatIter._ptr_for_index  s    zz --gsyyM!..w4P #E$K0 =CNN7<<vc{#CD#LLs<E= !//#((06079 
rG   c                 H    | j                  |||||      }t        ||||      S r=  )ra  r   rN  s          rE   r  z3_make_flattening_iter_cls.<locals>.FlatIter.getitem  s+    ))'7E3N '5#>>rG   c                 L    | j                  |||||      }t        |||||       y r=  )ra  r   rP  s           rE   rQ  z3_make_flattening_iter_cls.<locals>.FlatIter.setitem  s*    ))'7E3N7GUE3?rG   N)	rs   rt   ru   rq  r  r(  ra  r  rQ  rR  s   rE   FlatIterrU  N  s%    +BC/J"?@rG   rd  )rd   r  r
   ry   )r  rr  rd   rS  rd  s    `   rE   r  r    sr    ****&&JCD	@'"="=j"I D	@L #"E	@w22:> E	@N rG   r  c                 >   t        t        j                  |            } || |      }||_        | j	                  |      } || ||j                  d            }|j                  | |||       |j                         }t        | |t        j                  |      |      S Nr   )r\   )	r  r   NumpyFlatTyper   rz   ri   r  r   r!   )r   r?   r  r  flatiterclsflatiterarrclsr   s           rE   make_array_flatiterrk    s    %e&9&9%&@AK7G,HHN&F
'x'@'@'I
JC7GUC8



CWgu/B/B5/I3OOrG   c                     |j                   \  }|\  }t        |      } || ||      }|j                  }| j                  |      }	 |	| ||j                        }
|j                  | |||
|       y r<  )r   r  rd   rz   r   r(  )r   r?   r]   r   r  r  ri  rh  r  rj  r  s              rE   iternext_numpy_flatiterrm    sq     88LZJX%j1K7G8<H!!E&F
'
8CwVDrG   c                    |j                   d   }|\  }}t        |      } || ||      }|j                  }| j                  |      }	 |	| ||j                        }
|j                  | |||
|      }t        | ||j                  |      S Nr   r  )r   r  rd   rz   r   r  r!   r   )r   r?   r]   r   r  ri  r   rh  r  rj  r  r   s               rE   iternext_numpy_getitemrp    s    !JOHe%j1K7G8<H!!E&F
'
8C


7GUC
?CWgsDDrG   c                    |j                   d   }|\  }}}t        |      } || ||      }|j                  }	| j                  |	      }
 |
| ||j                        }|j                  | ||	|||       | j                         S ro  )r   r  rd   rz   r   rQ  r^  )r   r?   r]   r   r  ri  r   r	  rh  r  rj  r  s               rE   iternext_numpy_getitem_anyrr    s     !J!HeU%j1K7G8<H!!E&F
'
8CWguc5%@""$$rG   c                     |j                   d   }t        |      } || ||d         }| j                  |j                        } || ||j                        }|j
                  S ro  )r   r  rz   rd   r   r   )	r   r?   r]   r   r  rh  ri  rj  r  s	            rE   iternext_numpy_getitem_flatrt    s]    !J%j1K7G47;H
 5 56F
'
8C::rG   c                 P   |j                   \  }|\  }t        t        j                  |            } || |      }||_        | j                  |      } || ||j                  d            }|j                  | |||       |j                         }	t        | ||j                  |	      S rf  )r   r  r   NumpyNdEnumerateTyper   rz   ri   r  r   r!   r   )
r   r?   r]   r   r  r  	nditerclsr  rj  r   s
             rE   make_array_ndenumeraterx  $  s    XXFEDC*5+E+Ee+LMIw(FFL&F
'v'>'>w'G
HC
'5#6



CWgsDDrG   c                     |j                   \  }|\  }t        |      } || ||      }|j                  }| j                  |      }	 |	| ||j                        }
|j                  | |||
|       y r<  )r   r  rd   rz   r   r(  )r   r?   r]   r   r  r  r  rw  r  rj  r  s              rE   iternext_numpy_nditerrz  6  sq     JXHV*84Iwv6FE&F
'
6C
Wguc6BrG   c           
      t   t        |j                  |      D cg c]'  \  }}| j                  |||t        j                        ) }}}t        t        j                  t        |                  } || |      }|j                  | ||       |j                         }	t        | ||j                  |	      S c c}}w )zndindex(*shape))r   r   r   r   r   rC  NumpyNdIndexTyper   r  r   r!   r   )
r   r?   r]   r   argtyr  rg   rw  r  r   s
             rE   make_array_ndindexr~  F  s    
  #388T24 \\'3uzz: 4E 4 !!7!7E
!CDIw(F
'51



CWgsDD4s   ,B4c           	         |j                   j                  }|dkD  re|j                  d   j                  }|d   }t	        j
                  |||      }|D cg c]$  }| j                  |||t        j                        & }}ng }t        t        j                  t        |                  }	 |	| |      }
|
j                  | ||       |
j                         }t        | ||j                   |      S c c}w )zndindex(shape)r   )r   rr   r   r}   r
   r   r   r   r   rC  r|  r   r  r   r!   )r   r?   r]   r   rr   r   rF  rg   r   rw  r  r   s               rE   make_array_ndindex_tupler  U  s     ??Dax!!1g$$Wc48!# gsE5::> # #  !7!7E
!CDIw(F
'51



CWgsDD#s   )C.c                 z    |j                   \  }|\  }t        |      } || ||      }|j                  | ||       y r<  )r   rC  r(  )r   r?   r]   r   r  r  r  rw  s           rE   iternext_numpy_ndindexr  l  s@     JXHV *Iwv6F
Wgv6rG   c                 H   |j                   }|j                  }t        |j                  d   t        j
                        rt        j                  ||d         }n|d   g} t        |      | |      }|j                  | |||       |j                         }t        | |||      S )z
    nditer(...)
    r   )r   r  r   r   r   rI  r
   r   r9  r  r   r!   )	r   r?   r]   r   r  r  r  r  r   s	            rE   make_array_nditerr  x  s    
 H__F#((1+u/%%gtAw7q'&_X&w8F
'66:



CWgx==rG   c                 v    |j                   \  }|\  } t        |      | ||      }|j                  | ||       y r<  )r   r9  r(  )r   r?   r]   r   r  r  r  s          rE   iternext_numpy_nditer2r    s=     JXHV&_X&wvFF
Wgv6rG   c                     |j                   \  }}t        j                  t        j                  d      t	        ||k(              }t        | ||j                  |      S r  )r   r   r   r`  r   r#   r   )r   r?   r]   r   arg1arg2r   s          rE   dtype_eq_implr    sE    JD$
++bjjmS%6
7CgwEErG   c                    t        |      } || |      }| j                  |j                        }| j                  t        j
                  t        | |            }| j                  t        j
                  d      }t        t        j                  d      d      }	|D ]H  }
|j                  ||
      }|j                  |d      }|j                  |	|j                  |d            }	J |j                  dk(  rd}n|j                  dk(  rO|g}t        |dd       D ]&  }|j!                  |j#                  |d   |             ( t%        t        |            }np|j                  dk(  r=|g}|dd D ]&  }|j!                  |j#                  |d   |             ( t%        |      }n$t'        dj)                  |j                              |j                  ||      }|j                  |d      }|j                  |	|j                  |d            }	|j+                  |	d	
      5  | j,                  j/                  |t0        d       ddd       |j                  }| j3                  |      }| j                  t        j4                  |      }| j7                         ||f}t	        j8                  t        j:                        }t	        j<                  t?        |            }tA        ||t        j
                  t        j4                        }| jC                  |tD        ||      }| jF                  jI                  ||      }| jK                  t        j
                        }tM        jN                  |||      }tM        jN                  |||      }tQ        ||jS                  ||jU                               ||||       |S # 1 sw Y   yxY w)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.
    rI   r   rr  r   Nr  r  z3Don't know how to allocate array with layout '{0}'.FrV  )z[array is too big; `arr.size * arr.dtype.itemsize` is larger than the maximum possible size.rI  r  )+rz   r|   r}   r   r   r   r   r   r   r`  smul_with_overflowrP  r  rr   r  r  rk   r   r   rT   r   r  rX  rY  r   get_preferred_array_alignmentuint32r^  MemInfoPointervoidptrTypeRefr;   r%   r  _call_allocatorr   meminfo_datar   r
   rl   r   r+  r  )r   r?   rN  r   r  r   datatyper   arrlenoverflowr   arrlen_multr   dimension_sizeallocsize_multr2  r}   	align_valr   r   miparytypeclassargtypesr   r   r   shape_arraystrides_arrays                               rE   r  r    sO     F
'
"C$$W]]3H##EJJWg0NOH !!%**a0F

1q)H 
00;&&{A6;;g++K;

 ||q	3	*&vabz2 	ENNN7;;wr{NCD	E)*	3	*$Sbk 	ENNN7;;wr{NCD	E.!AHH ! 	!
 //AN%%na8I{{8W%:%:>1%MNH	%	0 
 	))Z-	

 MME55e<I  y9E##%y%8D


u}}
-C==g/LlEJJEH&&w4PG;;##GW5D##EJJ/F$$Wf@K&&wFCM3h.A.A.CD$($"$ JA
 
s   "N88O	_allocatec                     d }|S )zTImplements a Numba-only default target (cpu) classmethod on the array
    type.
    c                     t        ||      S r=  )intrin_alloc)clsr2  r   s      rE   r   z _ol_array_allocate.<locals>.impl  s    Iu--rG   rr  )r  r2  r   r   s       rE   _ol_array_allocater    s    
.KrG   c                 &    | j                  ||      S )z9Trampoline to call the intrinsic used for allocation
    )r  )rN  r   r   s      rE   r  r    s     T5))rG   c                 p    d }t        j                  t         j                        }t        |||      }||fS )z3Intrinsic to call into the allocator for Array
    c                 J    |\  }}| j                   j                  |||      }|S r=  )r   meminfo_alloc_aligned)r   r?   r%   r   r2  r   r   s          rE   rW  zintrin_alloc.<locals>.codegen  s)    !E++33GYNrG   )r   r  r  r%   )rX  r2  r   rW  r  r]   s         rE   r  r    s5    
 

u}}
-C
CE
*C<rG   c           	         d }t        |t        j                        r&d}| j                  |||t        j                        g}n@t        |t        j
                        sJ |j                  }t        j                  |||      }g }|D ]&  }|j                   || ||j                  |             ( | j                  |t        j                  d      }	t        |      D ]X  }
|j                  d||
   |	      }t        j                  ||      5  | j                  j!                  |t"        d       ddd       Z |S # 1 sw Y   fxY w)z;
    Parse the shape argument to an array constructor.
    c                    | j                  t        j                        }|j                  }t	        j
                  |      }t        |d|dz
  z  dz
        }|j                  |k  r|j                  ||      }|S |j                  |k\  ru|j                  d||      }	|j                  |	d      5  | j                  j                  |t        d       ddd       |j                  |kD  r|j                  ||      }|S |}S # 1 sw Y   0xY w)z0Cast src to intp only if value can be maintainedrI   >FrV  )z#Cannot safely convert value to intpN)r   r   r   rJ   r   r`  r   sextr  r  rX  rY  r   trunc)
r   r?   src_tr1  r   
intp_widthintp_irmaxvalr   	is_largers
             rE   safecast_intpz#_parse_shape.<locals>.safecast_intp  s    ''

3\\
**Z('Q*q.%8A$=?;;#,,sG,C 
 [[J&++Cf=I59 !!11Z<
 {{Z'mmC1 
 
 s   ."C??DrI   r   r   r
  )znegative dimensions not allowedN)r   r   r   r   r   rI  r   r
   r   rk   r;   get_constant_genericr:   r  r"  rX  rY  r   )r   r?   r@  r   r  rr   passed_shapesr   r   r   rv  is_negs               rE   _parse_shaper    s+   * "emm$ gsB

CD"eoo...xx,,WcFF BmGWaffa@AB ''Q?DT{ $$S&+t<  &1 	--%I	 	 M	 	s   "D::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arrshaperN  s          rE   _parse_empty_argsr  =  s9     88A;LAwHooGL'<JJJrG   c                    |j                   d   }t        |t        j                        rQ 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   rr  )
r   r   r   r   rz   r
   r   rg   rr   r   )r   r?   r]   r   arytyper   r   s          rE   rY  rY  G  sr    
 hhqkG'5;;'!j!'7$q'B%%gsyyM&&""rG   c                 n    t        |t        j                        rd|  d}t        j                  |      y )NzIf np.z0 dtype is a string it must be a string constant.)r   r   UnicodeTyper	   r   )fnamer}   r   s      rE   _check_const_str_dtyper  U  s7    %**+ugMN  %% ,rG   c                 <    |j                   } ||||      }d }||fS )Nc                 `    t        | |||      \  }}t        | |||      }|j                         S r=  )r  r  r   r  r?   r]   r  rN  r   r   s          rE   rW  znumpy_empty_nd.<locals>.codegen`  s2    +E7CHUGWf=}}rG   instance_type)r  ty_shapety_dtypety_retty_refty_rettyr]   rW  s          rE   numpy_empty_ndr  [  s,    ))H
8X|
4C <rG   c                 v   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 r=  )r  )rg   r}   rH  s     rE   r   zol_np_empty.<locals>.implu  s    !%66rG   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   )rg   r}   nb_dtyperr   r   r   rH  s         @rE   ol_np_emptyr  g  s    7E*	E5>>	*u/?/?5/H<<!%(% D 0(cB# 	7>ugRwaP  %%rG   c                 <    |j                   } ||||      }d }||fS )Nc                 `    t        | |||      \  }}t        | |||      }|j                         S r=  )rY  r  r   r  s          rE   rW  z$numpy_empty_like_nd.<locals>.codegen  s2    0fMUGWf=}}rG   r  )r  ty_prototyper  r  r  r]   rW  s          rE   numpy_empty_like_ndr  }  s,    ))H
<<
8C <rG   c                    t        d|       t        |      st        |      }n)t        | t        j
                        r| j                  }n| }|dt        | t        j
                        r2| j                  dk7  r| j                  nd}| j                  ||d      n6t	        j
                  |dd      nd|  d| d	}t        j                  |      dfd
	}|S )Nr  rK  r   F)r}   r  rS  r   z3Cannot parse input types to function np.empty_like(r  r  c                     t        | |      S r=  )r  )r  r}   rH  s     rE   r   zol_np_empty_like.<locals>.impl  s    "3u55rG   r=  )r  r   r  r   r   r   r}   r  rM  r	   r   )r  r}   r  r  r   r   rH  s         @rE   ol_np_empty_liker    s    </u!%(	C	%99c5;;'#&::#4SZZ#FHH8FUHKEKK!S1E  #uBugQ0  %%6KrG   c                 :    t        j                  |      }d }||fS )Nc                      t        |j                  d         | ||d         }t        j                  ||j                  |j                  |j                  |j                        d       y r   )rz   r   r
   rZ  r   r   r   r   )r  r?   r]   r  r   s        rE   rW  z(_zero_fill_array_method.<locals>.codegen  sO    %j!%eWfQi@w'++cllCJJ*O	rG   )r   r  )r  r[   r]   rW  s       rE   _zero_fill_array_methodr    s!    
**T
C <rG   
_zero_fillc                     d }|S )z?Adds a `._zero_fill` method to zero fill an array using memset.c                     t        |        y r=  )r  rc  s    rE   r   z ol_array_zero_fill.<locals>.impl  s
    %rG   rr  )r[   r   s     rE   ol_array_zero_fillr    s    &KrG   c                 0    t        d|       t        fd}|S )Nr]  c                 T    t        j                  | |      }|j                          |S Nr  )rk  r  r  )rg   r}   r  s      rE   r   zol_np_zeros.<locals>.impl  s!    hhuE*
rG   )r  r  rg   r}   r   s      rE   ol_np_zerosr    s    7E*  KrG   c                 &    t        d|       dd}|S )N
zeros_likec                 T    t        j                  | |      }|j                          |S r  )rk  r  r  )r  r}   r  s      rE   r   zol_np_zeros_like.<locals>.impl  s!    mmAU+
rG   r=  r  r  s      rE   ol_np_zeros_liker    s    </ KrG   c                 &    t        d|       dd}|S )N	ones_likec                     t        j                  | |      }|j                  }t        t	        |            D ]  }d||<   	 |S Nr  rI   rk  r  r  r:   r   )r  r}   r  arr_flatr   s        rE   r   zol_np_ones_like.<locals>.impl  sA    mmAU+88X' 	CHSM	
rG   r=  r  r  s      rE   ol_np_ones_liker    s    ;. KrG   c                 ^    t        d|       t        |      st        |      n|dfd	}|S )Nfullc                     t        j                  |       }|j                  }t        t	        |            D ]  }|||<   	 |S r=  rk  r  r  r:   r   )rg   
fill_valuer}   r  r  r   r  s         rE   r  zimpl_np_full.<locals>.full  sB    hhuh'88X' 	'C&HSM	'
rG   r=  )r  r   r  )rg   r  r}   r  r  s       @rE   impl_np_fullr    s0    65)u!%( KrG   c                 &    t        d|       dd}|S )Nr  c                     t        j                  | |      }|j                  }t        t	        |            D ]  }|||<   	 |S r=  r  )r  r  r}   r  r  r   s         rE   r  z$impl_np_full_like.<locals>.full_like  sA    mmAu%88X' 	'C&HSM	'
rG   r=  r  )r  r  r}   r  s       rE   impl_np_full_liker    s    ;. rG   c                 &    t        d|       dd}|S )Nonesc                     t        j                  | |      }|j                  }t        t	        |            D ]  }d||<   	 |S r  r  )rg   r}   r  r  r   s        rE   r   zol_np_ones.<locals>.impl  sA    hhuE*88X' 	CHSM	
rG   r=  r  r  s      rE   
ol_np_onesr    s     65) KrG   c                 z    t        d|       t        |      st        |      nt        j                  dfd	}|S )Nidentityc                 f    t        j                  | | f      }t        |       D ]	  }d|||f<    |S r  )rk  r]  r:   )r  r}   r  ro   r  s       rE   r  z"impl_np_identity.<locals>.identity  s<    hh1vx(q 	AC1I	
rG   r=  )r  r   r  r   r  )r  r}   r  r  s      @rE   impl_np_identityr    s4    :u-u!%(<<
 OrG   c                      y r=  rr  NMs     rE   _eye_none_handlerr    r  rG   c                 J    t        |t        j                        rd }|S d }|S )Nc                     | S r=  rr  r  s     rE   r   z$_eye_none_handler_impl.<locals>.impl      HrG   c                     |S r=  rr  r  s     rE   r   z$_eye_none_handler_impl.<locals>.impl"  r  rG   )r   r   r  )r	  r
  r   s      rE   _eye_none_handler_implr    s&    !U^^$	
 K	KrG   c                 :   |t        |t        j                        rt        j                  t
              nVt        |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\  r+t        | ||z
        }t	        |      D ]  }d||||z   f<    |S t        | |z   |      }t	        |      D ]  }d|||z
  |f<    |S r  )r  rk  r]  r  r:   )	r	  r
  r   r}   _Mr  dro   r  s	           rE   r   znumpy_eye.<locals>.impl2  s    q!$hh2w#6ArAvA1X " !Aq1uH" 
 AE2A1X " !AE1H"
rG   )
r   r   r  rk  r}   r  	DTypeSpecr  r   r  )r	  r
  r   r}   r   r  s        @rE   	numpy_eyer  '  sn     }
5%..9XXe_	EEOOU\\:	;geWe45XXe_!5  KrG   c                     t        |       st        j                  d      t        | t        j
                        r)| j                  dvrt        j                  d      dd}|S y )N#The argument "v" must be array-like)rI   r\  zInput must be 1- or 2-d.c                 h   | j                   dk(  r| j                  }|d   t        |      z   }t        j                  ||f| j
                        }|dk\  r"t        ||z
        D ]  }| |   ||||z   f<    |S t        ||z         D ]  }| |   |||z
  |f<    |S | j                  \  }}|dk  r||z   }|dkD  r||z
  }t        t        ||      d      }t        j                  || j
                        }|dk\  rt        |      D ]  }| |||z   f   ||<    |S t        |      D ]  }| ||z
  |f   ||<    |S r  )
rr   rg   r  rk  r]  r}   r:   r  r  r  )r   r   r   r  rY  ro   rowscolss           rE   	diag_implzimpl_np_diag.<locals>.diag_implJ  sd   vv{GGaD3q6Mhh1vqww/6"1q5\ -()!Aq1uH-
 
 #1q5\ -()!AE1H-
WW
dq5!8Dq5!8DD$+hhq!''*6"1X -!"1a!e8A-
 
 #1X -!"1q5!8A-
rG   r  )r   r	   r   r   r   r   rr   NumbaTypeError)r   r   r  s      rE   impl_np_diagr  A  sZ    A  !FGG!U[[!66''(BCC	6 ? "rG   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 ]K  }t        j                  |t         j                        j	                  t        ||            }|||<   |dz  }M |S )Nr  r   rI   )rk  r  r  arangerT  r1   )
dimensionsr   ro   rv  r   r	  rg   s        rE   r   znumpy_indices.<locals>.implu  sx    hhtj(9 	C))Crxx088eQ,C CFFA	 
rG   )r   r   rt  r	   r   r}   r   r   )r"  r   r   r	  rg   s      @@rE   numpy_indicesr#  h  so    j%..1E  %%j&&6E  %%JA1HE
 KrG   c                     t        |       sd}t        j                  |      t        |t        t
        j                  f      sd}t        j                  |      dd}|S )Nr  z#The argument "k" must be an integerc                 d   t        j                  |       } | j                         } t        |       }t	        |      }||z   }t        j
                  ||f| j                        }t        j                  d|       }t        j                  d|      }t        |      D ]  }| |   |||z   ||z   f<    |S r   )	rk  rl  r\  r   r  r]  r}   maximumr:   )	r   r   r   abs_kr  r   ro   jts	            rE   r   znumpy_diagflat.<locals>.impl  s    JJqMGGIFAIhh1vqww'JJq1"JJq!q 	%A !!CAq1u	% 
rG   r  )r   r	   r   r   r   r   r   )r   r   r   r   s       rE   numpy_diagflatr*    sU    A3  %%a#u}}-.3  %% KrG   c                 n   |dv sJ |dk(  r4d}t        d|       D ]"  }d|z  }|d| ddj                  |       d	z  }$ n3d
}t        d|       D ]"  }d|z  }|d| ddj                  |       dz  }$ t        j                  |      }t	        |t                      t               d|    }t        |      S )N)r  rQ  r  zv
            def _getitem(a, idx, axis):
                if axis == 0:
                    return a[idx, ...]
        rI   ):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  )r:   r  textwrapdedentexecglobalsr'   )rr   rr  r;  ro   lsts        rE   "generate_getitem_setitem_with_axisr2    s   ))))y
 q$ 	A1*C S !"iin- . B	 q$ 	A1*C S !yy~& ' B	 
	BWY	Qtf:	BBrG   takec                   	 t        j                  |      rt        | t        j                        r t        |t        j
                        rdd}|S t        | t        j                        r1t        |t        j                        r|j                  dk(  dfd	}|S t        | t        j                        r1t        |t        j                  t        j                  f      rdd}|S y y t        | t        j                        rBt        |t        j
                        r(d| j                  dz
  z  	t        	fd       dfd	}|S t        | t        j                        rgt        |t        j                  t        j                  t        j                  f      r-| j                  }t        |d	      t        |d
      dfd	}|S y y )Nc                     || j                   dz
  kD  s|| j                    k  rt        d      | j                         |   S )NrI   Index out of bounds)r   
IndexErrorr\  )r  r   r   s      rE   	take_implznumpy_take.<locals>.take_impl  s<    affqj)Ww->$%:;;wwy))rG   r  c                    t        j                  |j                  | j                        }	r|j	                         }n|}t        j
                  |      }d}| j                         }|D ]<  }|| j                  dz
  kD  s|| j                   k  rt        d      ||   ||<   |dz   }> |j                  |j                        S )Nr  r   rI   r6  )
rk  r  r   r}   rM  r  r\  r7  rT  rg   )
r  r   r   rY  walkeritro   r  rE  F_orders
            rE   r8  znumpy_take.<locals>.take_impl  s    hhw||177;$\\^F$FYYv&wwy AAFFQJ'1w;()>??!!WCFAA	
 {{7==11rG   c                 X    t        j                  |      }t        j                  | |      S r=  )rk  r   r3  )r  r   r   converts       rE   r8  znumpy_take.<locals>.take_impl  s!    ((7+wwq'**rG   r  rI   c                 J   t              }d}|t        | j                        k  r| j                  |   dk(  sJ | j                         t        t        | j                              D ])  }| j                  |   }||k7  st	        |||      }|dz  }+ | j                  |      S r  )r   r   rg   r:   r1   rT  )r}  r   rF  r(  r   r   r)  s         rE   _squeezeznumpy_take.<locals>._squeeze  s    Ahc!''l*qwwt}/AJ177JA QWW. CAd{+CA6Q	
 yy~%rG   c                     t        j                  | |f|      }| j                  dk(  r|d   S |dk  r|| j                  z  } ||      S )Nrl  rI   r   )rk  r3  rr   )r  r   r   r}  r@  s       rE   r8  znumpy_take.<locals>.take_impl  sN    GGAz566Q; Q4K!8AFFND4((rG   r  rQ  c                 z   |}|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  )	rr   r   r1   rg   r   rk  r  r}   r:   )r  r   r   r+  r   rg   r   ro   rF  _getitem_setitems            rE   r8  znumpy_take.<locals>.take_impl  s    !8AFFND!8tqvv~"2$ '++,66(4C$S/)%aggtS\BhhuAGG4s7|, .A GAJ5AS!T1-. 
rG   r=  )r
   r   r   r   r   r   r  r  rI  rr   r'   r2  )
r  r   r   r8  rr   r<  rC  rD  r@  r)  s
        @@@@@rE   
numpy_takerE    sb    4 a%*Wemm*L* a%*Wekk*Jnn+G2 a%7UZZ$AB+ 	 C & a%*Wemm*L
#A
 	& 	&) a%7U[[%**eoo$NO66D9$	JH9$	JH  / P &rG   c                     | D cg c]  }t        |t        j                        r|! }}t        d |D              rt        j                  }|S t        d |D              rt        j
                  }|S t        t        ddt        j                  t              j                  z  z        }|D cg c]  }t        j                  |       }}t        ||gz         }|S c c}w c c}w )Nc              3   P   K   | ]  }t        |t        j                           y wr=  r  r?  r  s     rE   rA  z _arange_dtype.<locals>.<genexpr>(  s     
8A:a'
8rB  c              3   P   K   | ]  }t        |t        j                           y wr=  )r   r   FloatrH  s     rE   rA  z _arange_dtype.<locals>.<genexpr>*  s     8AZ5;;'8rB  zint%sr  )r   r   r  rC  
complex128r   r  rk  r}   r   r   	unliteralr  )r   r  boundsr}   NPY_TYrE  unliteral_boundss          rE   _arange_dtyperP  %  s    CAZ5>>%BaCFC

8
88  & L% 
88	8" L 1rxx}/E/E+E FG 9??1EOOA.??$y01L- D& @s   CC.C"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
                        r~t        |t        j                  t        j
                  f      rTt        |t        j                  t        j
                  f      r*t        |t        j                  t        j                  f      sy t        |t        j                        rt        | ||      	n|j                  	t        | ||fD cg c]  }t        |t        j                         c}      
t        | dd       t        |dd       t        |dd       d	
fd	}|S c c}w )Nr   c                   n| }n|}n|}||nd}|d|}	}n||}	}|dk(  rt        d      |	|z
  |z  }
t        t        j                  |
j                              }du r?t        t        j                  |
j
                              }t        t        ||      d      }nt        |d      }t        j                  |      }|}t        |      D ]  }|||z  z   ||<    |S )NrI   r   zMaximum allowed size exceededT)r   r   mathceilr  r  r  r  rk  r  r:   )r!  r  r  r}   	lit_startlit_stoplit_step_step_start_stopnitems_cnitems_rnitems_ir   r  r   ro   start_value
step_value
stop_value
true_dtypeuse_complexs                    rE   r   znp_arange.<locals>.implb  s   #.#:K	!+!7:T!+!7:T$0ayEF%xEFA:<==FNe+tyy/0 $499X]]34HXx0!4F1%Fhhvz*v 	'AAI&CF	'
rG   r  )r   r   Optionalr;   r  r  r  r  rP  r}   rC  r  r  )r!  r  r  r}   rE  r   r^  r_  r`  ra  rb  s         @@@@@rE   	np_arangerd  ?  sb   $'yy$'yy%(

|zz|zz}

uell+tennell;<tennell;<55>>5??"CD%("5$5
[[
!&d 35 "!U]]3 5 6K %$7K5J5J < KK5s   !G"c                 X   t        d | |fD              sy t        |t        t        j                  f      sd}t        j                  |      t        d | |fD              r2t        j                  rt        j                  n!t        j                  nt        j                  dfd	}|S )Nc              3   P   K   | ]  }t        |t        j                           y wr=  )r   r   r  r  s     rE   rA  z!numpy_linspace.<locals>.<genexpr>  s     Fz#u||,FrB  r  c              3   P   K   | ]  }t        |t        j                           y wr=  r  r  s     rE   rA  z!numpy_linspace.<locals>.<genexpr>  r  rB  c                     t        j                  |      }| dz  } |dz  }|dk(  r|S |dz
  }|dkD  r8|| z
  }t        j                  ||      }t        d|      D ]  }| ||z  z   ||<    n| |d<   |dkD  r||d<   |S )Ng      ?r   rI   r  )rk  r  divider:   )	r!  r  r  r  divdeltar  ro   r}   s	           rE   r	  z numpy_linspace.<locals>.linspace  s    hhsE" cz!8JAg75LE99UC(D1c] ,!d(+A, CF7CG
rG   r  )rv  r   r   r   r   r	   r   rC  r   USE_LEGACY_TYPE_SYSTEMrK  np_complex128r   )r!  r  r  r   r	  r}   s        @rE   numpy_linspacern    s    FFFcC/05  %%

CeT]
CC(($$E''E, OrG   c           
         |j                   d   } t        |      | ||d         }t        j                  ||j                        }|j
                  }t        | |||      }|j                  }	|j                  }
|j                  dv sJ |j                  |j                  k(  r0t        j                  ||
|	|j                  |j                  d       nt        j                  ||j                        }t        j                  ||j                        }| j                  t        j                        }t        j                   |||      5 }t        j"                  | ||	|||j                  |      }t        j"                  | ||
|||j                  |      }|j%                  |j'                  |      |       ddd       t)        | ||j
                  |j+                               S # 1 sw Y   /xY w)z
    Array copy.
    r   r  r  rI   r   N)r   rz   r
   r   rg   r   r  r   r  
raw_memcpyr   r   r   r   r   r   r0  r  r  r@   r"   r   )r   r?   r]   r   r  r   r   rettyperY  r$  r  r&  r  r   r   r  r3  s                    rE   _array_copyrr    s    hhqkG
*W
gwd1g
>C!!'3995FooG
'7F
;CxxHI>>T!!!~~'7Ix<<q	2 **7CKK@++GS[[A''

3w7 	;7//(0607IG 00'91718JH MM',,w/:	; GWcoos}}OO	; 	;s   A,G""G+c                     t        |t        j                        sJ |j                  dk(  rdnd}|j	                  |d      } ||      }|t
        fS )Nr  r   F)r  rS  )r   r   r   r  rM  rr  )rX  r  r  rY  r]   s        rE   _array_copy_intrinsicrt    sM    a%%%HHOSF
&&&
/C
a&CrG   z
array.copyc                     t        | |||      S r=  )rr  r  s       rE   
array_copyrv    s    wd33rG   c                     t        |       st        j                  d      t        | t        j
                        rd }|S d }|S )NrZ  c                     t        |       S r=  )rt  rz  s    rE   
numpy_copyz#impl_numpy_copy.<locals>.numpy_copy  s    (++rG   c                 ,    t        j                  |       S r=  )rk  rl  rz  s    rE   ry  z#impl_numpy_copy.<locals>.numpy_copy  s    ::a= rG   )r   r	   r   r   r   r   )r  ry  s     rE   impl_numpy_copyr{    sL    A   "1 2 	2 !U[[!	, 	! rG   c           	      D   |j                   }|j                  d   }|j                  |k(  sJ d       |j                  dk(  r|j                  dk(  sJ  t	        |      | ||d         } t	        |      | |      }| j                  |t        j                  t        j                  d      d      }	| j                  |t        j                  t        j                  d      |j                  f      }
t        ||j                  |	|
|j                  |j                  |j                         t        | |||j!                               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         }|j)                  |      5 \  }}|5  t        | |||d         }|j*                  }d	d	d	       |5  t-        | |||      }|j*                  }d	d	d	       d	d	d	       |j/                  j0                        }|j3                  |       |j3                         |S t-        | |||      S # 1 sw Y   xY w# 1 sw Y   lxY w# 1 sw Y   pxY w)
zd
    Common logic for layout conversion function;
    e.g. ascontiguousarray and asfortranarray
    r   z return-type has incorrect layoutrI   r  r  r  rK  r   N)r   r   r  rr   rz   r  r   rt  r   r  r   r   r   r   r   r!   r   r   r   rH  r  blockrr  phir;   add_incoming)r   r?   r]   r   output_layoutrH  r   r   rY  rg   r   
check_funcr'  thenorelseout_thenthen_blk
out_orelse
orelse_blkret_phis                       rE   _as_layout_arrayr    sq   
 OOEHHQKE<<=(L*LL(zzQzzQjQ@j1,,U^^EJJ2D
 $$W%*^^EJJ%B&)ll_6 	sCHHeWcll{{CJJ	0 '5#--/JJ
,,%,,
&

aELLD$8 '5$q'BB <<3 !D(((*73*>JJ.z/6/6/4/3Aw	8I
 + 	/~f -0'515a :H&}}H-
  /!,WgsD!IJ!(J/	/ kk(--0G  84  Z8N wd;;!- -
/ /	/ 	/s<   JI>:
JJ
J>J	J
J	JJc                     t        t        j                        st        j                        |j                  j                  t        |j                  d            } ||      }|fdfS )NrI   )r  rr   c                 8    t        | |||j                        S )N)r  )r  r   )r  r  r   r  r  s       rE   r  z,_as_layout_array_intrinsic.<locals>.<lambda>:  s    #3	1a-"="=$? rG   )	r   r   r&   r	   RequireLiteralValuerM  r   r  rr   )rX  r  r  rY  r]   s     `  rE   _as_layout_array_intrinsicr  2  sd    mU%8%89((77
&&33#affa.&
IC
a
C ? ? ?rG   c                     t        |       st        j                  d      t        | t        j
                  t        j                  f      rd }|S t        | t        j                        rd }S )NrZ  c                 R    t        j                  t        j                  |             S r=  )rk  ascontiguousarrayr   rz  s    rE   r   z%array_ascontiguousarray.<locals>.implD  s    ''44rG   c                     t        | d      S Nr   r  rz  s    rE   r   z%array_ascontiguousarray.<locals>.implG      -a55rG   r   r	   r   r   r   r  r  r   r  s     rE   array_ascontiguousarrayr  >  sY    A  !FGG!ellEMM34	5
 K 
Au{{	#	6KrG   c                     t        |       st        j                  d      t        | t        j
                  t        j                  f      rd }|S t        | t        j                        rd }|S y )NrZ  c                 R    t        j                  t        j                  |             S r=  )rk  asfortranarrayr   rz  s    rE   r   z"array_asfortranarray.<locals>.implR  s    $$RXXa[11rG   c                     t        | d      S )Nr  r  rz  s    rE   r   z"array_asfortranarray.<locals>.implV  r  rG   r  r  s     rE   array_asfortranarrayr  L  sZ    A  !FGG!ellEMM34	2	Au{{	#	6 
$rG   zarray.astypec           
      r   |j                   d   } t        |      | ||d         }t        j                  ||j                        }|j
                  }t        | |||      }|j                  }	|j                  }
t        j                  ||j                        }t        j                  ||j                        }| j                  t        j                        }t        j                  |||      5 }t        j                  | ||	|||j                  |      }t        j                  | ||
|||j                  |      }t        | |||      }| j!                  |||j"                  |j"                        }t%        | ||||       d d d        t'        | ||j
                  |j)                               S # 1 sw Y   /xY wro  )r   rz   r
   r   rg   r   r  r   r   r   r   r   r0  r  r  r   r   r}   r   r"   r   )r   r?   r]   r   r  r   r   rq  rY  r$  r  r&  r  r   r   r  r3  items                     rE   array_astyper  [  s{    hhqkG
*W
gwd1g
>C!!'3995FooG
'7F
;CxxHI&&w<K''=L##EJJ/F			7FF	3 	>w++GWh,2K,3NNGE ,,Wgy-3\-4^^WF '7G<||GT7=='--H7GWdH=	> GWcoos}}OO	> 	>s   /BF--F6c                 ^    t        |t        j                        sJ t        |      }d }||fS )Nc           
         |j                   \  }t        |      } || ||d         }|j                  }|j                  ||j                        }t        | ||      }	|j                  rV|j                  dk(  rGt        j                  ||	j                  |j                  |j                  |       |	j7                         S t        j                  ||j                        }
t        j                  ||j                        }|j                  }| j                  t        j                         }t        j"                  ||dd      }t        j$                  ||
|      5 }t        j&                  | ||j                  |
|||      }|j)                  ||	j                  j*                        }|j-                  |      }|j/                  |	j                  |g      }t        j0                  ||||       |j3                  |j5                  ||      |       d d d        |	j7                         S # 1 sw Y   |	j7                         S xY w)Nr   r   byteptrT)namerQ   )r   rz   r   r   r   r/   r+  r  r
   rp  r   r   rg   r   r   r   r   rY   r0  r  r+  r;   r@   r  r  r  r  r   )r   r?   r]   r   r@  r  r  r   r"  bstrrg   r   r  r   byteidxr   rm   srcptrr   destptrs                       rE   rW  z)_array_tobytes_intrinsic.<locals>.codegen  s   xx2GWd1g.<<Xszz2#GWf=NNryyC/w		388SZZ'). ~~) ((#))<E**7CKK@GYYF++EJJ7F))itG ""7E6: 
Cg//Wchhw !diinn=ll7+!++dii#7wBgkk#x8'B
C ~~
C ~~s   B4H%%H=)r   r   r   r0   )rX  r  r]   rW  s       rE   _array_tobytes_intrinsicr  z  s1    a%%%
Q-C" F <rG   r  c                 B    t        | t        j                        rd }|S y )Nc                     t        |       S r=  )r  rk  s    rE   r   z impl_array_tobytes.<locals>.impl  s    +C00rG   r>  rl  s     rE   impl_array_tobytesr    s    #u{{#	1 $rG   c                 @    |j                   } ||||||      }d }||fS )Nc           	         |j                   d   }|d   }|d   }|j                  } t        |      | ||d         }t        |      }	 |	| |      }
|
j                  }t	        | |      }t        |j                  j                  |      }|j                  |j                  |j                        }|j                  ||      }|j                  ||      }|j                  d|t        j
                  |j                  d            }d}|j                  |d      5  | j                  j                  |t         |f       d d d        |j                  d|t        j
                  |j                  d            }|j#                  ||      }t%        j&                  ||      }|j                  |d      5  d	}| j                  j                  |t         |f       d d d        |j)                  |      5 \  }}|5  |j*                  }|j-                  ||      }d d d        |5  |j*                  }d d d        d d d        |j/                  |j                        }|j1                         |j1                  |       |j                  ||      }|j3                  d
||      }|j                  |d      5  d}| j                  j                  |t         |f       d d d        t%        j4                  ||g      }t%        j4                  ||g      }|j7                  |j8                  |g      }|j;                  || j=                  |j?                  d                  }tA        |
|||||jB                  |jD                         |
jG                         } tI        | ||j                  |       S # 1 sw Y   mxY w# 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   xY w)Nr   r\  r*  r  r
  z=offset must be non-negative and no greater than buffer lengthFrV  z.buffer size must be a multiple of element sizer  z%buffer is smaller than requested sizer   r3  )%r   r   rz   r   r   r   r   r;   r   r   r  r  r   r  rX  rY  r   sremr
   is_not_nullr  basic_blocksdivr~  r  r  rl   r  r   r+  r   r   r   r   r   r   r!   )!r   r?   r]   r   bufty	arg_count
arg_offsetr   r  
out_ary_tyout_aryout_datamodelr   ll_itemsizer"  ll_offset_sizenbytes_is_negativer   ll_count_is_negativeremis_incompatible
then_block
else_blockbb_if	num_wholebb_elsell_itemcountll_required_sizeis_too_largerg   r   r   r   s!                                    rE   rW  znp_frombuffer.<locals>.codegen  s   G	!W
jQ@&
Wg.**/s||00(;SZZ6 Z=V^4$00KK	*
 N__/_> 	K--gzC6J	K  '22KK	* 
 ll6;/!--gs;___U_; 	KBC--gzC6J	K
 __12 	.6Nz: >++#LL=	>  .!--.		. {{9>>2!!)U3!!)W5 #;;|[A,,S2BFK__\%_8 	K9C--gzC6J	K
 ""7\N;$$W{m<{{388j\2'(()?)?)GH
 	w "& +"{{!jj	* ! '3??CHHm	K 	K	K 	K> >. .		. 	.	K 	Ks`   #N'0%N4.O4O
OO*O1%O('N14N>O	OO	OO%(O2r  )	rX  bufferr}   r   r   rH  r@  r]   rW  s	            rE   np_frombufferr    s3    			B
VUE65
1CNI` <rG   r  c                     t        d|       t        | t        j                        r| j                  dk7  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        d	d
ffd	}|S )N
frombufferr   z+Argument "buffer" must be buffer-like. Got rI   )r}   rr   r  rS  z3Cannot parse input types to function np.frombuffer(r  r  r  r   c                 "    t        | |||      S r=  )r  )r  r}   r   r   rH  s       rE   r   z impl_np_frombuffer.<locals>.impl  s    VUE65AArG   )r  r   r   r   r  r	   r   r  r  r  r   r  r  r   r3  )r  r}   r   r   r   r  r   rH  s          @rE   impl_np_frombufferr    s    </fell+v}}/C;F8D  %%u~~.53C3Cu3L<<!%((3)/%79  &xr%3  %% 1 B KrG   c                     t        |      rt        dd       dfd	}|S t        |t        j                        rt        d|      dfd	}|S y )Nr   c                      | |      S r=  rr  rm   rg   r}   intrinsic_cfarrays      rE   r   zimpl_carray.<locals>.impl'      $S%00rG   c                      | |      S r=  rr  r  s      rE   r   zimpl_carray.<locals>.impl-  r  rG   r=  r   get_cfarray_intrinsicr   r   r  rm   rg   r}   r   r  s       @rE   impl_carrayr  "  L    51#t<	1	E5??	+1#u=	1 
,rG   c                     t        |      rt        dd       dfd	}|S t        |t        j                        rt        d|      dfd	}|S y )Nr  c                      | |      S r=  rr  r  s      rE   r   zimpl_farray.<locals>.impl7  r  rG   c                      | |      S r=  rr  r  s      rE   r   zimpl_farray.<locals>.impl=  r  rG   r=  r  r  s       @rE   impl_farrayr  2  r  rG   c                 (     t          fd       }|S )Nc                 b   |t         j                  u rd }nBt        |t         j                        r|j                  }nd| d}t        j                  |      	|d}t        j                  |      |}nft        	t         j                        r1	j                  }|>||k7  r9d| d| d}t        j                  |      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  r  r  r   r%   
np_cfarray)rX  rm   rg   	ptr_dtyper   r}   rr   rH  r]   dtype_r  s            rE   r  z0get_cfarray_intrinsic.<locals>.intrinsic_cfarrayC  s1   %--IU^^,		I4SE;C'',,> B++C00E0LLE$));+E72Fse1M++C00(2C'',,e$<#E7!,C'',,E40sE*JrG   r*   )r  r  r  s   `` rE   r  r  B  s     > rG   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}t        ||      D cg c]'  \  }}| j                  |||t        j                        ) }}}|}g }|j                  dk(  r+|D ]%  }|j                  |       |j                  ||      }' nCt!        |      D ]%  }|j                  |       |j                  ||      }' |j#                          |j%                  || j'                  |j(                        j+                               }t-        |	||||d       |	j/                         }t1        | ||j                  |      S c c}}w )zR
    numba.numpy_support.carray(...) and
    numba.numpy_support.farray(...).
    Nr\  r  r  r  )r   r   r  rz   r   r
   r   r   r   rI  r   r   r   r   rk   r   r  r`  r+  r|   r}   r  r   r   r"   )r   r?   r]   r   r#  r  rm   rg   r   r  r   r  r   r?  r	  offr   r   r   r   s                       rE   r  r  f  s   
 XXbq\NE7bqJCOOE<<4j1GGU+H..*K'5??+%%gu5*#&w#79&% ll7E65::> 9F 9 CG||s 	&ANN3++c1%C	& &! 	&ANN3++c1%C	& 	??3"00=HHJLD 7"' 


CGWcoosCC99s   0,Gc                 0   t        |t        j                        r)| j                  t        j                  t        |            S t        |t        j                        r8| j                  t
        t        t        j                  |            } |||f      S J r=  )	r   r   rI  r   r   r   r  rS   r%   )r   r?   seqtyseqr  s        rE   _get_seq_sizer    sj    %)##EJJE
;;	E5>>	*''Yuzz5-JK#((qrG   c                      |j                    j                  t        j                  t	        |t
        j                               fd}|S )zK
    Return a getitem() implementation that doesn't incref its result.
    c                 l     | |      }j                   rj                  j                  | |       |S r=  )r   r   decref)r?   r   rY  r   r  rH  s      rE   wrapz$_get_borrowing_getitem.<locals>.wrap  s3    7D)KKws3
rG   )r}   rS   r  r  r%   r   r   )r   r  r  r  rH  s   `  @@rE   _get_borrowing_getitemr    sC     KKE''(8(8(1%

(KML KrG   c           	      
     j                  t        j                        }t        |d       fd}g }||}	}t	        |      D ]0  }
|
dkD  r |||	      \  }}	|j                  t         ||	             2 t        |      S )zF
    Compute the likely shape of a nested sequence (possibly 0d).
    r   c                     t        | t        j                        r&t        |       dk(  ry| d   j	                  |d      fS t        |       }| j                   ||f      fS )Nr   NN)r   r   rI  r   rP  r  r}   )r  r  r  r?   r   r   s      rE   get_first_itemz.compute_sequence_shape.<locals>.get_first_item  sa    eU__-5zQ!Qx!6!6sA!>>>1'5AL;;WsDk BBBrG   )r   r   r   r   r:   rk   r  r   )r   r?   rr   r  r  r   r  r   innertyinnerro   r   s   ``         @rE   compute_sequence_shaper    s     ##EJJ/FFADC FCUG4[ Gq5+GU;NGUmGWguEFG
 =rG   c                 <      fd fd |||       y)z?
    Check the nested sequence matches the given *shapes*.
    c                  H    j                   j                   t        d       y )N)zincompatible sequence shape)rX  rY  r   )r?   r   s   rE   _failz#check_sequence_shape.<locals>._fail  s    ))':*J	LrG   c                    t        |      dk(  ry t        | |      }|d   }j                  d||      }j                  |d      5           d d d        t        |      dk(  ry t	        | t
        j                        rZt        |       }t        j                  |      5 }| j                  } |||j                  f      }	 ||	|dd         d d d        y t	        | t
        j                        r>t        t        |             D ]&  }
| |
   }j                  ||
      }	 ||	|dd         ( y J |        # 1 sw Y   xY w# 1 sw Y   y xY w)Nr   rU  FrV  rI   )r   r  r  r  r   r   r  r  r
   r  r}   r   rI  r:   rP  )r  r  r   r   expectedrC  r  r  r  r  ro   r  r?   check_seq_sizer   s              rE   r  z,check_sequence_shape.<locals>.check_seq_size  sP   v;!Wguc:!9&&tT8<__Xe_4 	G	 v;!eU^^,1'5AL""7D1 ;T++$WsDJJ.?@wvabz:; ;
 u/3u:& ;(--c15wvabz:; eO1)	 	; ;s   
D<%/E<EENrr  )r   r?   r  r  r   r  r  s   ``   @@rE   check_sequence_shaper    s    
L: 5#v&rG   c                 N    	  fd		 fd ||d       y)zl
    Assign a nested sequence contents to an array.  The shape must match
    the sequence's structure.
    c           
          t        j                  	j                  | d      }j                  ||j                        }t        ||       y r  )r
   r  r  r   r}   r   )
r   rL  r   rm   r  r?   r   r   r   r   s
       rE   assign_itemz-assign_sequence_to_array.<locals>.assign_item  sQ    ''$(-g%Qll7C<7GUC5rG   c                    t        |      dk(  r7t        | t        j                  t        j                  f      rJ  || |       y |d   }t        | t        j                        rit        |       }t        j                  |      5 }| j                  } |||j                  f      } |||dd  ||j                  fz          d d d        y t        | t        j                        rct        t        |             D ]K  }	| |	   }j                  ||	      }j                  t        j                  |	      }
 |||dd  ||
fz          M y J |        # 1 sw Y   y xY wr  )r   r   r   r  rI  r  r
   r  r}   r   r:   rP  r   r   )r  r  r   r   r   r  r  r  r  ro   r   assignr  r?   r   s              rE   r  z(assign_sequence_to_array.<locals>.assign	  sM   v;!!%%..%//)JKKK,ayeU^^,1'5AL""7D1 LT++$WsDJJ.?@wvabz7djj]3JKL L
 u/3u:& G(--c15,,UZZ;wvabz7eX3EF	G eO1L Ls   >EErr  Nrr  )
r   r?   r   r   r   r  r  r  r  r  s
   ``````  @@rE   assign_sequence_to_arrayr     s"    6 62 5#vr"rG   c                     t        | |      \  }}t        |      r|}nt        |      }|y t        j                  ||d      S r  )r6   r   r  r   r   )rX  r8  r}   rr   	seq_dtypes        rE   np_array_typerr  %  sD    ,Y?OD)5u%=;;udC((rG   c                 T    t        d|       t        | ||      } |||      }d }||fS )Nr   c           
      j   |j                   }|j                  }|j                  d   }|d   }t        | ||||      }t	        |      |k(  sJ t        | ||||       t        | |||      }	t        | ||	j                  ||	j                  |||       t        | ||j                   |	j                               S r   )r   rr   r   r  r   r  r  r   r   r   r"   r   )
r   r?   r]   r   r  rr   r  r  r   r  s
             rE   rW  znp_array.<locals>.codegen6  s    zz1g'$sK6{d"""Wguc6BWguf= '388V!$eUC	A  #// #1 	1rG   )r  r  )rX  objr}   rY  r]   rW  s         rE   np_arrayr  0  s6    7E*
C
/C
c5/C1" <rG   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 r=  )r  )r8  r}   s     rE   r   zimpl_np_array.<locals>.implT  s    &&rG   r=  )r  r   r	   r   r   r  )r8  r}   r   r   s       rE   impl_np_arrayr
  J  s^    7E*F#   "1 2 	2u."7"?J  %%'KrG   c                    |j                  d      }|j                  |      }|j                  d||      }|j                  ||j                  ||      |      }|j	                  |j                  d||      |j                  d||            }|j                  |d      5  d|z  }	| j                  j                  |t        |	f       d d d        |S # 1 sw Y   |S xY w)Nr   r
  r  FrV  z%s(): axis out of bounds)	r;   r  r  r  r  r  rX  rY  r7  )
r   r?   r   rr   r   r   ll_ndimis_neg_axisaxis_out_of_boundsr   s
             rE   _normalize_axisr  Y  s    99Q<DiioG %%c46K>>+w{{4'A4HD !Ct,D$02 
+E	: G(94))':vFG K	G Ks    (CCc           
      v   t        |      |dz
  k(  sJ t        j                  t        j                  |      }t        j
                  ||      }t        j                  d      }t        |dz
        D ]z  }t        j                  |      }	|j                  d|	|      }
||   }|j                  |
|j                  |	|      |	      }|j                  |t        j                  ||d|             | |j                  |t        j                  ||d|             t        j                  ||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).
    rI   r  r   r   r   r  r
   r   rY   r:   r  r  r  r  rj   r   r@   )r   r?   
orig_shaperr   r   ll_shtyr   r&  rv  ll_dim
after_axisr/  r   s                rE   _insert_axis_in_shaper  l  s    z?dQh&&&ll7>>40G  '2F
..
C TAX I$((vt<
_nnZ$[[5#% 	b'..w3GHI MM#w++GVQEFf)=>>rG   c           
         t        |      |dz
  k(  sJ t        j                  t        j                  |      }t        j
                  ||      }t        j                  d      }t        j                  d      }t        |dz
        D ]x  }	t        j                  |	      }
|j                  d|
|      }|j                  ||j                  |
|      |
      }|j                  ||	   t        j                  ||d|             z |j                  |t        j                  ||d|             t        j                  ||j                  |            S )zD
    Same as _insert_axis_in_shape(), but with a strides array.
    rI   r   r  r  )r   r?   orig_stridesrr   r   r  r   r&  r   rv  r  r  r   s                rE   _insert_axis_in_stridesr    s"    |q(((ll7>>40G!!'73G
..
C>>!D TAX F$((vt<
nnZ$[[5#% 	l3'**7GQD	FF MM$,,Wgq$GHg)>??rG   c           	         |j                   }|j                  }|j                  d   } t        |      | ||d         } t        |      | |      }	t	        j
                  ||j                        }
t	        j
                  ||j                        }t        | ||
||      }t        | ||||      }t        |	|j                  |||j                  |j                  |j                         |	j                         S )z/
    np.expand_dims() with the given axis.
    r   r  r3  )r   rr   r   rz   r
   r   rg   r   r  r  r   r   r   r   r   r   )r   r?   r]   r   r   rH  rr   r  r  rY  r   r   
new_shapesnew_stridess                 rE   expand_dimsr    s     OOE::DHHQKE
*U
GWDG
<C
*U
GW
-C!!'3995F""7CKK8G&wtLJ)'7GT4PK3#&LL;;**& ==?rG   c                     |j                   dk  r|j                  nd}|j                  |j                   dz   |      } |||      }d }||fS )NrI   rK  rL  c                     | j                  ||d   |j                  d   t        j                        }t	        | |d|j
                  j                  |      }t        | ||||      }t        | ||j
                  |      S )NrI   znp.expand_dims)	r   r   r   r   r  r   rr   r  r!   )r   r?   r]   r   r   rY  s         rE   rW  znp_expand_dims.<locals>.codegen  so    ||GT!Wchhqk5::Fw1A"33T; '7Ct< '3??CHHrG   )rr   r  rM  )rX  r  r   r  rY  r]   rW  s          rE   np_expand_dimsr     sN    1QXX#F
&&affqj&
0C
a,CI <rG   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 r=  )r   )r  r   s     rE   r   z!impl_np_expand_dims.<locals>.impl  s    a&&rG   )r   r   r   r	   r   r   )r  r   r   r   s       rE   impl_np_expand_dimsr#    sb    a%9!=  %%dEMM*8?  %%'KrG   c                 0     t          fd       fdS )Nc           	      0   ||D cg c](  }|j                  t        |j                              * c}fd}t        t	              dkD  rt        j                        nd   t
        j                  j                  |            |fS c c}w )NrA  c                 F   t              }t        j                  ||d         }t        |      D cg c]  \  }}} || ||||       }	}}}t	        |	      dkD  r| j                  ||j                  |	      }
n|	d   }
t        | ||j                  |
      S c c}}}w r  )_atleast_nd_transformr
   r   r   r   r  r   r!   )r   r?   r]   r   	transformarrsr  r  rH  retsrY  r  r   minimumr0  s              rE   rW  z*_atleast_nd.<locals>.impl.<locals>.codegen  s    -gt<I''a9D .1vv-FH H)UE gwUEB HD H 4y1}((#//4H1g$WgsLLHs   BrI   r   )	rM  r  rr   r%   r   r   ru  StarArgTuple
from_types)typingcontextr   r  rW  r  r0  r   r+  s       @@rE   r   z_atleast_nd.<locals>.impl  s    CGHC#((CHHg 6(7H	M FaV,VAY++66t<>?FG 	G Is   -Bc                       |  S r=  rr  )r   r   s    rE   r  z_atleast_nd.<locals>.<lambda>  s    t rG   r  )r+  r   r   s   ``@rE   _atleast_ndr0    s    G G( %$rG   c                 6      t              k(  sJ  fd}|S )z`
    Return a callback successively inserting 1-sized dimensions at the
    following axes.
    c           	         t        
      D ]t  }|dz   }|j                  |k  st        j                  	|         }|j	                  |j                  dz         }t        | |t        j                  ||      |f|      }|}v |S )NrI   rA  )r:   rr   r
   r   rM  r  r   r%   )r   r?   r  r  rH  ro   rr   r   newarrtyr   min_ndims            rE   r(  z(_atleast_nd_transform.<locals>.transform  s    x 	!Aq5DzzD ~~d1g. ::5::>::!'7"("2"28U"CcV"&( !	! 
rG   )r   )r4  r   r(  s   `` rE   r'  r'    s$    
 s4y    rG   c                  B    t        d | D              rt        ddg      S y )Nc              3   P   K   | ]  }t        |t        j                           y wr=  r>  r  s     rE   rA  z np_atleast_1d.<locals>.<genexpr>       
8C:c5;;'
8rB  rI   r   rv  r0  r  s    rE   np_atleast_1dr9    s$    

84
881qc"" 9rG   c                  D    t        d | D              rt        dddg      S y )Nc              3   P   K   | ]  }t        |t        j                           y wr=  r>  r  s     rE   rA  z np_atleast_2d.<locals>.<genexpr>  r7  rB  r\  r   r8  r  s    rE   np_atleast_2dr<    s&    

84
881q!f%% 9rG   c                  D    t        d | D              rt        dg d      S y )Nc              3   P   K   | ]  }t        |t        j                           y wr=  r>  r  s     rE   rA  z np_atleast_3d.<locals>.<genexpr>   r7  rB  r*  )r   r   r\  r8  r  s    rE   np_atleast_3dr?    s"    

84
881i(( 9rG   c	                 f   t        |      t        |      cxk(  rt        |      cxk(  rt        |      k(  sJ  J t        j                  d      }	t        | |||      }
t        j                  ||
j
                        }g }|D ]  }|	}t        t        ||            D ]_  \  }\  }}|j                  d|j                  |      |      }|j                  ||      }|j                  ||j                  ||      |      }a |j                  |        |
j                  }t        |||||      D ]  \  }}}}}|j                  }t        j                  ||t        j                  |j                         }|5 }t        j"                  | |||||j                   |      }t%        | |||      }| j'                  |||j(                  |j(                        }t        j"                  | |||||j                   |      }t+        | ||||       ddd       t        j,                  |||      } |
S # 1 sw Y   $xY w)z2
    Concatenate arrays along the given axis.
    r   r  )orderN)r   r
   r   r  r   r   r  r   r  r;   r   r  r  rk   r   r0  r  r  r   r   r}   r   r   )r   r?   r   r  r)  
arr_shapesarr_stridesrH  
ret_shapesr   rY  ret_stridescopy_offsetsarr_shr   rv  r   r  is_axisaddendret_datar  r  arr_starr_datar0  r   r  r   r3  s                                 rE   _do_concatenaterM  $  s,    v;#d)Js:J#k:JJJJJJ>>!D '5*
=C&&w<K L 	$#,S-E#F 	,C$))$		#EG[[v.F^^G$+KK$?$*,F	, 	F#	$ xxH.1&$
2=|/M B*sFFF88 %%gvw~~,1LL:	  		?'//(0605gGG GWeW=C,,wU[[%++FC00'81;[16wHH wX>		? &&w&A+B. J		? 		?s   4BH''H0	c                 x   |j                   }t        ||      D cg c]  \  }} t        |      | ||       }}}t        | |d||      }|D 	cg c]"  }	t	        j
                  ||	j                        $ }
}	|D 	cg c]"  }	t	        j
                  ||	j                        $ }}	|
d   D cg c]  }t	        j                  ||       }}t        |      D ]C  }|j                  d|j                  |      |      }||   }|j                  |      }|
dd  D cg c]  }||   	 }}|j                  |      5 \  }}|5  t        j                  |j                   ||gz         }|j#                  ||       d d d        |5  t        j$                  }|D ]%  }|j'                  ||j                  d||            }' |j)                  |j+                  |      d      5  | j,                  j/                  |t0        d|z  f       d d d        d d d        d d d        F |D cg c]  }|j                  |       }}t3        | |||||
|||	      }t5        | |||j7                               S c c}}w c c}	w c c}	w c c}w c c}w # 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   xY wc c}w )	Nr  np.concatenater   r  rI   FrV  z<np.concatenate(): input sizes over dimension %d do not match)rr   r   rz   r  r
   r   rg   r   r   r:   r  r;   r@   r  r6  r7  r  r  r8  r  r  r  rX  rY  r   rM  r"   r   )r   r?   r  r)  rH  r   rr   r  r  r  rB  rC  r/  rD  rv  rH  ret_shape_ptrret_shother_shapeson_axison_other_dimis_okrY  s                          rE   _np_concatenaterV  a  s   ::D fd+-Q JsOGWA6 -D - 7G-=tTJD GKKs'&&w		:KJKIMN#7''=NKN 'qM+ ++GR8 +J + T{ >%%dDIIcNDA"3m,*4QR.9B399__W% 	>)@'< 1%%KK F8+- b-0	1  	>((& PB#LL)0)<)<T2v)NPEP __W\\%%8_G >%%5557:; =>>	>	> 	>>0 .88r',,r"8J8
'7D $
K-C GWeS]]_EEY- LN
+ :1 1> >	> 	>	> 	>$ 9sx   I+'I1='I6-I;J 9J*?7J6
J* AJ&J	JJ*"J7J
J*JJJ'#J**J4	c                 	   |j                   }t        j                  d      }t        j                  d      }t        j                  t        |            }	t	        ||      D 
cg c]  \  }
} t        |
      | ||       }}
}t        | |d||      }t        j                  ||d   j                        }|dd  D ]  }t        j                  }t	        t        j                  ||j                        |      D ]t  \  }}|j                  ||j                  d||            }|j                  |j                  |      d      5  | j                  j                  |t         d       d d d        v  |D cg c]"  }t        j                  ||j"                        $ }}t%        j&                  t        j                  |      }t        j(                  ||      }t        j(                  ||      }t+        |dz
        D ]  }t        j                  |      }|j                  d	||      }||   }|j-                  ||j/                  ||      |      }|j1                  |t        j2                  ||d|             |j1                  |t        j2                  ||d|              |j1                  |t        j2                  ||d|             |j1                  |	t        j2                  ||d|             t        j                  ||j5                  |            }|gt        |      z  }t        j                  ||j5                  |            }t+        t        |            D cg c]  }t        j(                  ||       }}t+        |dz
        D ]  }t        j                  |      }|j                  d	||      }|j-                  ||j/                  ||      |      }t+        t        |            D ]3  }|j1                  ||   |   t        j2                  |||   d|             5  t+        t        |            D ]-  }|j1                  |t        j2                  |||   d|             / |D cg c]'  }t        j                  ||j5                  |            ) }}t7        | ||||||||	      }t9        | |||j;                               S c c}}
w # 1 sw Y   xY wc c}w c c}w c c}w )
Nr   rI   r  np.stackr  FrV  )z5np.stack(): all input arrays must have the same shaper  )rr   r
   r   r   r   rz   r  r   rg   r8  r  r  r  r  rX  rY  r   r   r   r  rY   r:   r  r  r  rj   r@   rM  r"   r   )r   r?   r  r)  rH  r   rr   r   r&  
ll_narraysr  r  r  r  rU  r/  orig_shr  r  input_shapesrD  rv  r  r  r   ro   input_stridesr0  rY  s                                rE   	_np_stackr]    s   ::D>>!D
..
CD	*J fd+-Q JsOGWA6 -D - 7GZtDD %%gtAw}}=JABx P  w33GSYYG)+ 	PKBLL(;(;D"g(NOEe!4UC P!!11ZNPP P	PP KOO3G((#++>OLO
 ll7>>40G&&w8L$$Wg6J TAX M$((vt<
_nnZ$[[5#% 	b'..waMNb'..w
AsKLM MM#w++G\1dKLMM*g2273=34379 :
 ''l1KLL >CI-L%%gw||J/GHJ $CI.0 ((': 0M 0 TAX 	5$((vt<
nnZ$[[5#% s4y! 	5AMM,q/#.!..wa8H!/245	5	5 3t9 8dG00-:JA157 	88
  -. ))'7<<3CD .M . '7D $m-C GWeS]]_EE_-P P
 PB0*.s$   $S"S6'S !S%0,S*Sc                     |t        |t        j                        sy t        | d|      \  }}|dk(  rd}t	        j
                  |      t        |      }t        j                  |||      S )NrO  r   z.zero-dimensional arrays cannot be concatenated)r   r   r   r7   r	   r  r8   r   )rX  r  r   r}   rr   r   r  s          rE   np_concatenate_typerr_    sl    
4 ? 	 &i&6@KE4qy>##C(()&1F;;udF++rG   c                 t    t        | ||      }t        |t        j                        sJ  |||      }d }||fS )Nc           
          | j                  ||d   |j                  d   t        j                        }t	        | |t        |j                  d         t        j                  ||d         |j                  |      S r  )	r   r   r   r   rV  r   r
   r   r   r   r?   r]   r   r   s        rE   rW  znp_concatenate.<locals>.codegen  se    ||GT!Wchhqk5::Fw#CHHQK0&33GT!WE"#	% 	%rG   )r_  r   r   r   )rX  r  r   rY  r]   rW  s         rE   np_concatenaterc    sA    
y&$
7Cc5;;'''
fd
C% <rG   c                 D    t        | t        j                        rdd}|S y )Nc                     t        | |      S r=  )rc  r  r   s     rE   r   z!impl_np_concatenate.<locals>.impl  s    !&$//rG   r  r   r   rI  r  r   r   s      rE   impl_np_concatenateri    s    &%//*	0 +rG   c                 |    |D ]7  }|j                   dk  s|j                   dkD  s"d}t        j                  |       y)NrI   r\  z7np.column_stack() is only defined on 1-d and 2-d arrays)rr   r	   r  )r   r   r  r  r   s        rE   _column_stack_dimsrk    sA     -66A:!KC'',,- rG   c                     t        | d|t              \  }}t        |      }t        j                  |||      } ||      }d }||fS )Nznp.column_stack)dim_chooserc                 B   t        |j                  d         }t        j                  ||d         }g }g }| j	                  t
        j                  d      }t        ||      D ]  \  }	}
|	j                  dk(  r#|j                  |	       |j                  |
       8|	j                  dk(  sJ |	j                  d      }t        j                  ||	      }t        | |||
f|      }|j                  |       |j                  |        t        | ||||j                  |      S )Nr   rI   r\  rA  )r   r   r
   r   r   r   r   r   rr   rk   rM  r   r%   r  rV  r   )r   r?   r]   r   orig_arrtys	orig_arrsr  r)  r   r  r  r  
expand_signewarrs                 rE   rW  z np_column_stack.<locals>.codegen)  s   388A;'(($q':	##EJJ2k95 	$JE3zzQe$C  zzQ&


*#--eU;
$WgzC64Pe$F#	$ w"6 	6rG   )r7   rk  r8   r   r   )rX  rF  r}   rr   r  rY  r]   rW  s           rE   np_column_stackrs     sS    %i&72DFKE4 *#.F
++eT6
*C
c(C64 <rG   c                 B    t        | t        j                        rd }|S y )Nc                     t        |       S r=  )rs  rF  s    rE   r   zimpl_column_stack.<locals>.implI  s    "3''rG   rg  rF  r   s     rE   impl_column_stackrx  F  s    #u'	( (rG   c           
          t        | |t        |j                  d         t        j                  ||d         |j
                  |      S )z/
    np.stack() with the given axis value.
    r   )r]  r   r   r
   r   r   rb  s        rE   _np_stack_commonrz  N  sC     Wg#((1+&))'47;__	 rG   c                     t        | d|      \  }}t        d |D              rdnd}t        j                  ||dz   |      } |||      }d }||fS )NrX  c              3   :   K   | ]  }|j                   d k(    yw)r  N)r  rH  s     rE   rA  z"np_stack_common.<locals>.<genexpr>^  s     8AC8s   r  r   rI   c                     | j                  ||d   |j                  d   t        j                        }t	        | ||||      S r  )r   r   r   r   rz  rb  s        rE   rW  z np_stack_common.<locals>.codegenb  s9    ||GT!Wchhqk5::F#tTBBrG   )r7   rv  r   r   )	rX  r  r   r}   rr   r  rY  r]   rW  s	            rE   np_stack_commonr~  Y  sa     &i&0&:KE4888ScF
++eTAXv
.C
fd
CC <rG   c                 D    t        | t        j                        rdd}|S y )Nc                     t        | |      S r=  )r~  rf  s     rE   r   zimpl_np_stack.<locals>.impll  s    "6400rG   r  rg  rh  s      rE   impl_np_stackr  i  s    &%//*	1 +rG   c                     t        | ||      \  }}t        ||      }t        |      }t        j                  |||      }|S r=  )r7   r  r8   r   r   )rX  r   r  ndim_minr}   rr   r  rY  s           rE   NdStack_typerr  q  sA    %iFCKE4tXD)&1F
++eT6
*CJrG   c                 <    t        | d|d      } ||      }d }||fS )Nz	np.hstackrI   c                     |j                   d   }|d   j                  }|dk(  r/| j                  t        j                  d      t        | |||      S |dk(  rdndfd}| j                  ||||      S )Nr   rI   c                 2    t        j                  |       S rk  rm  rf  s    rE   np_hstack_implz3_np_hstack.<locals>.codegen.<locals>.np_hstack_impl  s    ~~f488rG   r   rr   r   r   r   rz  r  )r   r?   r]   r   rE  rr   r  r   s          @rE   rW  z_np_hstack.<locals>.codegen  sz    Qx}}19''

A6D#GWc4FF
 	1qD9 ++G^S$OOrG   r  rX  rF  rY  r]   rW  s        rE   
_np_hstackr  z  s-    
	;Q
7C
c(CP& <rG   c                 B    t        | t        j                        rd }|S y )Nc                     t        |       S r=  )r  rv  s    rE   r   zimpl_np_hstack.<locals>.impl      c?"rG   rg  rw  s     rE   impl_np_hstackr        #u'	# (rG   c                 <    t        | d|d      } ||      }d }||fS )Nz	np.vstackr\  c                     |j                   d   }|d   j                  }|dk(  rd }n7|dk(  r/| j                  t        j                  d      }t        | ||||      S d }| j                  ||||      S )Nr   c                 T    t        j                  t        j                  |       d      S r  )rk  r  hstackr  s    rE   np_vstack_implz3_np_vstack.<locals>.codegen.<locals>.np_vstack_impl  s    ~~bii&7;;rG   rI   c                 0    t        j                  | d      S )Nr   rl  rm  r  s    rE   r  z3_np_vstack.<locals>.codegen.<locals>.np_vstack_impl      ~~f155rG   r  )r   r?   r]   r   rE  rr   r  r   s           rE   rW  z_np_vstack.<locals>.codegen  sx    Qx}}19< QY''

A6D#GWc4FF6 ''dKKrG   r  r  s        rE   
_np_vstackr    s-    
	;Q
7C
c(CL& <rG   c                 B    t        | t        j                        rd }|S y )Nc                     t        |       S r=  )r  rv  s    rE   r   zimpl_np_vstack.<locals>.impl  r  rG   rg  rw  s     rE   impl_np_vstackr    r  rG   c                 <    t        | d|d      } ||      }d }||fS )Nz	np.dstackr*  c                    |j                   d   }|j                  }|d   j                  }|dk(  rd }| j                  ||||      S |dk(  r| j	                  t
        j                  d      }|j                  |j                  dz
        }	t        j                  |	g|j                    }
t        | ||
||      }| j	                  t
        j                  d      }t        j                  ||	      }t        | |||f|      S |dk(  r/| j	                  t
        j                  d      }t        | ||||      S d }| j                  ||||      S )Nr   c                 N    t        j                  |       j                  ddd      S )NrI   r  )rk  r  rT  r  s    rE   r  z3_np_dstack.<locals>.codegen.<locals>.np_vstack_impl  s     yy(00Ar::rG   rI   rA  r\  c                 0    t        j                  | d      S )Nr\  rl  rm  r  s    rE   r  z3_np_dstack.<locals>.codegen.<locals>.np_vstack_impl  r  rG   )r   r   rr   r  r   r   r   rM  r   r%   rz  r  )r   r?   r]   r   rE  rH  rr   r  r   stack_retty	stack_sig	stack_retrq  s                rE   rW  z_np_dstack.<locals>.codegen  s:   Qx}}19; ++G^S$OOQY''

A6D**%**q.*9K((@sxx@I('9d)-/I ''

A6D))%=Jwi\4PPQY''

A6D#GWc4FF6 ++G^S$OOrG   r  r  s        rE   
_np_dstackr    s.    
	;Q
7C
c(C PD <rG   c                 B    t        | t        j                        rd }|S y )Nc                     t        |       S r=  )r  rv  s    rE   r   zimpl_np_dstack.<locals>.impl  r  rG   rg  rw  s     rE   impl_np_dstackr    r  rG   fillc                     d }|S )Nc                     || d d  y r=  rr  )r  r   s     rE   	fill_implzarr_fill.<locals>.fill_impl  s    ArG   rr  )r  r   r  s      rE   arr_fillr    s     rG   dotc                     d }|S )Nc                 .    t        j                  | |      S r=  )rk  r  )r  others     rE   dot_implzarray_dot.<locals>.dot_impl  s    vvc5!!rG   rr  )r  r  r  s      rE   	array_dotr     s    " OrG   c                 R    t        |       st        j                  d| z        d }|S )NzCannot np.fliplr on %s typec                 z    t        j                  |       }|j                  dk  rt        d      |d d d d ddf   S )Nr\  r'  r  .rk  rl  rr   r   r~  rK  s     rE   r   znp_flip_lr.<locals>.impl  s=    JJqM 66A:455TrT3rG   r  r~  r   s     rE   
np_flip_lrr    s/     A  !>!BCC  KrG   c                 R    t        |       st        j                  d| z        d }|S )NzCannot np.flipud on %s typec                 t    t        j                  |       }|j                  dk  rt        d      |d d ddf   S )NrI   zInput must be >= 1-d.r  .r  r  s     rE   r   znp_flip_ud.<locals>.impl  s:    JJqM 66A:4552s|rG   r  r  s     rE   
np_flip_udr    s/     A  !>!BCC KrG   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| }| j	                  t         j                        }| j                        } |      |g}	| j                  ||||	      }
|
S )Nc           
      Z    |}t        |       D ]  }t        ||t        d d d            } |S )Nr  )r:   r1   r.  )lengthempty_tupler   ro   s       rE   r   z6_build_flip_slice_tuple.<locals>.codegen.<locals>.impl5  s8    C6] C#CE$b,ABCJrG   )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              rE   rW  z(_build_flip_slice_tuple.<locals>.codegen4  s{    	  **j1$$ZA.A	,,UZZ800<!$'5
&&wiL
rG   )	r   r   rw  r	   r  r   r   rt  slice3_type)r  szr]   rW  r   r  s       @@rE   _build_flip_slice_tupler  *  sf     b%../((,,r De&7&7tDJ
R.C" <rG   c                 p    t        | t        j                        st        j                  d| z        d }|S )NzCannot np.flip on %s typec                 6    t        | j                        }| |   S r=  )r  rr   )r~  sls     rE   r   znp_flip.<locals>.implO  s    $QVV,urG   )r   r   r   r	   r   r  s     rE   np_flipr  H  s5     a%  !<q!@AA KrG   c                    t        | t        j                  t        j                  t        j                  f      rdd}|S t        |t        j
                        rdd}|S t        |t        j                        r4t        |j                  j                  t        j
                        rdd}|S t        |t        j                        r#t        d |j                  D              rdd}|S y y )Nc                 X    t        j                  t        j                  |       ||      S rk  )rk  array_splitrl  r   indices_or_sectionsr   s      rE   r   znp_array_split.<locals>.implY  s$    >>

3# rG   c                     t        | j                  |   |      \  }}t        j                  t        j                  |dz   g|z  |g||z
  dz
  z  z               }t        j
                  | ||      S )NrI   rl  )divmodrg   rk  cumsumr   r  )r   r  r   r  r  r   s         rE   r   znp_array_split.<locals>.implc  sp    CIIdO-@AFAsiiQ#*S01456! G >>#wT::rG   c                 "   t        | j                        }t        dd| j                  |      }g }d}|D ]/  }t        ||t	        ||            }|j                  | |          |}1 |j                  | t        ||t	        d                       |S Nznp.splitr   r   )r2   rr   r   r1   r.  rk   r   r  r   	slice_tupr   prevr  r   s           rE   r   znp_array_split.<locals>.implt  s    .sxx8I!*fchhEDCD* #ItU45EF

3s8$ JJs=D%T:JKLMJrG   c              3   P   K   | ]  }t        |t        j                           y wr=  r   r   r   )r?  r)  s     rE   rA  z!np_array_split.<locals>.<genexpr>  s     P
1emm,PrB  c                 4   t        | j                        }t        dd| j                  |      }g }d}t        |      D ]/  }t	        ||t        ||            }|j                  | |          |}1 |j                  | t	        ||t        d                       |S r  )r2   rr   r   r   r1   r.  rk   r  s           rE   r   znp_array_split.<locals>.impl  s    .sxx8I!*fchhEDCD%&9: #ItU45EF

3s8$ JJs=D%T:JKLMJrG   r  )r   r   rt  ListTyper  r   IterableTypeiterator_typer  ru  rv  r   r  r   r   s       rE   np_array_splitr  V  s    #

CD	 %u}}5	;  	&(:(:;--88MM


	  	&4P6I6O6OPP
	  Q 	5rG   c                     t        | t        j                  t        j                  t        j                  f      rdd}|S t        |t        j
                        rdd}|S t        | ||      S )Nc                 X    t        j                  t        j                  |       ||      S rk  )rk  splitrl  r  s      rE   r   znp_split.<locals>.impl  s    88BJJsO-@tLLrG   c                     t        | j                  |   |      \  }}|dk7  rt        d      t        j                  | ||      S )Nr   z0array split does not result in an equal divisionrl  )r  rg   r   rk  r  )r   r  r   r  r  s        rE   r   znp_split.<locals>.impl  sM    CIIdO-@AFAsax F  >>(t rG   rl  r  )r   r   rt  r  r  r   r  r  s       rE   np_splitr    s[     #

CD	M %u}}5	  c#6TBBrG   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                 f    | j                   dk  rt        d      t        j                  | |d      S )Nr\  z3vsplit only works on arrays of 2 or more dimensionsr   rl  rr   r   rk  r  r   r  s     rE   r   znumpy_vsplit.<locals>.impl  s5    88a< ? A Axx0q99rG   r   r   r   r	   r   r   r  rt  r   r  r   r   s       rE   numpy_vsplitr    s    c5;;'3  %%)EMM5;;,1JJ,H IK  %%: KrG   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kD  rt        j                  | |d      S t        j                  | |d      S )Nr   z3hsplit only works on arrays of 1 or more dimensionsrI   rl  r  r  s     rE   r   znumpy_hsplit.<locals>.impl  sT    88q= ? A A88a<88C!41==xx0q99rG   r  r  s       rE   numpy_hsplitr    ss    c5;;'3  %%)EMM5;;,1JJ,H IK  %%: KrG   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                 f    | j                   dk  rt        d      t        j                  | |d      S )Nr*  z3dsplit only works on arrays of 3 or more dimensionsr\  rl  r  r  s     rE   r   znumpy_dsplit.<locals>.impl  s3    88a< * + +xx0q99rG   r  r  s       rE   numpy_dsplitr    r  rG   c                     | |k  S )z7
    Trivial comparison function between two keys.
    rr  r  s     rE   
default_ltr    s     q5LrG   c                    | |j                   |f}	 t        |   S # t        $ r` | 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  )	rs   _sortsKeyErrorr,   make_jit_quicksortrun_quicksortr-   make_jit_mergesortrun_mergesort)rr  lt_implr  keyr  r  s         rE   get_sort_funcr    s       *
,Cc{ ;//% "D %%D[ //%'D %%Dss    A&BBc                     t        | t        j                        rt        S t        | t        j                        rt
        S t        S r=  )r   r   rJ  r   r  r   r  r  s    rE   lt_implementationr	    s0    %%	E5==	)rG   z
array.sortc                     |j                   d   }t        dt        |j                              fd}| j	                  ||||      S )Nr   r,   )rr  r  c                      |        y r=  rr  r  	sort_funcs    rE   array_sort_implz#array_sort.<locals>.array_sort_impl#  s
    #rG   )r   r  r	  r}   r  )r   r?   r]   r   r  r  r  s         @rE   
array_sortr    sG    hhqkG;&7&FHI ##G_c4HHrG   c                 L    t        |       st        j                  d      d }|S )NzArgument "a" must be array-likec                 F    | j                         }|j                          |S r=  )rM  r  )r  r   s     rE   np_sort_implz"impl_np_sort.<locals>.np_sort_impl0  s    ffh

rG   r  )r  r  s     rE   impl_np_sortr  *  s/    A   "1 2 	2 rG   zarray.argsortc                    	 |j                   \  }}t        |j                  t        |j                        d      		fd}|j                  |j                   d d       }|d d }| j                  ||||      S )NT)rr  r  r  c                      |       S r=  rr  r  s    rE   array_argsort_implz)array_argsort.<locals>.array_argsort_impl@  s    ~rG   rI   r  )r   r  r   r	  r}   replacer  )
r   r?   r]   r   r  rr  r  innersig	innerargsr  s
            @rE   array_argsortr  7  s|     HHMGT4#5#5&7&F)-/I {{!{-HRaI##G-?$,i9 9rG   c                 Z    |j                   |j                   k7  s|j                  dk(  sJ |S )NrK  )r3  r  )r   r?   r?  r@  r   s        rE   array_to_arrayr  L  s*     >>T\\)T[[C-???JrG   c                 z    d }t        ||      }| j                  ||||g      }t        | ||j                  |      S )Nc                 $    | j                  d      S r   )r3  rz  s    rE   r   zarray0d_to_scalar.<locals>.impl[  s    vvayrG   )r%   r  r#   r   r   r?   r?  r@  r   r   r]   r   s           rE   array0d_to_scalarr   S  sB     D&
!C

"
"7D#u
=CgwEErG   c                 z    d }t        ||      }| j                  ||||g      }t        | ||j                  |      S )Nc                     t        | d         S r  )r  rz  s    rE   r   z array_to_unichrseq.<locals>.implf  s    1R5zrG   )r%   r  r!   r   r  s           rE   array_to_unichrseqr#  d  sB     D&
!C

"
"7D#u
=CWgsDDrG   c                     t         )zR
    An intrinsic returning a derived array with the given shape and strides.
    r   )r  rg   r   s      rE   reshape_uncheckedr%  q  r  rG   c                     d fd}|S )Nc                 ^    t        | t        j                        xr t        d | D              S )Nc              3   P   K   | ]  }t        |t        j                           y wr=  r  r.  s     rE   rA  z>type_reshape_unchecked.<locals>.check_shape.<locals>.<genexpr>|  s     @QJq%--0@rB  )r   r   rI  rv  rg   s    rE   r  z+type_reshape_unchecked.<locals>.check_shapez  s*    5%//2 A@%@@	BrG   c                     t        | t        j                        sy  |      r |      sy t        |      t        |      k7  ry | j	                  t        |      d      S )NrK  rL  )r   r   r   r   rM  )r  rg   r   r  s      rE   typerz%type_reshape_unchecked.<locals>.typer~  sP    !U[[)5!W)=u:W%vv3u:cv22rG   rr  )r   r+  r  s     @rE   type_reshape_uncheckedr,  x  s    B3 LrG   c                    |j                   d   }|j                  } t        |      | ||d         } t        |      | |      }t        j                  ||d         }t        j                  ||d         }	t        ||j                  ||	|j                  |j                         |j                         }
t        | |||
      S )Nr   rI   r\  r  )r   r   rz   r
   r   r   r   r   r   r   r!   )r   r?   r]   r   r   rH  r   r   rg   r   r   s              rE   impl_shape_uncheckedr.    s    HHQKEOOE
*U
GWd1g
6C
*U
GW
-C  $q'2E""7DG4G3"LL;; --/CWguc::rG   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 r=  r)  rE  rg   s     rE   rj  zas_strided.<locals>.get_shape  s    77NrG   c                     |S r=  rr  r1  s     rE   rj  zas_strided.<locals>.get_shape  s    LrG   z,as_strided() strides argument cannot be Nonec                     |S r=  rr  )rE  r   s     rE   get_strideszas_strided.<locals>.get_strides  s    NrG   c                 >    t        |  | |       | |            } | S r=  )r%  )rE  rg   r   rj  r4  s      rE   as_strided_implz#as_strided.<locals>.as_strided_impl  s$    a1e!4k!W6MNrG   r  )r   r  r'   r	   r   )rE  rg   r   r6  rj  r4  s       @@rE   
as_stridedr7    s    uzz""		 
	 
	 
	 4$$
   !OPP		 
	 rG   c                    t        |t        j                        rOt        t	        | j
                  dz               t        t	        | j
                  dz               t        d        nt        |t        j                        rt        |j                  t        j                        rat        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                        r1t        |j                  t        j                        rt        d        nt        j                  d      d
fd		}|S )NrI   c                     | fS r=  rr  window_shapes    rE   get_window_shapez-sliding_window_view.<locals>.get_window_shape  s
     ?"rG   c                     | S r=  rr  r:  s    rE   r<  z-sliding_window_view.<locals>.get_window_shape  s    rG   z4window_shape must be an integer or tuple of integersc                 *    t        t        |            S r=  )r   r:   r;  r   rr   s      rE   get_axisz%sliding_window_view.<locals>.get_axis  s    d$$rG   c                      t        dd||      gS Nsliding_window_viewr   r   r?  s      rE   r@  z%sliding_window_view.<locals>.get_axis  s     4fdDI rG   c           	      D    |D cg c]  }t        dd||       c}S c c}w rB  rD  )r;  r   rr   r  s       rE   r@  z%sliding_window_view.<locals>.get_axis  s0     "# ##8&$J # # #s   z2axis must be None, an integer or tuple of integersc                 P    |      } 
||| j                         }t        |      t        |      k7  rt        d      }}t        | j                         D ]6  }t	        ||| j
                  |         }t	        ||| j                  |         }8 | j                   }t        ||      D ]l  \  }}|dk  rt        d      ||   |k  rt        d      ||   |z
  dz   }t	        |||      }t	        |||      }t	        ||| j                  |         }|dz  }n t        | ||      }	|	S )Nz2Must provide matching length window_shape and axisr   z-`window_shape` cannot contain negative valuesz4window_shape cannot be larger than input array shaperI   )	rr   r   r   r:   r1   rg   r   r   r%  )rE  r;  r   	out_shapeout_stridesro   r+  rv  trimmedr5  r@  r<  shape_bufferstride_buffers             rE   sliding_window_view_implz5sliding_window_view.<locals>.sliding_window_view_impl  sP   '5dAFF3|D	)D 
 !	#qvv 	FA%iAGGAJ?I'Q		!EK	F FF4. 	GBQw C  }s" J   mc)A-G%iW=I%iC8I'Q		"FKFA	$ !I{;rG   r=  )r   r   r   r   r:   rr   r'   rt  r}   r   r	   r   r   )rE  r;  r   rL  r@  r<  rJ  rK  s       @@@@rE   rC  rC    sx    ,.U166A:./eAFFQJ/0		# 
	# \5>>
2|))5==9U166C,=#=>?eAFFS->$>?@		  
	    B
 	

 4		% 
	% 
D%--	(		 
	
 T5>>
*tzz5==1		# 
	#
   @
 	
% %N $#rG   c                 B    t        | t        j                        rd }|S y )Nc                     | j                   dk(  rt        dk  ryt        d      | j                   dk(  rt        | j	                  d            S t        d      )Nr   )r\  r\  FziThe truth value of an empty array is ambiguous. Use `array.size > 0` to check that an array is not empty.rI   z[The truth value of an array with more than one element is ambiguous. Use a.any() or a.all())r   r   r   rJ  r3  rk  s    rE   r   zol_bool.<locals>.impl  s_    xx1} 6) $ 'J L L QCHHQK((  #- / /rG   r>  rl  s     rE   ol_boolrO    s!    #u{{#	/  $rG   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   r1   rk  r  )r  rR  rS  
axes_tuple	axes_listrr   s       rE   r   znumpy_swapaxes.<locals>.impl?  sr    }gtUC}gtUC 19TME19TME"9eU;
":ue<
||Az**rG   )
r   r   r   r   r	   r   r   rr   r   r:   )r  rR  rS  r   rU  rr   s       @@rE   numpy_swapaxesrV  0  s    ec5==12   "+ , 	,ec5==12   "+ , 	,a%  !JKK 66DeDk"I+ KrG   c                 (   t        dd| j                  |      }t        | j                        }d||<   t	        t        ||j                              D ]7  \  }\  }}	|dk(  r|	}
n|	dk(  r|}
n||	k7  rt        d      |}
t        |||
      }9 t        ||| j                  |         }t        j                  | |      } t        j                  ||      }|}t        |      dkD  r3t        t        |            D ]  }t        ||| j                  |         } |}t        |      dkD  r9t        t        |            D ]"  }t        ||| j                  |dz   |z            }$ |j                  |   }t        j                  ||fz   |z   | j                        }t        d d d       f}t        j                  |      D ]X  }t        j                  |      D ]>  }| ||z   |z      }|||z   |z      }|||z   |z      }t        |      D ]  }|||      ||<    @ Z |S )Nznp.take_along_axisr   rI   z*`arr` and `indices` dimensions don't matchr   )r   rr   r   rg   r  r   r   r1   rk  rq  r   r:   r  r}   r.  r  )r  r   r   Ni_origNk_origindices_broadcast_shape	arr_shapero   d1d2new_valarr_broadcast_shapeNiNkJr   np_s_iikka_1d
indices_1dout_1dr(  s                          rE   _take_along_axis_implri  P  s4    .$GD SYYIIdO Y!>? 
8B7G1WGRx @  G"/#Q#

 (syy //#2
3Coog'>?G	B
7|as2w 	4Ar1ciil3B	4	B
7|as2w 	?Ar1ciiq1&=>B	? 	dA
((29r>399
-C4t$&Ejjn 0**R. 	0BrEzB'D eb1Jeb)F1X 0 A/q	0		00 JrG   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                  k7  rt        j                  d      t        t        |j                              t        |      rfd}|S t        |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 integersrI   z;`indices` and `arr` must have the same number of dimensionsc                 @    t        | j                         |ddd      S )Nr   rr  )ri  rt  )r  r   r   rZ  s      rE   take_along_axis_implz1arr_take_along_axis.<locals>.take_along_axis_impl  s%    (B)@B BrG   r   zaxis must be a literal valuer   zaxis is out of boundsc                 $    t        | ||      S r=  )ri  )r  r   r   r`  ra  rZ  s      rE   rl  z1arr_take_along_axis.<locals>.take_along_axis_impl  s    (gtR)@B BrG   )r   r   r   r	   r   r}   r   r   rr   r   r:   r   rw  r.  r   )r  r   r   arr_ndimrl  r`  ra  rZ  s        @@@rE   arr_take_along_axisro    su   c5;;'  !LMMgu{{+  <> 	>gmmU]]3  !JKK4887<<  I
 	
 $E',,$784	B(  ! 	v&$ 4 45(()GHH!!!888d?D!8tsxx'(()@AA5;5388,-	B  rG   c                    t        | t        j                        rut        | t        j                        rd	d}|S t        | t        j                        rd	d}|S t        | t        j
                        rd	d}|S t        j                  d      t        |       rt        | j                  t        j                        rd	d}|S t        | j                  t        j                        rd	d}|S t        | j                  t        j
                        rd	d}|S t        j                  d      t        j                  d      )
Nc                     | S r=  rr  rE  rM  nanposinfneginfs        rE   r   znan_to_num_impl.<locals>.impl      rG   c                 @   ||n't        j                  t        |             j                  }||n't        j                  t        |             j                  }t        j
                  |       r|S t        j                  |       r|S t        j                  |       r|S | S r=  )rk  finfor;   r  r  r  isneginfisposinf)rE  rM  rs  rt  ru  min_infmax_infs          rE   r   znan_to_num_impl.<locals>.impl  s     ) $q'*..  ) $q'*..  88A;J[[^"N[[^"NrG   c                     t        j                  | j                  |||      }t        j                  | j                  |||      }t	        ||      S )N)rs  rt  ru  )rk  
nan_to_numr  r  complex)rE  rM  rs  rt  ru  r}  r  s          rE   r   znan_to_num_impl.<locals>.impl  s>    MM!&&c&PMM!&&c&Pq!}$rG   z4Only Integer, Float, and Complex values are acceptedc                     | S r=  rr  rr  s        rE   r   znan_to_num_impl.<locals>.impl  rv  rG   c                    ||n(t        j                  | j                        j                  }||n(t        j                  | j                        j                  }t        j
                  |       }|rt        j                  |      n|}|j                  }	t        |j                        D ]\  }
t        j                  |	|
         r||	|
<   !t        j                  |	|
         r||	|
<   ?t        j                  |	|
         sX||	|
<   ^ |S r=  )rk  rx  r}   r  r  rl  rM  r  r:   r   r  ry  rz  )rE  rM  rs  rt  ru  r{  r|  x_outputoutput_flatro   s              rE   r   znan_to_num_impl.<locals>.impl  s     ) !''*..  ) !''*..  ZZ](,"$kkv{{+ 1AxxA/),A[^4)0A[^4)0A1 rG   c                     t        j                  |       }|rt        j                  |      n|}t        j                  |j                  d|||       t        j                  |j
                  d|||       |S )NF)rM  rs  rt  ru  )rk  rl  rM  r~  r  r  )rE  rM  rs  rt  ru  r  r  s          rE   r   znan_to_num_impl.<locals>.impl  sg    ZZ](,"KK!! KK!! rG   z4The first argument must be a scalar or an array-likeTg        NN)
r   r   r  r   rJ  r  r	   r   r   r}   )rE  rM  rs  rt  ru  r   s         rE   nan_to_num_implr    s   !U\\"a't Ko 5;;'l KG 5==)%D K{ $$F  
!	aggu}}-l Ki -f K7 /4 K $$F     ". / 	/rG   r=  r  r  r  r  )Fr  r  (  rq  r6  rS  r  r-  llvmliter   llvmlite.irr   numpyrk  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.charseqr/   r0   numba.cpython.unsafe.tupler1   r2   r3   numba.core.typing.npydeclr4   r  r5   r  r6   r7   r8   rF   rK   rz   r   r   r   r   r   r   r   r   r   r   r   r   r  ArrayIteratorBORROWEDr  r1  r   r7  r  r   r  r:  rI  rG  rQ  AnyrN  r   rS  r   rZ  r_  r8  ra  rt  r  r  r  r  r  rD  r   r  r  r  r  r4  r=  rI  rQ  rZ  r_  ri  rn  rq  rz  r  broadcast_shapesr  r  r  r  r  r  rK  r  r  r  r  VarArgr  r  r  r  r  r  	geomspacer%  rot90r/  r>  rF  rN  rP  rT  rV  resizere  rk   rn  rw  r\  r|  r  r  r  r  r  r  r  rg   r  r   r  uniquer  r  r  r  r  r  r   r  r  r  r  
MemoryViewr  r  r  r  r!  r$  r(  r,  r1  r4  r:  r7  r=  r  r  rA  rH  rL  rJ  rN  rP  rW  r[  rU  rm  rq  DTypeNumberClassrv  r  r  rx  r  r  r  rw  r  r  r  r  r  Bytesr  is_r  r  r  r  r  r  r9  rC  r  rk  rg  rm  rp  rr  rt  r  rx  rv  rz  r  r~  r  r|  r  r  r  NumpyNdIterTyper  eqr  r  r  r  r  r  r  rY  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  eyer  diagr  r   r#  diagflatr*  r2  r3  rE  rP  r!  rd  r	  rn  rr  rt  rv  rM  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#  r0  r'  
atleast_1dr9  
atleast_2dr<  
atleast_3dr?  rM  rV  r]  r_  rc  r_  ri  rk  rs  column_stackrx  rz  r~  stackr  r  r  r  r  r  vstackr  	row_stackr  dstackr  r  r  r,  r  r-  r  r  flipr  r  r  r  r  vsplitr  hsplitr  dsplitr  r  r  r  r	  r  r  r  argsortr  r  UnicodeCharSeqrJ  r  r  NPTimedelta
NPDatetimer   r#  r%  type_callabler,  r.  libstride_tricksr7  rC  rJ  rO  r+  rV  ri  take_along_axisro  r~  r  rr  rG   rE   <module>r     s/  
         * H H; ; ; P O* * * * ( *A A + ! B L 5E E#69x(-M	

  BJH& 
 
. , y%,,' (.;* z5../w - ! 0-6  $A4H ;* xu}}=xu?E @ >E xu?E @E0 xuyy%))D%6 E%6P sELL!F "F |U[[)8 *8 6?EKK;) <)(/"f /"d/-G /-dW >:-' :-zN-' N-bB-7 B-JL6 L^(GV xu{{;; <;&'TH
:$z"J!. 4  ,  " 5 5>- 
"//'& '&T 3 3  
"

% %P 
"

6 6r 

"95
 6
 

"51 2*U%v&  %++.; /;
  %++u?3E @3El  %++|u||EII/FGF HF
 
",,  u{{C 9 !9& 
"++  
",,I IX 
"(( 4!H;< U__==E >=E@ \U\\%))-DE> F>
 6bjj 
 bjj  
"))+ +\ 
")) 2 }ekk* +, rxx%G &G , - 
 
   
"''v vr f% &{| 
"((  
"''  
"))  
")))1 )1X  " 5;;1 2  	 

9-( .(V |U[[%//:$E ;$ET u{{G$: %:
 u{{G$u): * %: u{{I&u+: , ': u{{F#u(: ) $:
 u{{F#: $: u{{J'u,: - (: u{{H%u*: + &: u.: /:
 u0: 1:
 u0: 1:
 u,: -: u{{H%	9 &	9 u  &): *: Eu~~.Eu}}-; . /;4 u{{G$8 %8 u.u0	: 1 /	: u0
: 1
:  u{{F#Q $Q u{{F#Q $Q 4Mn f%k* + &%
 #ekk6 ": . "ekk6 ": . !2!2EII>( ?(. u{{#4; $4;n e.A.ABO CO u||$$= %$=N u||$D %D: u/B/BCA DA u/C/CDE EE u/B/BEIIN	% O	% u/C/CUYYO
% P
%" ; ; 3 3 9 9 x||U[[%++6
G 7
G  EKK, -9> IM6:#D '+OEP
>BVr u{{F#P $P z5../w E ! 0E x!4!4emmDE EE x!4!4emmyy%% sE''( ) r~~u{{+E ,E" z5556w C ! 7C xemm45rzz<5<<67
E 8 6
E x)rzz5??+E , *E* z5112w 7 ! 37 ryy%))$> %>& z5001w 7 ! 27 x{{EKK5F 6FL^ ekk;u= >* 
 
-`K#&   
"((" & &*   
"-- 0   l+ , 
"(("   
"--  
",,
 
 
"''   
",,
 
 
"''  
"++ 	 %& ' BFF1E  2 
"''# #L 
"** 6 
"++ 4  F 
"''f%^ & ^B4 
"))@ @F 
"++' 'T"PJ   |U[[)4 *4 
"'' ><B ? ? 
"


  
 
"

  ~u{{EOO<~u{{E,?,?@P A =P: ' 'T i( ) T Tn 
"--%*"Q  8 
&  
& !H1Dh"<&'R&#R)  2 
"(( &?:@:8    
".. %2. 
"--# #
 
"--& &
 
"--) )
:z/FdVFr,$    
"..  " "J 
"//    
"((   4 
"))   4 
"))  FHR\\>* & &R 
"))  5;;/ 0 5;;. / 
"))   
"))    : 
"''
 
 
"..; ;| 
"((C C4 
")) & 
")) * 
")) , 
0 |U[[)
I *
I 
"''	 	 U-@-@Arzz5;;(;(;<9 = B9& EKK% & EKK--.EKK%EKK'EKK'EKK'EKK**+EKK))*F + , ( ( ( & /F EKK--.E /E *+ ,"  %++uP; Q;* BFF((334 58 BFF((<<=[$ >[$| 
$ & 
"++ > 8 8v 
"

(  ( V 
"--^ ^rG   