B d!dZd"d#Z d$d%Z!d?d'd(Z"d@d)d*Z#dAd+d,Z$dBd.dZ%dCd/d Z&dDd0d1Z'd2dZ(d3dZ)dEd4d Z*dFd5dZ+dGd6dZ,dHd7d Z-dId;dZ.dJd>> from numpy.lib import recfunctions as rfn >>> a = np.array([(1, 10.), (2, 20.)], dtype=[('A', int), ('B', float)]) >>> b = np.zeros((3,), dtype=a.dtype) >>> rfn.recursive_fill_fields(a, b) array([(1, 10.0), (2, 20.0), (0, 0.0)], dtype=[('A', '>> from numpy.lib import recfunctions as rfn >>> rfn.get_names(np.empty((1,), dtype=int)) is None True >>> rfn.get_names(np.empty((1,), dtype=[('A',int), ('B', float)])) ('A', 'B') >>> adtype = np.dtype([('a', int), ('b', [('ba', int), ('bb', int)])]) >>> rfn.get_names(adtype) ('a', ('b', ('ba', 'bb'))) N)rappendtuple get_names)adtype listnamesrnamer!r"r"r#r&Is r&cCsJg}|j}x2|D]*}||||}|jr|t|qWt|pHdS)a2 Returns the field names of the input datatype as a tuple. Nested structure are flattend beforehand. Parameters ---------- adtype : dtype Input datatype Examples -------- >>> from numpy.lib import recfunctions as rfn >>> rfn.get_names_flat(np.empty((1,), dtype=int)) is None True >>> rfn.get_names_flat(np.empty((1,), dtype=[('A',int), ('B', float)])) ('A', 'B') >>> adtype = np.dtype([('a', int), ('b', [('ba', int), ('bb', int)])]) >>> rfn.get_names_flat(adtype) ('a', 'b', 'ba', 'bb') N)rr$extendget_names_flatr%)r'r(rr)r!r"r"r#r+hs  r+cCsd|j}|dkr|jSg}x>|D]6}|j|\}}|jrF|t|q|||fqWt|SdS)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'))) N)rdescrfieldsr* flatten_descrr$r%)ndtyperr,r typ_r"r"r#r.s  r.FcCs|g}|r(xf|D]}|t|jqWnHxF|D]>}|j}|jp@d}t|dkr`|d|jfq.||jq.Wt|jS)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. r")r*r.rrrr$r,np) seqarraysflattenrar!rr"r"r# zip_descrs     r8cCs|dkr i}|j}x|D]~}||}|jrV|r:|g||<ng||<|t|||qdd||gpjgD}|r||n |r|g}|pg||<qW|pdS)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']} NcSsg|]}|qSr"r").0r1r"r"r# sz&get_fieldstructure..)rupdatergetr$)r'Zlastnameparentsrr)r!Z lastparentr"r"r#rs"   ccsBx<|D]4}t|tjr4x"tt|D] }|Vq$Wq|VqWdS)zu Returns an iterator of concatenated fields from a sequence of arrays, collapsing any nested structure. N) isinstancer4void_izip_fields_flatr%)iterableelementfr"r"r#r@s    r@ccs|xv|D]n}t|dr8t|ts8xTt|D] }|Vq(Wqt|tjrntt|dkrnxt|D] }|Vq^Wq|VqWdS)zP Returns an iterator of concatenated fields from a sequence of arrays. __iter__r2N)hasattrr>r _izip_fieldsr4r?rr%)rArBrCr"r"r#rFs     rFTccsT|r t}nt}tjddkr$tj}ntj}x$||d|iD]}t||Vq:WdS)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 rr fillvalueN)r@rFsys version_info itertools zip_longestZ izip_longestr%)r5 fill_valuer6ZzipfuncrKtupr"r"r# izip_records srNcCs>t|tsd}|r"|r:|t}nt|}|r:|t}|S)z Private function: return a recarray, a ndarray, a MaskedArray or a MaskedRecords depending on the input parameters F)r>rviewrmafilledr)rusemask asrecarrayr"r"r# _fix_output&s    rTcCs\|jj}|j|j|j}}}x8|p&iD](\}}||kr,|||<|||||<q,W|S)zp Update the fill_value and masked data of `output` from the default given in a dictionary defaults. )rrdatamaskrLitems)rdefaultsrrUrVrLkvr"r"r# _fix_defaults7sr[cCst|dkrt|d}t|ttjfr|j}|rHt|fdd|jkr| }|j s`d|fg}|rt|rnt }qt }n|r~t }nt}|j||dS|f}ndd|D}td d |D}t|}t||d} g} g} |rxt||D]\} } || }| }t|  }|rzt|| j}t|ttjfrt|jdkrV|d}d}n"tj|| jdd }tjd |jd }nd}d}| t||g|| t||g|qWtt| |d}tjtj|| |dtt| |dd}|r|t }nxt||D]\} } || }| }|r|t|| j}t|ttjfrt|jdkrh|d}ntj|| jdd }nd}| t||g|q Wtjtt| |d| |d}|r|t }|S)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 -------- >>> from numpy.lib import recfunctions as rfn >>> rfn.merge_arrays((np.array([1, 2]), np.array([10., 20., 30.]))) masked_array(data = [(1, 10.0) (2, 20.0) (--, 30.0)], mask = [(False, False) (False, False) (True, False)], fill_value = (999999, 1e+20), dtype = [('f0', '>> rfn.merge_arrays((np.array([1, 2]), 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', int)]), ... np.array([10., 20., 30.])), ... usemask=False, asrecarray=True) rec.array([(1, 10.0), (2, 20.0), (-1, 30.0)], dtype=[('a', '.css|] }|jVqdS)N)size)r9r7r"r"r# szmerge_arrays..)rZndmin)r2)rN)rcount)rV)rr4r^r>rr?rr8r,ravelrrrrrOr%maxr Z __array__rPZ getmaskarray_check_fill_valueitemarrayZonesr$rJchainrNZfromiterlist)r5rLr6rRrSZseqdtypeZseqtypeZsizesZ maxlengthrZseqdataZseqmaskr7nZ nbmissingrUrVZfvalZfmskrr"r"r#rEs|1           cs`t|r|g}nt|}fdd|j|}|s8dStj|j|d}t||}t|||dS)av Return a new array with fields in `drop_names` dropped. Nested fields are supported. 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', int), ('b', [('ba', float), ('bb', int)])]) >>> rfn.drop_fields(a, 'a') array([((2.0, 3),), ((5.0, 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', '._drop_descrN)r)rRrS)r setrr4emptyshaperrT)baserkrRrSrrr")rlr#rs#   cs:fdd|D}tjj|d}t|}t|||dS)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. csg|]}|j|fqSr")r)r9rj)rpr"r#r:!sz _keep_fields..)r)rRrS)r4rnrorrT)rpZ keep_namesrRrSrrr")rpr# _keep_fieldss rqcCst||dddS)zK Returns a new numpy.recarray with fields in `drop_names` dropped. FT)rRrS)r)rprkr"r"r#r'scs"fdd|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.0, [3.0, 30.0])), (4, (5.0, [6.0, 60.0]))], dtype=[('A', '._recursive_rename_fields)rrO)rprrrr")rsr#r.s c CsLt|ttfr,t|t|krBd}t|nt|trB|g}|g}|dkrndd|D}ddt||D}n`t|ttfs|g}t|t|krt|dkr|t|}n d}t|ddt|||D}t|||d }t|dkrt|d ||d }n|}t j t t|t||j j |j j d }t||}t||}t|||d 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 namesNcSsg|]}tj|dddqS)FT)copysubok)r4rg)r9r7r"r"r#r:}sz!append_fields..cSs"g|]\}}|||jfgqSr")rOr)r9r)r7r"r"r#r:~sr2z5The dtypes argument must be None, a dtype, or a list.cSs0g|](\}}}tj|dd|d||fgqS)FT)rtrur)r4rgrO)r9r7rjdr"r"r#r:s)rRrLT)r6rRrL)r)rRrS)r>r%rirrr r rpoprP masked_allrdrr,rrT) rprrUdtypesrLrRrSmsgrr"r"r#r Us:       cCst||||dddS)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)rUryrSrR)r )rprrUryr"r"r#rs cCs:t|tr|St|dkr"|dSdd|D}dd|D}dd|D}dd|D}|d} | j} dd| D} x|dd D]} x| jD]} | dpd }|| kr| | | |q| |}| |}|rt| dt|d krBt|}| d|d <t || |<q| d|d krt d t | || dfqWqWt| dkrdt |}nt t|f| }ttjd|f}g}xt|||d d |dd D]r\}}}}|jj} | d kr||d t|||<n8x6|D].}||||||<||kr||qWqWtt||||dS)a Superposes arrays fields by fields Parameters ---------- arrays : array or sequence Sequence of input arrays. 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. autoconvert : {False, True}, optional Whether automatically cast the type of the field to the maximum. Examples -------- >>> 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', float), ('C', float)]) >>> test = rfn.stack_arrays((z,zz)) >>> test masked_array(data = [('A', 1.0, --) ('B', 2.0, --) ('a', 10.0, 100.0) ('b', 20.0, 200.0) ('c', 30.0, 300.0)], mask = [(False, False, True) (False, False, True) (False, False, False) (False, False, False) (False, False, False)], fill_value = ('N/A', 1e+20, 1e+20), dtype = [('A', '|S3'), ('B', '.cSsg|] }t|qSr")r)r9r7r"r"r#r:scSsg|] }|jqSr")r)r9r7r"r"r#r:scSsg|] }|jqSr")r)r9rvr"r"r#r:scSsg|] }|dqS)rr")r9r1r"r"r#r:sNr3r\zIncompatible type '%s' <> '%s'zf%i)rRrS)r>rrr,r$indexr4rrir% TypeErrordictrP concatenaterxsumZcumsumZr_r rrTr[)ZarraysrXrRrSZ autoconvertr5Znrecordsr/ZfldnamesZdtype_lZnewdescrrZdtype_nr,r)nameidxZ current_descrroffsetseenr7rjijr"r"r#rsT'          ,    c Cst|}t|j}|}|rBx||D] }||}q*W||}|}||}|} | dd| ddk} |r|j} d| | dd<tdg| f} | dd| dd| dd<||| } |r| || fS| SdS)aa 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) ... # XXX: judging by the output, the ignoremask flag has no effect Nr\r2F) r4r^rcrrargsortrQZ recordmaskr~) r7keyZ ignoremaskZ return_indexr-rprCZsortidxZ sortedbaseZ sorteddataflagZ sortedmask duplicatesr"r"r#rs(     inner12c )s|dkrtd|ttr$ftttkr^tfddtD} td| x<D]4} | |jjkrtd| | |jjkrdtd| qdW| }| }t|} |jj|jj} } t t| t|  r|s|sd}|d 7}t|fd d | D}t ||}t ||}t ||f}|jd }||}t d g|dd|ddkf}|dd|dd|dd<||}||| k}||| k| }t|t|}}|dkrd\}}n|dkr2||}t|||| kf}t|||| k| f}t||t||}}n<|dkrn||}t|||| kf}t||d}}||||}}dd |jjD}|fdd|jjDtdd|D} x|jjD]}!t|!}!|!d} | | krN||!}"||"}#| krt|!d|#d|#d<n0|#d|7<|!d|7<||"d|!n| |!d||!qWdd |D}t||}$t j|$||f|d}%|%jj} x| D]x}&||&}'|&| ks|&| kr|s|&kr|&|7}&|%|&}#|'d||#d|<|dkr|'|d|#|$|$|<qWx| D]|}&||&}'|&| ks\|&| krd|sd|&krd|&|7}&|%|&}#|'d||#d|<|dkr,|r,|'|d|#| d<q,W|%jd t||d}(tt|%|f|(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... )router leftouterzWThe 'jointype' argument should be in 'inner', 'outer' or 'leftouter' (got '%s' instead)c3s*|]"\}}||ddkr|VqdS)r2Nr")r9rjx)rr"r#raszjoin_by..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 be emptycsg|]}|kr|qSr"r")r9rj)rr"r#r:szjoin_by..)orderFr2Nr\r)rrrrrcSsg|] }t|qSr")ri)r9r1r"r"r#r:sc3s"|]}|dkrt|VqdS)rN)ri)r9r1)rr"r#rascss|]}|dVqdS)rNr")r9r1r"r"r#rascSsg|] }t|qSr")r%)r9r1r"r"r#r:s)r)rr)rRrS)rr>r rrmnext enumeraterrrc intersection differencerqrPr~rr4r,r*rir{rdinsertr$rxsortr}rTr[))rr1r2jointype r1postfix r2postfixrXrRrSdupr)Znb1Zr1namesZr2namesrzZkey1Zr1kZr2kZauxZidx_sortZflag_inZidx_inZidx_1Zidx_2Zr1cmnZr2cmnZr1spcZr2spcZidx_outs1s2r/rZdescrr!ZcmnrrCZselectedkwargsr")rr#rLs3         $             $  $  cCs$t||||ddd}t|||f|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)rrrrXrRrS)r}r)rrrrrrrXrr"r"r#rs  )F)NN)NT)TF)N)r\FFF)TF)TF)Nr\TF)N)NTFF)NTF)rrrNTF)rrrN)0__doc__Z __future__rrrrHrJZnumpyr4Znumpy.marPrrrZnumpy.ma.mrecordsrZnumpy.lib._iotoolsr Z numpy.compatr rIZfuture_builtinsr Zcorere__all__rr&r+r.r8rr@rFrNrTr[rrrqrrr rrrrrr"r"r"r#s\        '  /     @ ' D " Y 6 -