KhSrSSKrSSKrSSKJr SSKJs Jr SSK J r SSK J r /SQr Sr\ "\5S5rSrS rS rS rS7S jrS7S jrS8SjrSrSrS9SjrS:SjrS;SjrSSj5r&S;Sjr'\ "\'5S;S j5r(S8S!jr)\ "\)5S?S"j5r*S@S#jr+S$r,SAS%jr-\ "\-5SBS&j5r.SCS'jr/\ "\/5SDS(j5r0S)r1\ "\15S*5r2S;S+jr3\ "\35SES,j5r4S-r5\ "\55S.5r6SC g)Kz Collection of utilities to manipulate structured arrays. Most of these functions were initially implemented by John Hunter for matplotlib. They have been rewritten and extended for convenience. N)array_function_dispatch)_is_string_like) append_fieldsapply_along_fieldsassign_fields_by_name drop_fieldsfind_duplicates flatten_descrget_fieldstructure get_namesget_names_flatjoin_by merge_arraysrec_append_fieldsrec_drop_fieldsrec_joinrecursive_fill_fields rename_fields repack_fieldsrequire_fields stack_arraysstructured_to_unstructuredunstructured_to_structuredcX4$N)inputoutputs H/var/www/html/env/lib/python3.13/site-packages/numpy/lib/recfunctions.py!_recursive_fill_fields_dispatcherr s ?cURnURH?nXnURRb[XAU5 M/XAUS[ U5&MA U$![a MRf=f)a5 Fills fields from output with fields from input, with support for nested structures. Parameters ---------- input : ndarray Input array. output : ndarray Output array. Notes ----- * `output` should be at least the same size as `input` Examples -------- >>> import numpy as np >>> from numpy.lib import recfunctions as rfn >>> a = np.array([(1, 10.), (2, 20.)], dtype=[('A', np.int64), ('B', np.float64)]) >>> b = np.zeros((3,), dtype=a.dtype) >>> rfn.recursive_fill_fields(a, b) array([(1, 10.), (2, 20.), (0, 0.)], dtype=[('A', '>> import numpy as np >>> dt = np.dtype([(('a', 'A'), np.int64), ('b', np.double, 3)]) >>> dt.descr [(('a', 'A'), '>> _get_fieldspec(dt) [(('a', 'A'), dtype('int64')), ('b', dtype(('# UHoTRU4v M g7fr)fields.0namer#s r !_get_fieldspec..`sEd+,s r)r$r&)r#r-r0fs` r_get_fieldspecr5Hso( {{U }EE" !Vq[TqtTlAaD 9!   s)Ac /nURnUHLnXnURb'URU[[U5545 M;URU5 MN [U5$)a Returns the field names of the input datatype as a tuple. Input datatype must have fields otherwise error is raised. Parameters ---------- adtype : dtype Input datatype Examples -------- >>> import numpy as np >>> from numpy.lib import recfunctions as rfn >>> rfn.get_names(np.empty((1,), dtype=[('A', int)]).dtype) ('A',) >>> rfn.get_names(np.empty((1,), dtype=[('A',int), ('B', float)]).dtype) ('A', 'B') >>> adtype = np.dtype([('a', int), ('b', [('ba', int), ('bb', int)])]) >>> rfn.get_names(adtype) ('a', ('b', ('ba', 'bb'))) )r$appendtupler adtype listnamesr$r0r)s rr r hse,I LLE, == $   dE)G*<$=> ?   T "   r!c/nURnUHAnURU5 XnURcM'UR[U55 MC [ U5$)aU Returns the field names of the input datatype as a tuple. Input datatype must have fields otherwise error is raised. Nested structure are flattened beforehand. Parameters ---------- adtype : dtype Input datatype Examples -------- >>> import numpy as np >>> from numpy.lib import recfunctions as rfn >>> rfn.get_names_flat(np.empty((1,), dtype=[('A', int)]).dtype) is None False >>> rfn.get_names_flat(np.empty((1,), dtype=[('A',int), ('B', str)]).dtype) ('A', 'B') >>> adtype = np.dtype([('a', int), ('b', [('ba', int), ('bb', int)])]) >>> rfn.get_names_flat(adtype) ('a', 'b', 'ba', 'bb') )r$r7extendr r8r9s rr r s[.I LLE, == $   ^G4 5   r!cURnUcSU44$/nUHOnURUupEURbUR[U55 M=UR X445 MQ [ U5$)a; Flatten a structured data-type description. Examples -------- >>> import numpy as np >>> from numpy.lib import recfunctions as rfn >>> ndtype = np.dtype([('a', '>> rfn.flatten_descr(ndtype) (('a', dtype('int32')), ('ba', dtype('float64')), ('bb', dtype('int32'))) r+)r$r-r=r r7r8)ndtyper$descrr(typ_s rr r sr LLE }V E}}U+HSyy$ ]3/0 e\*  U|r!cp/nU(a.UH'nUR[UR55 M) OjUHdnURnURb5[ UR5S:XaUR[ U55 MQUR SU45 Mf [R"U5$)Nr+)r=r r#r$r&r5r7np) seqarraysflattenr'ar)s r _zip_dtyperIsHA OOM!''2 3AggG}}(S-?1-Dw 78W .  88H r!c([XS9R$)z Combine the dtype description of a series of arrays. Parameters ---------- seqarrays : sequence of arrays Sequence of arrays flatten : {boolean}, optional Whether to collapse nested descriptions. rG)rIr@)rFrGs r _zip_descrrLs i 1 7 77r!c`Uc0nURnUHnXnURb.U(aU/X$'O/X$'UR[XTU55 MB[UR U/5=(d /5nU(aUR U5 O U(aU/nU=(d /X$'M U$)a) Returns a dictionary with fields indexing lists of their parent fields. This function is used to simplify access to fields nested in other fields. Parameters ---------- adtype : np.dtype Input datatype lastname : optional Last processed field name (used internally during recursion). parents : dictionary Dictionary of parent fields (used internally during recursion). Examples -------- >>> import numpy as np >>> from numpy.lib import recfunctions as rfn >>> ndtype = np.dtype([('A', int), ... ('B', [('BA', int), ... ('BB', [('BBA', int), ('BBB', int)])])]) >>> rfn.get_fieldstructure(ndtype) ... # XXX: possible regression, order of BBA and BBB is swapped {'A': [], 'B': [], 'BA': ['B'], 'BB': ['B'], 'BBA': ['B', 'BB'], 'BBB': ['B', 'BB']} )r$updater listgetr7)r:lastnameparentsr$r0r) lastparents rr r s6 LLE, == $!)  " NN-gWE Fw{{8R8>B@J!!(+&\ &,"GM Nr!c## UHDn[U[R5(a[[ U55ShvN M@Uv MF gN7f)zi Returns an iterator of concatenated fields from a sequence of arrays, collapsing any nested structure. N) isinstancerEvoid_izip_fields_flatr8iterableelements rrWrWs<  grww ' '(w8 8 8M  8s[U[R 5(a-[ [U55S:Xa[U5ShvN MUv M gN[N7f)zH Returns an iterator of concatenated fields from a sequence of arrays. __iter__NrD)hasattrrUstr _izip_fieldsrErVr&r8rXs rr_r_ sw  GZ ( (w,,#G, , ,  ) )c%..AQ.F#G, , ,M - -s":BBA BB BBc## U(a[nO[n[R"USU06Hn[ U"U55v M g7f)a Returns an iterator of concatenated items from a sequence of arrays. Parameters ---------- seqarrays : sequence of arrays Sequence of arrays. fill_value : {None, integer} Value used to pad shorter iterables. flatten : {True, False}, Whether to fillvalueN)rWr_ itertools zip_longestr8)rF fill_valuerGzipfunctups r _izip_recordsrg0s>#$$iF:FGCL!!GsAAc[U[R5(dSnU(a(U(aUR[R 5nU$[R "U5nU(aUR[R5nU$)zt Private function: return a recarray, a ndarray, a MaskedArray or a MaskedRecords depending on the input parameters F) rUma MaskedArrayviewmrec MaskedRecordsfilledrErecarray)rusemask asrecarrays r _fix_outputrrHse fbnn - - [[!3!34F M6" [[-F Mr!cURRnURURURpTnU=(d 0R 5HupgXb;dM XuU'XsUXF'M U$)zd Update the fill_value and masked data of `output` from the default given in a dictionary defaults. )r#r$datamaskrditems)rdefaultsr$rtrurdkvs r _fix_defaultsrzYsf LL  E & V[[&:K:KT>r((* :qM GDG + Mr!cU$rr)rFrdrGrprqs r_merge_arrays_dispatcherr|gs r!c l [U5S:Xa[R"US5n[U[R[R 45(aUR nURc[R "SU4/5nU(a[U4SS9U:XawUR5nU(a)U(a[RnO9[RnO(U(a[RnO[RnURXVS9$U4nO&UVs/sHn[R"U5PM nn[!SU55n[#U5n [XS9n /n /n U(Ga[%X5GHiupX- nU R5R'5n[R("U 5R5nU(a[R*"XR 5n[U[R[R 45(an[UR 5S:XaUR-5SnSnOD[R."UU R SS 9n[R0"S UR S 9nOSnSnU R3[4R6"UU/U-55 U R3[4R6"UW/U-55 GMl [![9XS95n[R."[R:"UXS 9[=[9XS95S 9nU(aUR[R5nU$[%X5HupX- nU R5R'5nU(a[R*"XR 5n[U[R[R 45(aM[UR 5S:XaUR-5SnO#[R."UU R SS 9nOSnU R3[4R6"UU/U-55 M [R:"[![9XS95XS 9nU(aUR[R5nU$s snf)a Merge arrays field by field. Parameters ---------- seqarrays : sequence of ndarrays Sequence of arrays fill_value : {float}, optional Filling value used to pad missing data on the shorter arrays. flatten : {False, True}, optional Whether to collapse nested fields. usemask : {False, True}, optional Whether to return a masked array or not. asrecarray : {False, True}, optional Whether to return a recarray (MaskedRecords) or not. Examples -------- >>> import numpy as np >>> from numpy.lib import recfunctions as rfn >>> rfn.merge_arrays((np.array([1, 2]), np.array([10., 20., 30.]))) array([( 1, 10.), ( 2, 20.), (-1, 30.)], dtype=[('f0', '>> rfn.merge_arrays((np.array([1, 2], dtype=np.int64), ... np.array([10., 20., 30.])), usemask=False) array([(1, 10.0), (2, 20.0), (-1, 30.0)], dtype=[('f0', '>> rfn.merge_arrays((np.array([1, 2]).view([('a', np.int64)]), ... np.array([10., 20., 30.])), ... usemask=False, asrecarray=True) rec.array([( 1, 10.), ( 2, 20.), (-1, 30.)], dtype=[('a', '.s,)Q&&)s)r#ndmin)rDr#)r#count)ru)r&rE asanyarrayrUndarrayrVr#r$rIravelrlrmrirjrorkr8maxzip __array__ getmaskarray_check_fill_valueitemarrayonesr7rbchainrgfromiterrO)rFrdrGrprqseqdtypeseqtype_msizes maxlengthr'seqdataseqmaskrHn nbmissingrtrufvalfmskrs rrrlsrd I!MM)A,/ )bjj"''233?? >> !xx"h 01H*i\4@HL!)I"00G nnG++**>>>? ?" I2;;2R]]2& ; ,), ,EE I)5HGG)+FQ"I779&&(D??1%++-D--j''BdRZZ$9::4::!+#yy{1~#!xxAGG1E!wwt4::> NN9??4$)1CD E NN9??4$)1CD E),,]7<="++d(L#M'$KLN [[!3!34F* M%)+FQ"I779&&(D--j''BdRZZ$9::4::!+#yy{1~!xxAGG1E NN9??4$)1CD E,U=#JK#+> [[-F Mu>> import numpy as np >>> from numpy.lib import recfunctions as rfn >>> a = np.array([(1, (2, 3.0)), (4, (5, 6.0))], ... dtype=[('a', np.int64), ('b', [('ba', np.double), ('bb', np.int64)])]) >>> rfn.drop_fields(a, 'a') array([((2., 3),), ((5., 6),)], dtype=[('b', [('ba', '>> rfn.drop_fields(a, 'ba') array([(1, (3,)), (4, (6,))], dtype=[('a', '>> rfn.drop_fields(a, ['ba', 'bb']) array([(1,), (4,)], dtype=[('a', 'URn/nUHRnXnXA;aMURb%T"XQ5nU(aURXF45 M>M@URXE45 MT U$r)r$r7)r?rr$r'r0r)r@ _drop_descrs rr drop_fields.._drop_descr!sl DlG!}}(#G8OOTM20r!rrprq)rsetr#rEemptyshaperrr)rrrprqr'rrs @rrrscFz"" \ _  4::z2H XXdjj 1F "4 0F v: FFr!cUVs/sHoDURU4PM nn[R"URUS9n[ X5n[ XbUS9$s snf)aL Return a new array keeping only the fields in `keep_names`, and preserving the order of those fields. Parameters ---------- base : array Input array keep_names : string or sequence String or sequence of strings corresponding to the names of the fields to keep. Order of the names will be preserved. usemask : {False, True}, optional Whether to return a masked array or not. asrecarray : string or sequence, optional Whether to return a recarray or a mrecarray (`asrecarray=True`) or a plain ndarray or masked array with flexible dtype. The default is False. rr)r#rErrrrr)r keep_namesrprqrr'rs r _keep_fieldsr7sS&-77JqDJJqM"JH7 XXdjj 1F "4 0F v: FF8sAcU4$rrrrs r_rec_drop_fields_dispatcherrPrr!c[XSSS9$)zC Returns a new numpy.recarray with fields in `drop_names` dropped. FTr)rrs rrrTs t4 HHr!cU4$rr)r namemappers r_rename_fields_dispatcherr\rr!cX^U4SjmT"URU5nURU5$)a Rename the fields from a flexible-datatype ndarray or recarray. Nested fields are supported. Parameters ---------- base : ndarray Input array whose fields must be modified. namemapper : dictionary Dictionary mapping old field names to their new version. Examples -------- >>> import numpy as np >>> from numpy.lib import recfunctions as rfn >>> a = np.array([(1, (2, [3.0, 30.])), (4, (5, [6.0, 60.]))], ... dtype=[('a', int),('b', [('ba', float), ('bb', (float, 2))])]) >>> rfn.rename_fields(a, {'a':'A', 'bb':'BB'}) array([(1, (2., [ 3., 30.])), (4, (5., [ 6., 60.]))], dtype=[('A', '/nURHRnURX35nXnURbURUT"XQ545 M@URXE45 MT U$r)r$rPr7)r?rr'r0newnamer)_recursive_rename_fieldss rr/rename_fields.._recursive_rename_fieldsysgLLD nnT0GlG}}(6wKL 23!r!)r#rk)rrr'rs @rrr`s)2 ( J?H 99X r!c#,# Uv UShvN gN7frr)rr$rtdtypesrdrprqs r_append_fields_dispatcherrs JOO c Z[U[[45(a&[U5[U5:wa Sn[ U5eO[U[ 5(aU/nU/nUcaUVs/sHn[ R"USSS9PM nn[X5V Vs/sH"upURXR4/5PM$ nn nO[U[[45(dU/n[U5[U5:wa+[U5S:XaU[U5-nO Sn[ U5e[X!U5VV V s/sH.upn [ R"USSU S9RX4/5PM0 nn nn [XUS9n[U5S:a [USUUS 9nOUR5n[R"[[U5[U55[!UR5[!UR5-S 9n [#X 5n [#X,5n [%XUS 9$s snfs snn fs sn n nf) a Add new fields to an existing array. The names of the fields are given with the `names` arguments, the corresponding values with the `data` arguments. If a single field is appended, `names`, `data` and `dtypes` do not have to be lists but just values. Parameters ---------- base : array Input array to extend. names : string, sequence String or sequence of strings corresponding to the names of the new fields. data : array or sequence of arrays Array or sequence of arrays storing the fields to add to the base. dtypes : sequence of datatypes, optional Datatype or sequence of datatypes. If None, the datatypes are estimated from the `data`. fill_value : {float}, optional Filling value used to pad missing data on the shorter arrays. usemask : {False, True}, optional Whether to return a masked array or not. asrecarray : {False, True}, optional Whether to return a recarray (MaskedRecords) or not. z7The number of arrays does not match the number of namesNT)copysubokrDz5The dtypes argument must be None, a dtype, or a list.)rrr#)rprd)rGrprdrr)rUr8rOr&r%r^rErrrkr#rpopri masked_allrr5rrr) rr$rtrrdrprqmsgrHr0rdrs rrrs@%%'' u:T "KCS/ ! # E3   x ~<@ADqT2DA;>u;KL;Kitww();KL&5$-00ZF t9F #6{a#d)+M o%!$T&!9;!9IQ1T;@@1&J!9 ; * ED 4y1}D$'13xxz ]] CIs4y!TZZ(>$**+EEGF#4 0F "4 0F v: FF7BL;s$ H)H 25H&c#,# Uv UShvN gN7frrrr$rtrs r_rec_append_fields_dispatcherrs JOOrc [XX#SSS9$)a Add new fields to an existing array. The names of the fields are given with the `names` arguments, the corresponding values with the `data` arguments. If a single field is appended, `names`, `data` and `dtypes` do not have to be lists but just values. Parameters ---------- base : array Input array to extend. names : string, sequence String or sequence of strings corresponding to the names of the new fields. data : array or sequence of arrays Array or sequence of arrays storing the fields to add to the base. dtypes : sequence of datatypes, optional Datatype or sequence of datatypes. If None, the datatypes are estimated from the `data`. See Also -------- append_fields Returns ------- appended_array : np.recarray TF)rtrrqrp)rrs rrrs> 4$(% 99r!cU4$rr)rHalignrecurses r_repack_fields_dispatcherrs 4Kr!c[U[R5(d$[URXS9nUR USS9$UR cU$/nUR HUnUR UnU(a[USUSS9nOUSn[U5S:XaUSU4nURXW45 MW [R"XAS9n[R"URU45$) ac Re-pack the fields of a structured array or dtype in memory. The memory layout of structured datatypes allows fields at arbitrary byte offsets. This means the fields can be separated by padding bytes, their offsets can be non-monotonically increasing, and they can overlap. This method removes any overlaps and reorders the fields in memory so they have increasing byte offsets, and adds or removes padding bytes depending on the `align` option, which behaves like the `align` option to `numpy.dtype`. If `align=False`, this method produces a "packed" memory layout in which each field starts at the byte the previous field ended, and any padding bytes are removed. If `align=True`, this methods produces an "aligned" memory layout in which each field's offset is a multiple of its alignment, and the total itemsize is a multiple of the largest alignment, by adding padding bytes as needed. Parameters ---------- a : ndarray or dtype array or dtype for which to repack the fields. align : boolean If true, use an "aligned" memory layout, otherwise use a "packed" layout. recurse : boolean If True, also repack nested structures. Returns ------- repacked : ndarray or dtype Copy of `a` with fields repacked, or `a` itself if no repacking was needed. Examples -------- >>> import numpy as np >>> from numpy.lib import recfunctions as rfn >>> def print_offsets(d): ... print("offsets:", [d.fields[name][1] for name in d.names]) ... print("itemsize:", d.itemsize) ... >>> dt = np.dtype('u1, >> dt dtype({'names': ['f0', 'f1', 'f2'], 'formats': ['u1', '>> print_offsets(dt) offsets: [0, 8, 16] itemsize: 24 >>> packed_dt = rfn.repack_fields(dt) >>> packed_dt dtype([('f0', 'u1'), ('f1', '>> print_offsets(packed_dt) offsets: [0, 1, 9] itemsize: 17 )rrF)rrTr3r) rUrEr#rastyper$r-r&r7r~)rHrrdt fieldinfor0rffmts rrrsz a " " 177% Axxx''wwIhhtn AeTBCa&C s8q=FD>D$% ) )B 88QVVRL !!r!cSn/nURHnURUnUSUSpvU"U5uphURc.UR[R"Xh445XU-45 M`[ XgU-5n UR n [U5HKn U S:XaURU 5 MURU V V Vs/sHupoXX--4PM snn n 5 MM M U$s snn n f)z Returns a flat list of (dtype, count, offset) tuples of all the scalar fields in the dtype "dt", including nested fields, in left to right order. cSnURS:wa5URHnX-nM URnURS:waM5X4$)NrDr)rr)rrrs r count_elem+_get_fields_and_offsets..count_elem_sGhh"n !Bhh"nyr!rrD) r$r-r7rEr#_get_fields_and_offsetsitemsizeranger=)roffsetrr-r0r(f_dtf_offsetr subfieldsrircos rrrVsF $q58hT" ::  MM288T4L116GH I/6GHI==D1X6MM),MMY"OY'!qaf*#5Y"OP " M#PsC,cL[U5S::aU$USUS:nU(a[[U5[U55nO [X5nSnSnUHBupxUS:wa U(a gUcUnXb:wa gXxS- U--n OUn UbXu- n UcU nXj:wa gU nMD U(aU*$U$)z Returns the stride between the fields, or None if the stride is not constant. The values in "counts" designate the lengths of subarrays. Subarrays are treated as many contiguous fields, with always positive stride. rDrN)r&rreversed) offsetscountsrnegativeit prev_offsetstriderr end_offset new_strides r_common_strider{s 7|qqzGAJ&H '"HV$4 5  !K F  A:~!!19"88JJ  "-J~## '*w Mr!cU4$rr)arrr#rcastings r&_structured_to_unstructured_dispatcherr 6Mr!c<^URRc [S5e[UR5n[ U5nUS:XaUc [S5eUS:Xa [ S5e[ U6upgn[U5V s/sHn SRU 5PM n n Uc.[R"UV s/sHoRPM sn 6mO[R"U5m[R"U UUURRS.5n URU 5n[U5[R[R [R"4;n U(GdDU (Ga<[%U4SjU55(Ga!['XTR5nUGbUR(nUR*[-U5TR4-nUR.[1U5S 4-nUS [R24R[R45nUS [7U5S24n[R8R:R=UUUS S 9nURT5S nUS:a US SSS24n[U5[UR>5LaU"U5nU$[R"U UV s/sHn TU R*4PM sn S.5nURAUX#S9nURT[-U5445$s sn fs sn fs sn f)a Converts an n-D structured array into an (n+1)-D unstructured array. The new array will have a new last dimension equal in size to the number of field-elements of the input array. If not supplied, the output datatype is determined from the numpy type promotion rules applied to all the field datatypes. Nested fields, as well as each element of any subarray fields, all count as a single field-elements. Parameters ---------- arr : ndarray Structured array or dtype to convert. Cannot contain object datatype. dtype : dtype, optional The dtype of the output unstructured array. copy : bool, optional If true, always return a copy. If false, a view is returned if possible, such as when the `dtype` and strides of the fields are suitable and the array subtype is one of `numpy.ndarray`, `numpy.recarray` or `numpy.memmap`. .. versionchanged:: 1.25.0 A view can now be returned if the fields are separated by a uniform stride. casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional See casting argument of `numpy.ndarray.astype`. Controls what kind of data casting may occur. Returns ------- unstructured : ndarray Unstructured array with one more dimension. Examples -------- >>> import numpy as np >>> from numpy.lib import recfunctions as rfn >>> a = np.zeros(4, dtype=[('a', 'i4'), ('b', 'f4,u2'), ('c', 'f4', 2)]) >>> a array([(0, (0., 0), [0., 0.]), (0, (0., 0), [0., 0.]), (0, (0., 0), [0., 0.]), (0, (0., 0), [0., 0.])], dtype=[('a', '>> rfn.structured_to_unstructured(a) array([[0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.]]) >>> b = np.array([(1, 2, 5), (4, 5, 7), (7, 8 ,11), (10, 11, 12)], ... dtype=[('x', 'i4'), ('y', 'f4'), ('z', 'f8')]) >>> np.mean(rfn.structured_to_unstructured(b[['x', 'z']]), axis=-1) array([ 3. , 5.5, 9. , 11. ]) Narr must be a structured arrayrz(arr has no fields. Unable to guess dtypez#arr with no fields is not supportedf{}r$formatsrrc3@># UHoRT:Hv M g7fr)r)r/r out_dtypes rr1-structured_to_unstructured.. s&Jcww)';csrD.T)r.rr$rrr)!r#r$r%rr&NotImplementedErrorrrformatrE result_typerrrkr~rromemmapallr__array_wrap__rsumstridesabsnewaxisuint8minlib stride_tricks as_strided__self__r)rr#rrr-n_fieldsdtsrrrr$rflattened_fieldscan_view common_stridewrap new_shape new_strides packed_fieldsrs @rrrsx yy9:: $SYY /F6{H1}CDD Q!"GHH<C&+Ho 6oU\\!_oE 6 }NNs$;sWWs$;< HHUO xx%,/,3-0YY-?-?!AB ((# $C CyRZZbii@@H h3&Jc&J#J#J'w 8J8JK  $%%D S[)2D2D$EEI++]);Q(??Kc2::o&++BHH5Cc3w<=()C&&&&11#2;2=8<2>C ((9%f-Cq #tt)nCyT]] 333iJHHuJM)N#B9bhh*?#)NPQM **]* ?C 88YV/ 00q 7%>> import numpy as np >>> from numpy.lib import recfunctions as rfn >>> dt = np.dtype([('a', 'i4'), ('b', 'f4,u2'), ('c', 'f4', 2)]) >>> a = np.arange(20).reshape((4,5)) >>> a array([[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 9], [10, 11, 12, 13, 14], [15, 16, 17, 18, 19]]) >>> rfn.unstructured_to_structured(a, dt) array([( 0, ( 1., 2), [ 3., 4.]), ( 5, ( 6., 7), [ 8., 9.]), (10, (11., 12), [13., 14.]), (15, (16., 17), [18., 19.])], dtype=[('a', '>> import numpy as np >>> from numpy.lib import recfunctions as rfn >>> b = np.array([(1, 2, 5), (4, 5, 7), (7, 8 ,11), (10, 11, 12)], ... dtype=[('x', 'i4'), ('y', 'f4'), ('z', 'f8')]) >>> rfn.apply_along_fields(np.mean, b) array([ 2.66666667, 5.33333333, 8.66666667, 11. ]) >>> rfn.apply_along_fields(np.mean, b[['x', 'z']]) array([ 3. , 5.5, 9. , 11. ]) rr)axis)r#r$r%r)rruarrs rrrs6H yy9:: %c *D 2 r!cX4$rr)dstsrczero_unassigneds r!_assign_fields_by_name_dispatcherr&s 8Or!cURRcXS'gURRH<nX1RR;aU(aSX'M)M+[XXU5 M> g)az Assigns values from one structured array to another by field name. Normally in numpy >= 1.14, assignment of one structured array to another copies fields "by position", meaning that the first field from the src is copied to the first field of the dst, and so on, regardless of field name. This function instead copies "by field name", such that fields in the dst are assigned from the identically named field in the src. This applies recursively for nested structures. This is how structure assignment worked in numpy >= 1.6 to <= 1.13. Parameters ---------- dst : ndarray src : ndarray The source and destination arrays during assignment. zero_unassigned : bool, optional If True, fields in the dst for which there was no matching field in the src are filled with the value 0 (zero). This was the behavior of numpy <= 1.13. If False, those fields are not modified. N.r)r#r$r)r#r$r%r0s rrrs`4 yyC  yy &  "#)SY"1 3  r!cU4$rr)rrequired_dtypes r_require_fields_dispatcherr*s 8Or!cZ[R"URUS9n[X 5 U$)a Casts a structured array to a new dtype using assignment by field-name. This function assigns from the old to the new array by name, so the value of a field in the output array is the value of the field with the same name in the source array. This has the effect of creating a new ndarray containing only the fields "required" by the required_dtype. If a field name in the required_dtype does not exist in the input array, that field is created and set to 0 in the output array. Parameters ---------- a : ndarray array to cast required_dtype : dtype datatype for output array Returns ------- out : ndarray array with the new dtype, with field values copied from the fields in the input array with the same name Examples -------- >>> import numpy as np >>> from numpy.lib import recfunctions as rfn >>> a = np.ones(4, dtype=[('a', 'i4'), ('b', 'f8'), ('c', 'u1')]) >>> rfn.require_fields(a, [('b', 'f4'), ('c', 'u1')]) array([(1., 1), (1., 1), (1., 1), (1., 1)], dtype=[('b', '>> rfn.require_fields(a, [('b', 'f4'), ('newf', 'u1')]) array([(1., 0), (1., 0), (1., 0), (1., 0)], dtype=[('b', '>> import numpy as np >>> from numpy.lib import recfunctions as rfn >>> x = np.array([1, 2,]) >>> rfn.stack_arrays(x) is x True >>> z = np.array([('A', 1), ('B', 2)], dtype=[('A', '|S3'), ('B', float)]) >>> zz = np.array([('a', 10., 100.), ('b', 20., 200.), ('c', 30., 300.)], ... dtype=[('A', '|S3'), ('B', np.double), ('C', np.double)]) >>> test = rfn.stack_arrays((z,zz)) >>> test masked_array(data=[(b'A', 1.0, --), (b'B', 2.0, --), (b'a', 10.0, 100.0), (b'b', 20.0, 200.0), (b'c', 30.0, 300.0)], mask=[(False, False, True), (False, False, True), (False, False, False), (False, False, False), (False, False, False)], fill_value=(b'N/A', 1e+20, 1e+20), dtype=[('A', 'S3'), ('B', ' ''rzf%ir)rUrErr&rrr#r$r5r7indexr TypeErrorri concatenaterrcumsumr_rrrrz)r.rwrprqr/rHrFnrecordsr?rfldnamesdtype_lnewdescrrr$dtype_nfnamefdtypenameidxrBcdtyperrseenrjr0s rrr,slT&"**%% V ay39:6aq!'')6I: )* 1A H*( )y!ggyF )!'(AH(QiGg&H# $841Q8E $!":+G4ME6E!0 U#++e,$W- 6).FF0C(DHW%v%#%+V%5665 8} *x 02H=255H-. VCR[&*MLQ1aGGMME}12us4y()!A.D()$F4L1%4' D) N }VX6& ??O;* )( %s.J.J  J$JJcU4$rr)rHkey ignoremask return_indexs r_find_duplicates_dispatcherrGs 4Kr!c[R"U5R5n[UR5nUnU(aXAHnXVnM XQnUR 5nXWnUR 5n U SSU SS:Hn U(aURn SXSS'[R"S/U 45n U SSU SS-U SS&XU n U(aXU 4$U $)a Find the duplicates in a structured array along a given key Parameters ---------- a : array-like Input array key : {string, None}, optional Name of the fields along which to check the duplicates. If None, the search is performed by records ignoremask : {True, False}, optional Whether masked data should be discarded or considered as duplicates. return_index : {False, True}, optional Whether to return the indices of the duplicated values. Examples -------- >>> import numpy as np >>> from numpy.lib import recfunctions as rfn >>> ndtype = [('a', int)] >>> a = np.ma.array([1, 1, 1, 2, 2, 3, 3], ... mask=[0, 0, 1, 0, 0, 0, 1]).view(ndtype) >>> rfn.find_duplicates(a, ignoremask=True, return_index=True) (masked_array(data=[(1,), (1,), (2,), (2,)], mask=[(False,), (False,), (False,), (False,)], fill_value=(999999,), dtype=[('a', '>E7D/ *DSb DH$D"ID!JDM**r!c X4$rr) rDr1r2jointype r1postfix r2postfixrwrprqs r_join_by_dispatcherrW  8Or!c  ^US;a[SU-5e[T[5(aT4m[[ T55[T5:wa,[ U4Sj[ T555n [SU -5eTHQn XRR;a[SU -5eXRR;dME[SU -5e UR5nUR5n[U5n URRURRp[ U 5[ U 5-[ T5- nU(a U(dU(dSnUS- n[U5eU Vs/sH nUT;dM UPM nn[UU5n[UU5n[R"UU45nURTS 9nUUn[R"S /US S US S :H45nUS S US S -US S &UUnUUU :nUUU :U - n[U5[U5nnUS:XaSunnOUS:XabUU)n[R"UUUU :45n[R"UUUU :U - 45n[U5U- [U5U- nnO:US:Xa4UU)n[R"UUUU :45n[U5U- SnnUUUUn n[UR5n![UR5H!un"n#U"T;dMU!R!U"U#45 M# [UR5H_un"n#[#SU!55n$U$R%U"5n%U!U%un&n'U"T;aU"['U#U'54U!U%'MKU"U-U'4U"U-U#4/U!U%U%S -&Ma [R"U!5n!['UU5n([R("U(W-W-4U!S9n)U)RRn$U HFn*UU*n+U*U$;dU*U ;aU(d U*T;aU*U- n*U)U*n,U+S UU,S U&US;dM;U+US U,U(U(U-&MH U HMn*U U*n+U*U$;dU*U ;aU(d U*T;aU*U- n*U)U*n,U+S UU,S U&US:XdM;U(dMDU+US U,U*S &MO U)R+TS 9 [-XxS9n-[/[1U)U540U-D6$s snf![a U!R!U"U#45 GMf=f)a Join arrays `r1` and `r2` on key `key`. The key should be either a string or a sequence of string corresponding to the fields used to join the array. An exception is raised if the `key` field cannot be found in the two input arrays. Neither `r1` nor `r2` should have any duplicates along `key`: the presence of duplicates will make the output quite unreliable. Note that duplicates are not looked for by the algorithm. Parameters ---------- key : {string, sequence} A string or a sequence of strings corresponding to the fields used for comparison. r1, r2 : arrays Structured arrays. jointype : {'inner', 'outer', 'leftouter'}, optional If 'inner', returns the elements common to both r1 and r2. If 'outer', returns the common elements as well as the elements of r1 not in r2 and the elements of not in r2. If 'leftouter', returns the common elements and the elements of r1 not in r2. r1postfix : string, optional String appended to the names of the fields of r1 that are present in r2 but absent of the key. r2postfix : string, optional String appended to the names of the fields of r2 that are present in r1 but absent of the key. defaults : {dictionary}, optional Dictionary mapping field names to the corresponding default values. usemask : {True, False}, optional Whether to return a MaskedArray (or MaskedRecords is `asrecarray==True`) or a ndarray. asrecarray : {False, True}, optional Whether to return a recarray (or MaskedRecords if `usemask==True`) or just a flexible-type ndarray. Notes ----- * The output is sorted along the key. * A temporary array is formed by dropping the fields not in the key for the two arrays and concatenating the result. This array is then sorted, and the common entries selected. The output is constructed by filling the fields with the selected entries. Matching is not preserved if there are some duplicates... )innerouter leftouterzWThe 'jointype' argument should be in 'inner', 'outer' or 'leftouter' (got '%s' instead)c3H># UHupUTUS-S;dMUv M g7f)rDNr)r/rxrDs rr1join_by.. s%A!s1Q34y.11s" "zduplicate join key %rzr1 does not have key field %rzr2 does not have key field %rz8r1 and r2 contain common names, r1postfix and r2postfix zcan't both be empty)orderFrDNrrZ)rrr[r\rc3*# UH upUv M g7frrr.s rr1r_Ns4VkdTVsr)r[r\r)r%rUr^r&rnext enumerater#r$rrrir5rIrEr5r7rOr3rrsortdictrrrz).rDrRrSrTrUrVrwrprqdupr0nb1r1namesr2names collisionsrrkey1r1kr2kauxidx_sortflag_inidx_inidx_1idx_2r1cmnr2cmnr1spcr2spcidx_outs1s2r?r=r>r$r?rBr@cmnrr4selectedr)kwargss.` rrrsFh66<>FG  #sf 3s8}C A #AA03677 xx~~ %a7l9# NA)"6E*  UU'/GUFG  KKcK ' 9F }VX6 A& AAs .\ + MM5&/ * * +s6 SS#SS54S5cX4$rr)rDrRrSrTrUrVrws r_rec_join_dispatcherrrXr!c 6[X4UUSSS9n[XU40UD6$)z Join arrays `r1` and `r2` on keys. Alternative to join_by, that always returns a np.recarray. See Also -------- join_by : equivalent function FT)rTrUrVrwrprq)rer)rDrRrSrTrUrVrwr}s rrrs,8I#UtEF 3B )& ))r!)F)NN)NT)TFr)NNNN)rFFF)NrTF)FF)r)NNN)NFunsafe)NNNNN)NNFFr)T)NTFF)NTF)NNNNNN)rZ12NTF)rZrrN)?__doc__rbnumpyrEnumpy.marinumpy.ma.mrecordsmrecordsrlnumpy._core.overridesrnumpy.lib._iotoolsr__all__r rr5r r r rIrLr rWr_rgrrrzr|rrrrrrrrrrrrrrrrrrrrrrr&rr*rr0rrGr rWrrrrr!rrs 9. :;$<$N @BB6  8-`   "0" BF6: 1238+0E3EP01:G2:GzG245I6I23%4%P9=HL 23,0:?CG4CGL 67989D23Q"4Q"f#J*ZBF37?@1A1DCGJN?@BG3;i'Ai'V78'9'V:;#3<#3J34)5)X=A:> 12AF"U?3U?r48 45767v?C04 ,-DG49pB.pBh?C -.EH */ *r!