�
�9Zc@`
s7dZd
dl
mZmZmZ
d
dlZd
dlZd
dlZd
dl	j
Z
d
dlmZmZ
d
dl	m
Z

d
dlmZ
d
dlmZ
d
dlmZ
ejd
d	kr�d
d
lmZ
nej
jjZddd
dddddddddgZd�Zd�Zd�Zd�Zed�
Zddd�Z!d�Z"d�Z#de$d�Z%e$ed �Z&dd!�
Z'd"eeed#�Z(e$ed$�Z)d%�Z*d&�Z+dd"e$ed'�Z,dd(�
Z-de$eed)�Z.de$ed*�Z/d+d,d-de$ed.�Z0d+d,d-dd/�Z1dS(0s�
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.

i(tdivisiontabsolute_importtprint_functionN(tndarraytrecarray(
tMaskedArray(
t
MaskedRecords(
t_is_string_like(
t
basestringi(
tzipt
append_fieldstdrop_fieldstfind_duplicatestget_fieldstructuretjoin_bytmerge_arraystrec_append_fieldstrec_drop_fieldstrec_jointrecursive_fill_fieldst
rename_fieldststack_arrayscC`
sz|
j}xj|j
D]_}y||}Wntk
r=


qn
X|jj
r^t||
|�
q||
|t|�
*qW|
S(
sl
    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', 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', '<i4'), ('B', '<f8')])

    (tdtypetnamest
ValueErrorRtlen(tinputtoutputtnewdtypetfieldtcurrent((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyR"s	








c
C`
srg}
|j}xP|D]H}||}|jrQ|
j
|tt|�
�
f�

q|
j
|�

qWt|
�
pqd
S(s�

    Returns the field names of the input datatype as a tuple.

    Parameters
    ----------
    adtype : dtype
        Input datatype

    Examples
    --------
    >>> 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(Rtappendttuplet	get_namestNone(tadtypet	listnamesRtnameR((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyR!Is
	




	
"
c
C`
sfg}
|j}xD|D]<}|
j
|�

||}|jr|
jt|�
�

qqWt|
�
ped
S(s2
    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(RRtextendtget_names_flatR R"(R#R$RR%R((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyR'hs
	






	

c
C`
s�|j}
|
d
kr|jSg}xS|
D]K}|j|\}}|jra|jt|�
�

q)|j||f�

q)Wt|�
Sd
S(sD

    Flatten a structured data-type description.

    Examples
    --------
    >>> from numpy.lib import recfunctions as rfn
    >>> ndtype = np.dtype([('a', '<i4'), ('b', [('ba', '<f8'), ('bb', '<i4')])])
    >>> rfn.flatten_descr(ndtype)
    (('a', dtype('int32')), ('ba', dtype('float64')), ('bb', dtype('int32')))

    N(RR"tdescrtfieldsR&t
flatten_descrRR (tndtypeRR(Rttypt
_((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyR*�s	





	

cC`
s�g}|
r6x�|D]}|jt
|j�
�

qWndxa|D]Y}|j}|jpXd}t|�
d
kr�|jd|jf�

q=|j|j�

q=Wtj|�
jS(s�
    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.
    i
t((R&R*RRRRR(tnp(t	seqarraystflattenRt
aRR((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyt	zip_descr�s





	



cC`
s�|d
kri}n|j
}x�|D]�}||}|j
rz|
rT|
g
||<n
g||<|jt|||��

q%g|j|
g�p�gD]}|^q�}|r�|j|
�

n|
r�|
g
}n|p�g||<q%W|p�d
S(sb
    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']}

    N(R"RtupdateR
tgetR(R#tlastnametparentsRR%RR-t
lastparent((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyR
�s"
	
	




	



+





c
c`
sQxJ|D]B}
t|
t
j�rDx'tt|
�
�
D]}|V
q2Wq|
V
qWd
S(su
    Returns an iterator of concatenated fields from a sequence of arrays,
    collapsing any nested structure.

    N(t
isinstanceR/tvoidt_izip_fields_flatR (titerabletelementt
f((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyR;�s




c
c`
s�x�|D]�}
t|
d
�rKt
|
t�rKxjt|
�
D]}|V
q9Wqt
|
tj�r�tt|
�
�
dkr�x!t|
�
D]}|V
q�Wq|
V
qWdS(sP
    Returns an iterator of concatenated fields from a sequence of arrays.

    t__iter__i
N(thasattrR9Rt_izip_fieldsR/R:RR (R<R=R>((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyRA�s





*

c	c`
s�|
g
t|�
d
j
d�
}tj|
�
}g|D]}tj||�|�^q6}|rit}nt}y,x%t|�D]}t||�
�
V
qWWnt	k
r�


