wN n d Z ddlZddlZddlmZ ddlmZmZ ddlmZ ddl m
Z
ddl m Z ddl
mZ ej j j Zg dZd Z e e d
Zd Zd Zd
Zd ZdAdZdAdZdBdZd Zd Z dCdZ dDdZ dEdZ dFdZ e e dGd Z!dBd Z" e e" dDd Z#dDd Z$d Z% e e% d Z&d! Z' e e' d" Z( dFd#Z) e e) dHd$ Z*dEd%Z+ e e+ dEd& Z,dBd'Z- e e- dId( Z.dJd)Z/d* Z0 dKd+Z1 e e1 dLd- Z2 dMd.Z3 e e3 dNd/ Z4d0 Z5 e e5 d1 Z6dEd2Z7 e e7 dOd3 Z8d4 Z9 e e9 d5 Z: dFd6Z; e e; dPd7 Z< dKd8Z= e e= dQd9 Z> dRd:Z? e e? dSd> Z@ dFd?ZA e eA dTd@ ZBdS )Uz
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)ndarrayrecarray) MaskedArray)
MaskedRecords)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_structuredc
| |fS N )inputoutputs j/builddir/build/BUILD/cloudlinux-venv-1.0.10/venv/lib64/python3.11/site-packages/numpy/lib/recfunctions.py!_recursive_fill_fields_dispatcherr$ s 6? c |j }|j D ]Y} | | }n# t $ r Y w xY w|j j t ||| ?||| dt | < Z|S )aj
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
--------
>>> 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', '>> dt = np.dtype([(('a', 'A'), np.int64), ('b', np.double, 3)])
>>> dt.descr
[(('a', 'A'), '>> _get_fieldspec(dt)
[(('a', 'A'), dtype('int64')), ('b', dtype(('z!_get_fieldspec..a s/ EE4 d+,EEEEEEr% c b g | ],\ }}t | d k r|n |d |f|d f-S ) r r* )r3 r4 fs r#
z"_get_fieldspec..c sO
a VVq[[TTqtTlAaD 9
r% r( )r' r1 s ` r# _get_fieldspecr< J sU &
{U } EEEEEEE
!
r% c g }| j }|D ]X}| | }|j 2| |t t | f C| | Yt | S )aG
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
--------
>>> 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( r4 r- s r# r r i s * I LE # #, = $ dE)G*<*<$=$= > ? ? ? ? T " " " " r% c g }| j }|D ]H}| | | | }|j "| t | It | S )a
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
--------
>>> 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( r> extendr r? r@ s r# r r so , I LE 6 6 , = $ ^G 4 4 5 5 5 r% c | j }|d| ffS g }|D ]S}| j | \ }}|j #| t | <| ||f Tt | S )aD
Flatten a structured data-type description.
Examples
--------
>>> from numpy.lib import recfunctions as rfn
>>> ndtype = np.dtype([('a', '>> rfn.flatten_descr(ndtype)
(('a', dtype('int32')), ('ba', dtype('float64')), ('bb', dtype('int32')))
Nr/ )r( r1 rD r r> r? )ndtyper( descrr, typ_s r# r r s
LE }V + +E }U+HS!y$ ]3 / /0000 eS\****U||r% Fc V g }|r-| D ])}| t |j *ne| D ]b}|j }|j ;t |j dk r#| t | K| d|f ct j | S )N r/ )rD r r' r( r* r< r> np) seqarraysflattenr+ ar- s r#
_zip_dtyperP s H
/ 4 4A OOM!' 2 2 3 3 3 3 4 / /AgG}(S -?-?1-D-Dw 7 78888W
....
8H r% c . t | | j S )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.
rN )rP rG )rM rN s r#
_zip_descrrS s i 1 1 1 77r% c 6 |i }| j }|D ]}| | }|j 3|r|g||< ng ||< | t ||| Dd | |g pg D }|r| | n|r|g}|pg ||< |S )ab
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 interbally during recursion).
Examples
--------
>>> 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']}
Nc g | ]}|S r r )r3 rI s r# r: z&get_fieldstructure.. s GGG!GGGr% )r( updater getr> )rA lastnameparentsr( r4 r-
lastparents r# r r s 4 LE - -, = $
#!)
"
NN-gtWEE F F F FGGgkk(B&?&?&E2GGGJ
*!!(++++
* &\
& ,"GDMM Nr% c # K | D ]C}t |t j r#t t | E d{V ?|V DdS )zu
Returns an iterator of concatenated fields from a sequence of arrays,
collapsing any nested structure.
N)
isinstancerL void_izip_fields_flatr? iterableelements r# r^ r^ si grw ' ' (w 88 8 8 8 8 8 8 8 8MMMM r% c # 2 K | D ]}t |d r+t |t st | E d{V =t |t j r6t
t | dk rt | E d{V |V dS )zP
Returns an iterator of concatenated fields from a sequence of arrays.
__iter__NrK )hasattrr\ str _izip_fieldsrL r] r* r? r_ s r# rf rf s
GZ ( ( w,, #G,, , , , , , , , ,
)
) c%...A.AQ.F.F#G,, , , , , , , , ,MMMM r% Tc # K |rt }nt }t j | d|iD ] }t || V dS )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)r^ rf itertools zip_longestr? )rM
fill_valuerN zipfunctups r#
_izip_recordsrn - sd # $iF:FF " "GGCLL!!!!!!" "r% c t | t sd}|r |r| t } n0t j | } |r| t } | S )z
Private function: return a recarray, a ndarray, a MaskedArray
or a MaskedRecords depending on the input parameters
F)r\ r viewr mafilledr )r" usemask
asrecarrays r# _fix_outputru E sj
fk * * + 0[[ //F6"" +[[**F Mr% c | j j }| j | j | j }}}|pi D ] \ }}||v r|||< ||| || < | S )zp
Update the fill_value and masked data of `output`
from the default given in a dictionary defaults.
)r' r( datamaskrk items)r" defaultsr( rw rx rk kvs r#
_fix_defaultsr} V so
L E & V[&:K4T>r((** ! !A :: JqM DGDG Mr% c | S r r )rM rk rN rs rt s r# _merge_arrays_dispatcherr d s r% c t | dk rt j | d } t | t t j f r| j }|j t j d|fg }|rt | fd |k rP| } |r|rt }nt }n|rt }nt }|
|| S | f} n d | D } t d | D }t | }t | | } g }
g } |rt! | | D ]X\ } }
||
z
}| }t% j | }|rt) || j }t |t t j f rlt |j dk r | d }d}n>> 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" ;;;2R]2&&;;;r% c 3 $ K | ] }|j V d S r )sizer3 rO s r# r5 z merge_arrays.. s$ ,,Q!&,,,,,,r% )r' ndmin)rK r' )r' count)rx ) r* rL r r\ r r] r' r( rP ravelr r r rp r? maxzip __array__rq getmaskarray_check_fill_valueitemarrayonesr> ri chainrn fromiterlist)rM rk rN rs rt seqdtypeseqtypesizes maxlengthr+ seqdataseqmaskrO n nbmissingrw rx fvalfmskr" s r# r r i s1 b I!M)A,// )grw /00 < ? > !x"h 011H %*i\4@@@HLL!))I
" * +GG )GG
""! >>w>?? ?" II <;;;; ,,),,, , ,EE
I)W555HGG .+)U++ F FFQ"Q I7799&&((D?1%%++--D
(QW== dWbg$677 ?4:!++ #yy{{1~ # !xAG1 E E E !wt4: > > > NN9?4$)1CDD E E E NN9?4$)1CDD E E E E]7G<<<=="+d()LLL #M'7$K$K$K L LN N N 0[[ //F )U++ F FFQ"Q I7799&&((D
(QW== dWbg$677 F4:!++ #yy{{1~ !xAG1 E E E NN9?4$)1CDD E E E EU='#J#J#J K K#+9> > > +[[**F Mr% c | fS r r )base
drop_namesrs rt s r# _drop_fields_dispatcherr 7Nr% c t | r|g}nt | }fd | j | }t j | j | }t
| | }t ||| S )a
Return a new array with fields in `drop_names` dropped.
Nested fields are supported.
.. versionchanged:: 1.18.0
`drop_fields` returns an array with 0 fields if all fields are dropped,
rather than returning ``None`` as it did previously.
Parameters
----------
base : array
Input array
drop_names : string or sequence
String or sequence of strings corresponding to the names of the
fields to drop.
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.
Examples
--------
>>> 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', ' )rF r r( r+ r4 r- rG _drop_descrs r# r z drop_fields.._drop_descr s 1 1D TlGz!!}(# GZ88 3 OOT5M222w0000r% r rs rt )r setr' rL emptyshaper ru )r r rs rt r+ r" r s @r# r r s L z"" % \
__
{4:z22H
Xdj
1
1
1F
"4
0
0F vw: F F FFr% c fd|D }t j j | }t | }t ||| S )a
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.
c . g | ]}|j | fS r r )r3 r r s r# r: z _keep_fields..I s$ 777qDJqM"777r% r r )rL r r r ru )r
keep_namesrs rt r+ r" s ` r# _keep_fieldsr 6 sX & 8777J777H
Xdj
1
1
1F
"4
0
0F vw: F F FFr% c | fS r r r r s r# _rec_drop_fields_dispatcherr O r r% c ( t | |dd S )zK
Returns a new numpy.recarray with fields in `drop_names` dropped.
FTr )r r s r# r r S s
tZ4 H H HHr% c | fS r r )r
namemappers r# _rename_fields_dispatcherr [ r r% c Z fd | j | }| | S )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
--------
>>> 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', ' )rF r r+ r4 newnamer- _recursive_rename_fieldss r# r z/rename_fields.._recursive_rename_fieldsw s L 4 4D nnT400G TlG}( 6 6w
K KL ' 23333r% )r' rp )r r r+ r s @r# r r _ sD 0 ('
J??H 99X r% c # " K | V |E d {V d S r r )r r( rw dtypesrk rs rt s r# _append_fields_dispatcherr s$
JJJOOOOOOOOOr% c t |t t f r2t | t | k rd}t | nt |t
r|g}|g}|'d |D }d t
|| D }nt |t t f s|g}t | t | k r7t | dk r|t | z }nd}t | d t
||| D }t | || } t | dk rt |d ||
}n| }t j
t t | t | t | j
t |j
z }t | | }t || }t ||| S )
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 namesNc < g | ]}t j |d d S )FT)copysubok)rL r r s r# r: z!append_fields.. s) BBBd333BBBr% c N g | ]"\ }}| ||j fg #S r )rp r' )r3 r4 rO s r# r: z!append_fields.. s1 LLLitQqw())LLLr% rK z5The dtypes argument must be None, a dtype, or a list.c r g | ]4\ }}}t j |d d| ||fg 5S )FT)r r r' )rL r rp )r3 rO r ds r# r: z!append_fields.. sU ; ; ; Q1 d!<<<AAAq6(KK ; ; ;r% )rs rk T)rN rs rk r r )r\ r? r r* r) re r r poprq
masked_allr r< r' r ru ) r r( rw r rk rs rt msgr" s r# r r s @ %% '' u::T " "KC S// ! #
E3 x
~BBTBBBLL3ud;K;KLLL&5$-00 ZF t99F # #6{{a #d))+M oo%; ;!$T5&!9!9; ; ; g* E E ED
4yy1}}D$'13 3 3 xxzz
] CIIs4yy!! TZ((>$*+E+EEG G GF #4
0
0F
"4
0
0F vw: F F FFr% c # " K | V |E d {V d S r r r r( rw r s r# _rec_append_fields_dispatcherr s$
JJJOOOOOOOOOr% c , t | |||dd S )aM
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)rw r rt rs )r r s r# r r s( > u4$(% 9 9 9 9r% c | fS r r )rO alignrecurses r# _repack_fields_dispatcherr s
4Kr% c t | t j s.t | j || }| |d S | j | S g }| j D ]f}| j | }|rt |d |d }n|d }t | dk r
|d |f}| ||f gt j || }t j | j |f S )
a
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
--------
>>> 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
)r r F)r Nr T r7 r )
r\ rL r' r astyper( r1 r* r> r )rO r r dt fieldinfor4 rm fmts r# r r s x a " " (
17%
A
A
Axxx'''wI
&
&htn AeTBBBCCa&C s88q==FD>D$%%%% )5 ) ) )B
8QVRL ! !!r% c
d }g }| j D ]}| j | }|d |d }} || \ }}|j 1| t j ||ff |||z f et |||z } |j t | D ]@
dk r| | |
fd| D A|S )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.
c f d}| j dk r!| j D ]}||z }| j } | j dk !| |fS )NrK r )r r )r r r s r#
count_elemz+_get_fields_and_offsets..count_elem\ sN h"nn
B h"nn 5yr% r rK Nc . g | ]\ }}}|||z z fS r r )r3 r coir s r# r: z+_get_fields_and_offsets..u s. "O"O"O'!QAq!af*#5"O"O"Or% ) r( r1 r> rL r' _get_fields_and_offsetsitemsizerangerD ) r offsetr r1 r4 r, f_dtf_offsetr subfieldsr r s @@r# r r S s F Q Q $ q58h *T""a : MM28TA4L111h6GH I I I I/h6GHHI=D1XX
Q
Q66MM),,,,MM"O"O"O"O"OY"O"O"OPPPP
Q Mr% c h t | dk r|S | d | d k }|r+t t | t | }nt | | }d}d}|D ]A\ }}|dk r |r dS ||}||k r dS ||dz
|z z } n|} |||z
}
||
}||
k r dS | }B|r| S |S )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.
rK r N)r* r reversed) offsetscountsr negativeit prev_offsetstrider r
end_offset
new_strides r# _common_strider x s 7||qqzGAJ&H "
'""HV$4$4
5
5
&
!
!K
F ! !
A::
tt~!!!tt 519"88JJ J " +-J~###tt w Mr% c | fS r r )arrr' r castings r# &_structured_to_unstructured_dispatcherr 6Mr% unsafec | j j t d t | j }t | }|dk r|t d |dk rt d t
| \ }}}d t | D } |t j d |D nt j | t j | ||| j j
d }
| |
} t | t j
t j t j fv } |sF| rCt! fd |D r't# ||j
} | | j }
| j t) | j
fz }| j t- | d
fz }| d t j f t j } | d t3 | df } t j j | ||d
} | d } | dk r
| d dddf } t | t |
j ur |
| } | S t j | fd|D d }| ||| } | t) | ff S )aW
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 `np.ndarray`, `np.recarray`
or `np.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
--------
>>> 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. ])
N arr must be a structured arrayr z(arr has no fields. Unable to guess dtypez#arr with no fields is not supportedc 8 g | ]}d | S zf{}formatr3 r s r# r: z.structured_to_unstructured.. s" 6 6 6U\\!__ 6 6 6r% c g | ] }|j
S r r )r3 r s r# r: z.structured_to_unstructured.. s $;$;$;RW$;$;$;r% r( formatsr r c 3 . K | ]}|j k V d S r r r3 r out_dtypes r# r5 z-structured_to_unstructured.. s* &J&Jrw)';&J&J&J&J&J&Jr% rK .T)r .r r c " g | ] }|j f S r )r r s r# r: z.structured_to_unstructured..$ s )N)N)NB9bh*?)N)N)Nr% r( r r r ) r' r( r) r r* NotImplementedErrorr r rL result_typer rp r r r memmapallr __array_wrap__r sumstridesabsnewaxisuint8minlib
stride_tricks
as_strided__self__r )r r' r r r1 n_fieldsdtsr r r( flattened_fieldscan_view
common_stridewrap new_shape new_strides
packed_fieldsr s @r# r r s v y 9:::
$SY
/
/F6{{H1}} CDDD Q !"GHHH <C 6 6eHoo 6 6 6E }N$;$;s$;$;$;< HUOO x%,/,3-0Y-?!A !A B B ((#
$
$C
CyyRZbi @@H h 3&J&J&J&Jc&J&J&J#J#J 'w 8JKK
$%D S[[)2D$EEI +]););Q(??Kc2:o&++BH55Cc3w<<==()C&&11#2;2=8< 2 > >C ((9%%f-C q #ttt)nCyyT] 3 333 d3iiJ Hu)N)N)N)N#)N)N)N P P Q QM
**]w*
?
?C 88YV/ 0 00r% c | fS r r )r r' r( r r r s r# &_unstructured_to_structured_dispatcherr# + r r% c j dk rt d j d }|dk rt d |Z|d t | D }t j fd|D | }t
| }t | \ } }
} n|t d
t j | }t
| }t | dk rg g g } }
} n
t | \ } }
} |t |
k rt d |}|r|j
st d d
t t | D }t j | fd| D d } t j | t j || | |j
d }
|
|| | d S )a
Converts an n-D unstructured array into an (n-1)-D structured array.
The last dimension of the input array is converted into a structure, with
number of field-elements equal to the size of the last dimension of the
input array. By default all output fields have the input array's dtype, but
an output structured dtype with an equal number of fields-elements can be
supplied instead.
Nested fields, as well as each element of any subarray fields, all count
towards the number of field-elements.
Parameters
----------
arr : ndarray
Unstructured array or dtype to convert.
dtype : dtype, optional
The structured dtype of the output array
names : list of strings, optional
If dtype is not supplied, this specifies the field names for the output
dtype, in order. The field dtypes will be the same as the input array.
align : boolean, optional
Whether to create an aligned memory layout.
copy : bool, optional
See copy argument to `numpy.ndarray.astype`. If true, always return a
copy. If false, and `dtype` requirements are satisfied, a view is
returned.
casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
See casting argument of `numpy.ndarray.astype`. Controls what kind of
data casting may occur.
Returns
-------
structured : ndarray
Structured array with fewer dimensions.
Examples
--------
>>> 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', '.p s" <<<U\\!__<<.q s < < <q#)n < < . s" 9 9 9U\\!__ 9 9 9r% c , g | ]}j |j fS r )r' r )r3 r r s r# r: z.unstructured_to_structured.. s" )N)N)NB39bh*?)N)N)Nr% r r r r )r r) r
r rL r' r r r* r isalignedstructascontiguousarrayrp r r )r r' r( r r r n_elemr r1 r r r r! r s ` r# r r / s= p yB?@@@
Yr]F
{{!"JKKK } =<>> 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. ])
Nr r )axis)r' r( r) r )r- r uarrs r# r
r
s@ F y 9::: %c * *D 42 r% c
| |fS r r )dstsrczero_unassigneds r# !_assign_fields_by_name_dispatcherr6 s 8Or% c | j j || d< dS | j j D ]5}||j j vr|rd| |< t | | || | 6dS )a
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 )r3 r4 r5 r4 s r# r r s 4 y C 3 3 sy & &
D !#d)SY"1
3
3
3
3 3 3r% c | fS r r )r required_dtypes r# _require_fields_dispatcherr: s 8Or% c \ t j | j | }t || |S )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
--------
>>> 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', '>> 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', 1.e+20, 1.e+20),
dtype=[('A', 'S3'), ('B', '.R s. :::a q!!'')):::r% c , g | ]}t | S r r8 r s r# r: z stack_arrays..S s ***1A***r% c g | ] }|j
S r r r s r# r: z stack_arrays..T s
)
)
)!ag
)
)
)r% c g | ] }|j
S r r; )r3 r s r# r: z stack_arrays..U s (((A(((r% c g | ]\ }}|S r r )r3 r r s r# r: z stack_arrays..Y s $ $ $41aQ $ $ $r% NzIncompatible type 'z' <> ''r zf%ir )r\ r r* r< r> indexr TypeErrorrq concatenater rL r cumsumr_r r' r( ru r} )r> rz rs rt r? rM nrecordsrF fldnamesdtype_lnewdescrr( dtype_nfnamefdtypenameidxrI cdtyper" r seenrO r r jr4 s r# r r % s R &'""
V ay::6:::I** ***H
)
)y
)
)
)F(((((HQiG g&&H $ $8 $ $ $E!"": 6 6 +G 4 4 6 6ME6E!!000 U#### ++e,, $W - 6 6).FF0C0C(DHW%%v%%#)%+VVVVV%5 6 6 6 & 6 8}} ** x 0 0 2H==25H-.. 8VCRC[&* M M * *LQ1aGME}12us4yy()!A#.. * *D()$F4L1%4'' D)))*
}VX66 &: ? ? ? ?r% c | fS r r )rO key
ignoremask return_indexs r# _find_duplicates_dispatcherr\ } s
4Kr% c t j | } t | j }| }|r|| D ]
}|| } || }| }|| }| } | dd | dd k }
|r|j } d|
| dd < t j dg|
f }
|
dd |
dd z |
dd< | | |
} |r
| ||
fS | S )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
--------
>>> 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/ * *DSbS DH$D"I7D!J GDM**r% c
||fS r r ) rY r1r2jointype r1postfix r2postfixrz rs rt s r# _join_by_dispatcherrl
8Or% inner12c
|dvrt d|z t t r f t t t k r:t fdt
D } t d| z D ]B}
|
|j j vrt d|
z |
|j j vrt d|
z C| }| }t | } |j j |j j }
} t | t |
z t z
}|r|s|sd}|dz
}t | fd | D }t || }t || }t j ||f }|
}|| }t j d g|d d
|d
d k f }|d d
|d
d z |d
d< || }||| k }||| k | z
}t | t | }}|dk rd\ }} n|dk rq|| } t j || | | k f }t j || | | k | z
f }t | |z
t | |z
} }nC|dk r=|| } t j || | | k f }t | |z
d} }|| || } } t |j } t |j D ] \ }!}"|! vr| |!|"f !t |j D ]\ }!}"t# d | D }# |# |! }$| |$ \ }%}&|! v r|!t' |"|& f| |$< Y|!|z |&f|!|z |"fg| |$|$d z < p# t $ r | |!|"f Y w xY wt j | } t' || }'t j |'|z | z f| }(|(j j }#| D ]J})| |) }*|)|#vs
|)|
v r |s |) vr|)|z
})|(|) }+|*d
| |+d
|< |dv r|*|d
|+|'|'|z < K|
D ]L})| |) }*|)|#vs
|)| v r |s |) vr|)|z
})|(|) }+|*d
| |+d
|< |dk r| r|*|d
|+| d
< M|(
t- || },t/ t1 |(| fi |,S )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...
)rn outer leftouterzWThe 'jointype' argument should be in 'inner', 'outer' or 'leftouter' (got '%s' instead)c 3 @ K | ]\ }}||d z d v |V dS )rK Nr )r3 r xrY s r# r5 zjoin_by.. s7 AA1!s1Q344y..1....AAr% zduplicate join key %rz r1 does not have key field %rz r2 does not have key field %rz8r1 and r2 contain common names, r1postfix and r2postfix zcan't both be emptyc g | ]}|v | S r r )r3 r rY s r# r: zjoin_by.. s - - -1188Q888r% )orderFrK Nr rn )r r rr rs r c 3 K | ] \ }}|V
d S r r r2 s r# r5 zjoin_by..E s& 44kdET444444r% r )rr rs r )r) r\ re r* r next enumerater' r( r r rq rJ r^ rL r< r> r rH r r sortdictru r} )-rY rg rh ri rj rk rz rs rt dupr4 nb1r1namesr2names
collisionsr key1r1kr2kauxidx_sortflag_inidx_inidx_1idx_2r1cmnr2cmnr1spcr2spcidx_outs1s2rF rR rS r( rT rI rU cmnr" r9 selectedr- kwargss- ` r# r r sT h 666<>FG
#s f 3s88}}C AAAA #AAAAA036777 E E rx~ % % w
Y&/Y&//ww{*++ + + + MM5&/ * * * * * +" Xf
F eU
C
]C%K% /1
@
@
@F L E
8 8a5 E>>a7ll9l#
NA)"6E6* - - -'/'7GCe O $
0 0a5 E>>a7ll9l#
NA)"6E6* U ' /GUFGG
KKcK
'j
9
9
9F }VX66 A A& A AAs 0P!P%$P%c
||fS r r )rY rg rh ri rj rk rz s r# _rec_join_dispatcherr v rm r% c J t ||||dd }t | ||fi |S )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)ri rj rk rz rs rt )r| r )rY rg rh ri rj rk rz r s r# r r | sB 8yI#UtE E EF 3B ) )& ) ))r% )F)NN)NT)TFr )NNNN)r FFF)Nr TF)FF)r )NNN)NFr )NNNNN)NNFFr )T)NTFF)NTF)NNNNNN)rn ro rp NTF)rn ro rp N)C__doc__ri numpyrL numpy.marq r r r numpy.ma.mrecordsr numpy.core.overridesr numpy.lib._iotoolsr corer __all__r$ r r< r r r rP rS r r^ rf rn ru r} r r r r r r r r r r r r r r r r r r r r# r r. r
r6 r r: r r@ r r\ r
rl r r r r r% r# r s # # # # # # # # + + + + + + 8 8 8 8 8 8 . . . . . .EJ0 :;;# # <;#L
> @ @ 4
8 8 8 8 , , , ,^
" " " "0 " BF6:
12238+0D D D 32DN 011=G =G =G 21=G@G G G G2 455I I 65I 233$ $ 43$ N 9=HL 233,0:?CG CG CG 43CGL
677 9 9 9 87 9D 233P" P" P" 43P"d# # # #J* * *Z BF37 ?@@~1 ~1 ~1 A@~1B CGJN ?@@BG3;h' h' h' A@h'T 788& & 98& T :;;#3 #3 #3 <;#3J 344( ( 54(V =A:>
122AF "T? T? T? 32T?p 48
4556 6 6 656t ?C04 ,--DG49pB pB pB .-pBh ?C -..EH * * * /. * * *r%