n
XdS(s*

    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
    i
c


s`
s|�V
d
S(s*Yields the fill_value or raises IndexErrorN((
tcounter((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pytsentinel
sN(
Rtpopt	itertoolstrepeattchainR;RAR	R t
IndexError(	R0t
fill_valueR1RCtfillerstittiterstzipfuncttup((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pytizip_records	
s 
+
	




cC`
sdt|t
�st}
n|
r9|r`|jt�
}q`n'tj|�
}|r`|jt�
}n|S(
s�
    Private function: return a recarray, a ndarray, a MaskedArray
    or a MaskedRecords depending on the input parameters
    (R9RtFalsetviewRtmatfilledR(Rtusemaskt
asrecarray((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyt_fix_output*
s
	





cC`
s{|jj
}|j|j|j}}}xK|
p5ij�D]7\}}||kr<|||<|||||<q<q<W|S(
sp
    Update the fill_value and masked data of `output`
    from the default given in a dictionary defaults.
    (RRtdatatmaskRItitems(RtdefaultsRRWRXRIt
kt
v((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyt
_fix_defaults;
s






i����cC`
st|�
d
kr(t
j|d�
}nt|tt
jf�r�|j}|snt|f
dt�

|j	kr�|j
�}|js�d|fg
}n|r�|r�t}q�t
}n|r�t}nt}|jd|d|�S|f
}n"g|D]}t
j|�
^q�}td�|D�
�
}t|�
}	t|d|�

}
g}g}|r�x4
t||�D]#
\}
}|	|}|
j
�j�}tj|
�
j
�}|r9t|
|
j�}t|tt
jf�rEt|j�
d
kr�
|j�d}t}q6t
j|d|
jdd
�
}t
jdd|j�

}qEnd}t}|jtj||g
|��

|jtj||g
|��

qb
Wtt|d|�

�
}tjt
j|d|
d	|	�
d
t t|d|�

�
�

}|r|jt�
}qn#
x�t||�D]�\}
}|	|}|
j
�j�}|r�t|
|
j�}t|tt
jf�r�t|j�
d
kr�|j�d}q�t
j|d|
jdd
�
}q�nd}|jtj||g
|��

qWt
jtt|d|�

�
d|
d	|	�
}|r|jt�
}n|S(
s�
    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', '<i4'), ('f1', '<f8')])

    >>> 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', '<i4'), ('f1', '<f8')])
    >>> 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', '<i4'), ('f1', '<f8')])

    Notes
    -----
    * Without a mask, the missing value will be filled with something,
    * depending on what its corresponding type:
            -1      for integers
            -1.0    for floating point numbers
            '-'     for characters
            '-1'    for strings
            True    for boolean values
    * XXX: I just obtained these values empirically
    i
iR1R.Rttypec
s`
s|]}
|
jV
qdS(
N(
tsize(t.0R2((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pys	<genexpr>�
stndmintcountRX(
i
N(!RR/t
asanyarrayR9RR:RR3tTrueR(travelRRRRRQR tmaxR	t	__array__RRtgetmaskarrayt_check_fill_valuetitemtarraytonesR"RRERGROtfromitertlist(R0RIR1RTRUtseqdtypetseqtypet_mtsizest	maxlengthRtseqdatatseqmaskR2t
nt	nbmissingRWRXtfvaltfmskR((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyRI
s|1

	

	


		

	
"










	

 
$
!










$
$



c`
s�t|
�
r|
g
}
nt
|
�
}
�f
d
���|j|
�}|sOdStj|jd|�

}t||�}t|d|d|�
S(sv
    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', '<f8'), ('bb', '<i4')])])
    >>> rfn.drop_fields(a, 'ba')
    array([(1, (3,)), (4, (6,))],
          dtype=[('a', '<i4'), ('b', [('bb', '<i4')])])
    >>> rfn.drop_fields(a, ['ba', 'bb'])
    array([(1,), (4,)],
          dtype=[('a', '<i4')])
    c`
s�|j}g}xt|D]l}||}||
kr8qn|jro�||
�}|r�|j
||f�

q�q|j
||f�

qW|S(
N(RR(R+t
drop_namesRRR%RR((
t_drop_descr(sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyR{�
s
	







	



RRTRUN(	RtsetRR"R/temptytshapeRRV(tbaseRzRTRURR((
R{sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyR�
s#




cC`
st||
d
t
dt�S(sK
    Returns a new numpy.recarray with fields in `drop_names` dropped.
    RTRU(RRPRd(RRz((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyRsc`
s.�f
d
���|j|
�}|j
|�
S(s�
    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', '<i4'), ('b', [('ba', '<f8'), ('BB', '<f8', 2)])])

    c`
sug}xh|jD]]}|
j
||�}||}|jrZ|j|�||
�f�

q|j||f�

qW|S(
N(RR5R(R+t
namemapperRR%tnewnameR(
t_recursive_rename_fields(sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyR�0s





	


(RRQ(RR�R((
R�sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyRs
c

C`
svt|
t
tf�rEt|
�
t|�
krid
}t|�
�
qin$t|
t�ri|
g
}
|g
}n|dkr�g|D]!}tj|dt	dt
�
^q|}gt|
|�D]'\}	}|j|	|j
fg
�
^q�}n�t|t
tf�s
|g
}nt|�
t|�
krV
t|�
dkrA
|t|�
}qV
d}t|�
�
ngt||
|�D]B\}}
}tj|dt	dt
d|�
j|
|fg
�
^qi
}t|d|d|�
}t|�
dkr�
t|d	t
d|d|�
}n|j�}tjtt|�
t|�
�d|j
j|j
j�

}t||�}t||�}t|d|d
|�
S(s

    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.

    s7The number of arrays does not match the number of namestcopytsuboki
s5The dtypes argument must be None, a dtype, or a list.RRTRIR1RUN(R9R RnRRRR"R/RkRPRdR	RQRRRDRRt
masked_allRfR(RRV(
RRRWtdtypesRIRTRUtmsgR2R%Rvt
dR((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyR
@s:




	

.
@






X


!


cC`
s%t||
d
|d|dt
dt�S(sM
    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
    RWR�RURT(R
RdRP(RRRWR�((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyR�s
cC`
st|t
�r|St|�
d
kr-|dSg|D]}tj|�
j�^q4}g|D]}t|�
^q\}g|D]}|j^q{}g|D]}	|	j^q�}
|d}|j}g|D]}
|
d^q�}x
|d
D]
}x�|jD]�}|dp

d}||kr6
|j	|�

|j	|�

q�|j
|�
}||}|r�
tj|d
�
tj|d�
kr�
t|�
}|d
|d<t|�
||<q�
q�|d
|dkr�t
dt|�
||d
f�
�
q�q�Wq�Wt|�
d
krtj|�
}n�tjtj|�
f
|�}tjtjd|f�
}g}x�t||
|d |d
�D]�\}}}}|jj}|d	kr�||dt|�
||+qpx?|D]7}||||||+||kr�|j	|�

q�q�WqpWtt||
�d|d|�
S(
s�
    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', '<f8'), ('C', '<f8')])

    i
iR.i����sIncompatible type '%s' <> '%s'sf%iRTRUN(R9RRR/RcReRRR(RtindexRnR t	TypeErrortdictRRtconcatenateR�tsumtcumsumtr_R	R"RVR](tarraysRZRTRUtautoconvertR2R0tnrecordsR+R�tfldnamestdtype_ltnewdescrR-Rtdtype_nR(R%tnameidxt
current_descrRtoffsettseenRvt
it
j((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyR�sT'



(




	











&





)



0







c
C`
s

tj
|�
j�}t|j�
}|}|
r\x||
D]}||}q;W||
}n|j�}||}|j�}	|	d
 |	dk}
|r�|j}t|
|d<ntj	tg
|
f�
}
|
d
 |
d|
d
*|||
}|r
|||
fS|SdS(sa
    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
    i����i
N(
R/RcReR
RtargsortRSt
recordmaskRPR�(
R2tkeyt
ignoremasktreturn_indexR)RR>tsortidxt
sortedbaset
sorteddatatflagt
sortedmaskt
duplicates((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyR
s(








	




tinnert
1t
2c	)`
s|dkrtd|�
�
nt
�t�r:�f
�nxX�D]P}	|	|
jjkrltd|	�
�
n|	|jjkrAtd|	�
�
qAqAW|
j�}
|j�}t|
�
}
|
jj|jj}}tjt|�
t|�
�j	��
r%
|p
|r%
d}
|
d7}
t|
�
�
nt
|
g|D]}|�kr2
|^q2
�}t
|g|D]}|�kr`
|^q`
�}tj||f�
}|j
d	��
}||}tjtg
|d
|d kf�
}|d
|d |d*||}|||
k}|||
k|
}t|�
t|�
}}|d
krPd\}}n�|dkr�||}tj||||
kf�
}tj||||
k|
f�
}t|�
|t|�
|}}nP|dkr||}tj||||
kf�
}t|�
|d}}n|
|||}}g|jjD]}t|�
^q?}|j�f
d
�|
jjD�
�

td�|D�
�
} x�|jjD]�}!t|!�
}!|!d}	|	| kr?|j|!�
}"||"}#|	�krt|!d
|#d�|#d<q]|#dc|7<|!dc|7<|j|"d
|!�
q�| j|!d�

|j|!�

q�Wg|D]}t|�
^qh}t||�}$tj|$||f
d|�

}%|%jj} x�|D]�}&||&}'|&| ks�|&|kr
|r
|&�kr
|&|7}&n|%|&}#|'| |#|*|dkr�|'||#|$|$|+q�q�Wx�|D]�}&||&}'|&| ks�|&|kr�|r�|&�kr�|&|7}&n|%|&}#|'| |#|*|dkrQ|rQ|'||#|)qQqQW|%jd	��

td|d|�}(tt|%|�|(�
S(s<
    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...

    R�toutert	leftoutersWThe 'jointype' argument should be in 'inner', 'outer' or 'leftouter' (got '%s' instead)sr1 does not have key field %ssr2 does not have key field %ss8r1 and r2 contain common names, r1postfix and r2postfix scan't be emptytorderi
i����ic
3`
s+|]!}
|
d�krt|
�
V
qd
S(iN(
Rn(R`R-(
R�(sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pys	<genexpr>�sc
s`
s|]}
|
dV
qd
S(iN((R`R-((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pys	<genexpr>�sRRTRU(R�R�R�(ii(R�R�(RR9RRRReRR|tintersectiont
differenceRRRR�R�RPR/R(RnR&R�RftinsertRR R�tsortR�RVR]()R�tr1tr2tjointypet	r1postfixt	r2postfixRZRTRUR%tnb1tr1namestr2namesR�Rvtr1ktr2ktauxtidx_sorttflag_intidx_intidx_1tidx_2tr1cmntr2cmntr1spctr2spctidx_outts1ts2R-R+RtdescR�RtcmnRR>tselectedtkwargs((
R�sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyR7s�3











'





.
.


&











#
$



%#










 





+











+








c
C`
s@td
|d|d|d|dt
dt�}t||
||�S(s�
    Join arrays `r1` and `r2` on keys.
    Alternative to join_by, that always returns a np.recarray.

    See Also
    --------
    join_by : equivalent function
    R�R�R�RZRTRU(R�RPRdR(R�R�R�R�R�R�RZR�((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyR�s


(2t__doc__t
__future__RR
RtsysREtnumpyR/tnumpy.maRRRRRtnumpy.ma.mrecordsRtnumpy.lib._iotoolsRtnumpy.compatRtversion_infotfuture_builtinsR	tcoreRit__all__RR!R'R*RPR3R"R
R;RARdRORVR]RRRRR
RRRRR(((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/recfunctions.pyt<module>sV









	
	
	
	'			/		!
�@		'
D"	
Y6	
