�
�9Zc+@`
s�dZd
dl
mZmZmZ
ddddddd	d
ddd
ddddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-g+Zd
d.lZd
d.lZd/d0lm	Z

d/d1l	mZmZm
Z
mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z 
d
d.l!Z"d
d2l!m#Z#mZ$
d
d.l%j	j&Z&d
d3l'm(Z(
d
d4l)m*Z*
d5�Z+d.d6�
Z-e.d7�
Z/d8�Z0d9d`d:��YZ1e1d�
Z2e1d�
Z3e1d�
Z4e1d-�
Z5Z6e1d�
Z7e1d�
Z8e1d�
Z9e1d�
Z:e1d�
Z;d;�Z<d<�Z=e"j=je=_d=�Z>e>jd.k	r�e"j>je"j>jj?d>�
 j@�d?e>_nd.d.eAd@�ZBd.d.eAeAdA�ZCd.d.eAdB�ZDd.dC�
ZEd.dD�
ZFdE�ZGdF�ZHd.dG�
ZId.dH�
ZJd.d.dI�ZKeAeAdJ�ZLeAdK�
ZMeAdL�
ZNeAeAdM�ZOdN�ZPeAdO�
ZQd.eReRdP�ZSd.eReAeRd.dQ�ZTd.eRe"jUeRe"jUdR�ZVdSe*f
dT��YZWdUeWf
dV��YZXeX�ZYdW�ZZd.dX�
Z[dY�Z\d.dZ�
Z]d[�Z^d\�Z_d]�Z`d.d^�
Zae
jbe"jajeaj�ea_d.eAd.eAd_�Zce
jbe"jcjecj�ec_d.S(as�
Masked arrays add-ons.

A collection of utilities for `numpy.ma`.

:author: Pierre Gerard-Marchant
:contact: pierregm_at_uga_dot_edu
:version: $Id: extras.py 3473 2007-10-29 15:18:13Z jarrod.millman $

i(tdivisiontabsolute_importtprint_functiontapply_along_axistapply_over_axest
atleast_1dt
atleast_2dt
atleast_3dtaveragetclump_maskedtclump_unmaskedtcolumn_stackt
compress_colstcompress_ndtcompress_rowcolst
compress_rowstcount_maskedtcorrcoeftcovtdiagflattdottdstacktediff1dtflatnotmasked_contiguoustflatnotmasked_edgesthsplitthstacktin1dtintersect1dt	mask_colstmask_rowcolst	mask_rowst
masked_alltmasked_all_liketmediantmr_tnotmasked_contiguoustnotmasked_edgestpolyfitt	row_stackt	setdiff1dtsetxor1dtuniquetunion1dtvandertvstackNi
(
tcore(tMaskedArraytMAErrortaddtarraytasarraytconcatenatetfilledtcounttgetmasktgetmaskarraytmake_mask_descrtmaskedtmasked_arraytmask_ortnomasktonestsorttzerostgetdatatget_masked_subclassRR(tndarrayR2(
t_ureduce(
tAxisConcatenatorc

C`
s t|t
ttf�rtStS(
s6
    Is seq a sequence (ndarray, list or tuple)?

    (t
isinstanceRCttupletlisttTruetFalse(
tseq((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyt
issequence+s

cC`
st|�
}|j
|
�
S(
s�
    Count the number of masked elements along the given axis.

    Parameters
    ----------
    arr : array_like
        An array with (possibly) masked elements.
    axis : int, optional
        Axis along which to count. If None (default), a flattened
        version of the array is used.

    Returns
    -------
    count : int, ndarray
        The total number of masked elements (axis=None) or the number
        of masked elements along each slice of the given axis.

    See Also
    --------
    MaskedArray.count : Count non-masked elements.

    Examples
    --------
    >>> import numpy.ma as ma
    >>> a = np.arange(9).reshape((3,3))
    >>> a = ma.array(a)
    >>> a[1, 0] = ma.masked
    >>> a[1, 2] = ma.masked
    >>> a[2, 1] = ma.masked
    >>> a
    masked_array(data =
     [[0 1 2]
     [-- 4 --]
     [6 -- 8]],
          mask =
     [[False False False]
     [ True False  True]
     [False  True False]],
          fill_value=999999)
    >>> ma.count_masked(a)
    3

    When the `axis` keyword is used an array is returned.

    >>> ma.count_masked(a, axis=0)
    array([1, 1, 1])
    >>> ma.count_masked(a, axis=1)
    array([0, 2, 1])

    (R8tsum(tarrtaxist
m((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR4s3
cC`
s4tt
j||
�d
t
j|t|
�
��

}|S(s�
    Empty masked array with all elements masked.

    Return an empty masked array of the given shape and dtype, where all the
    data are masked.

    Parameters
    ----------
    shape : tuple
        Shape of the required MaskedArray.
    dtype : dtype, optional
        Data type of the output.

    Returns
    -------
    a : MaskedArray
        A masked array with all data masked.

    See Also
    --------
    masked_all_like : Empty masked array modelled on an existing array.

    Examples
    --------
    >>> import numpy.ma as ma
    >>> ma.masked_all((3, 3))
    masked_array(data =
     [[-- -- --]
     [-- -- --]
     [-- -- --]],
          mask =
     [[ True  True  True]
     [ True  True  True]
     [ True  True  True]],
          fill_value=1e+20)

    The `dtype` parameter defines the underlying data type.

    >>> a = ma.masked_all((3, 3))
    >>> a.dtype
    dtype('float64')
    >>> a = ma.masked_all((3, 3), dtype=np.int32)
    >>> a.dtype
    dtype('int32')

    tmask(R;tnptemptyR>R9(tshapetdtypet
a((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR js/

c
C`
s@tj
|�
jt�
}
tj|
jd
t|
j�
�

|
_|
S(sz
    Empty masked array with the properties of an existing array.

    Return an empty masked array of the same shape and dtype as
    the array `arr`, where all the data are masked.

    Parameters
    ----------
    arr : ndarray
        An array describing the shape and dtype of the required MaskedArray.

    Returns
    -------
    a : MaskedArray
        A masked array with all data masked.

    Raises
    ------
    AttributeError
        If `arr` doesn't have a shape attribute (i.e. not an ndarray)

    See Also
    --------
    masked_all : Empty masked array with all elements masked.

    Examples
    --------
    >>> import numpy.ma as ma
    >>> arr = np.zeros((2, 3), dtype=np.float32)
    >>> arr
    array([[ 0.,  0.,  0.],
           [ 0.,  0.,  0.]], dtype=float32)
    >>> ma.masked_all_like(arr)
    masked_array(data =
     [[-- -- --]
     [-- -- --]],
          mask =
     [[ True  True  True]
     [ True  True  True]],
          fill_value=1e+20)

    The dtype of the masked array matches the dtype of `arr`.

    >>> arr.dtype
    dtype('float32')
    >>> ma.masked_all_like(arr).dtype
    dtype('float32')

    RU(	RRt
empty_liketviewR/R>RTR9RUt_mask(RNRV((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR!�s2
$
t_fromnxfunctionc
B`
s)eZ
dZd
�Zd�Zd�ZRS(s�

    Defines a wrapper to adapt NumPy functions to masked arrays.


    An instance of `_fromnxfunction` can be called with the same parameters
    as the wrapped NumPy function. The docstring of `newfunc` is adapted from
    the wrapped function as well, see `getdoc`.

    Parameters
    ----------
    funcname : str
        The name of the function to be adapted. The function should be
        in the NumPy namespace (i.e. ``np.funcname``).

    cC`
s|
|_|j
�|_dS(
N(t__name__tgetdoct__doc__(tselftfuncname((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyt__init__�s
	
c
C`
sctt
|jd�}
t|
d
d�}|r_|jtj|
�
}d}dj|||f�
SdS(s 
        Retrieve the docstring and signature from the function.

        The ``__doc__`` attribute of the function is used as the docstring for
        the new masked array version of the function. A note on application
        of the function to the mask is appended.

        .. warning::
          If the function docstring already contained a Notes section, the
          new docstring will have two Notes sections instead of appending a note
          to the existing section.

        Parameters
        ----------
        None

        R]sLNotes
-----
The function is applied to both the _data and the _mask, if any.s

N(tgetattrRRR[tNonetmatget_object_signaturetjoin(R^tnpfunctdoctsigtlocdoc((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR\�s




c

O`
stt
|j�}t|
�
d
krD
|
d}t|t�rw||j�|�
}|t|�
|�
}t|d|�

St|t	�s�t|t
�r
|t	g|D]}t
j|�
^q��
|�
}|t	g|D]}t|�
^q��
|�
}t|d|�

S|t
j|�
|�
}|t|�
|�
}t|d|�

Sn�g}t
|
�
}
x<t|
�
dkr�
t|
d�
r�
|j
|
jd�
�

qY
Wg}	xZ|D]R}|t
j|�
|
|�
}|t|�
|
|�
}|	j
t|d|�

�

q�
W|	SdS(Ni
iRQ(RaRRR[tlenRFRCt	__array__R8R;RGRHR3RLtappendtpop(
R^targstparamstfunct
xt_dt_mRVtarraystres((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyt__call__
s0









1
.




%







(R[t
__module__R]R`R\Rv(((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyRZ�s		c
C`
s\d
}
xO|
t|�
krWx,t
||
d�rI||
||
|
d+qW|
d7}
q	W|S(sFlatten a sequence in place.it__iter__i
(Rjthasattr(RKt
k((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pytflatten_inplace7
s




cO`
s�t|d
t
dt�
}|j}|
dkr:|
|7}
n|
|kr_td|
|f�
�
ndg
|d}tj|d�}tt|�
�
}|j	|
�

t
d
d
�||
<tj|j
�
j|�
}	|j||�
|j�}
||t|j��
||�
}tj|�
}|sM
yt|�

WqM
tk
rI



t}qM
Xng}
|r�|
jtj|�
j�

t|	t�}||t|�
<tj|	�
}d}x�||kr�|dcd7<d}xP|||	|kr|d|kr||dcd7<d||<|d8}q�
W|j||�
||t|j��
||�
}||t|�
<|
jt|�
j�

|d7}q�
Wn�
t|d
t
dt�
}|j�}
t
d
d
�g
|j|
|
<|
j||�
tj|	�
}|	}t|j
�
}	|j
|	|
<|
jt|�
j�

t|	�
}	t|	t�}||tt|
j��
�
<d}x�||krU|dcd7<d}xP||||kr�|d|kr�||dcd7<d||<|d8}q�W|j||�
|
j||�
||t|j��
||�
}||tt|
j��
�
<|
jt|�
j�

|d7}q_Wtjtj|
�
j��
}t|d�s�tj|d	|�

}n$t|d	|�

}tj|�
|_|S(s0
    (This docstring should be overwritten)
    tcopytsubokis2axis must be less than arr.ndim; axis=%d, rank=%d.i
t
Oi����RYRUN( R2RJRItndimt
ValueErrorRRR@RHtrangetremovetsliceRbR3RTttaketputR|RGttolisttisscalarRjt	TypeErrorRlRUtobjecttproductR{tmaxRyRctdefault_fill_valuet
fill_value(tfunc1dRORNRntkwargstndtindt
itindlisttoutshapet
jRutasscalartdtypestoutarrtNtotRzt
nt	holdshapet
max_dtypestresult((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyRA
s�
	















"















'





"


















'






"







cC`
s�t|
�
}|
j
}t|�
j
d
kr6|f
}nx�|D]�}|d
kr\||}n||f}||�}|j
|j
kr�|}q=tj||�}|j
|j
kr�|}q=td�
�
q=W|S(s.
    (This docstring will be overwritten)
    is7function is not returning an array of the correct shape(R3RR2Rctexpand_dimsR�(RpRVtaxestvalt
NRORnRu((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR�
s 
	










	

	tNotess�


    Examples
    --------
    >>> a = ma.arange(24).reshape(2,3,4)
    >>> a[:,0,1] = ma.masked
    >>> a[:,1,:] = ma.masked
    >>> print(a)
    [[[0 -- 2 3]
      [-- -- -- --]
      [8 9 10 11]]

     [[12 -- 14 15]
      [-- -- -- --]
      [20 21 22 23]]]
    >>> print(ma.apply_over_axes(ma.sum, a, [0,2]))
    [[[46]
      [--]
      [124]]]

    Tuple axis arguments to ufuncs are equivalent:

    >>> print(ma.sum(a, axis=(0,2)).reshape((1,-1,1)))
    [[[46]
      [--]
      [124]]]
    c	C`
st|�
}t
|�
}|d
krQ|j|
�
}|jj|j|
�
�
}nm
tj|�
}t	|jjtj
tjf�r�tj|j|jd
�}ntj|j|j�}|j
|j
krd
|
d
kr�td�
�
n|jdkr
td�
�
n|j
d|j
|
kr+
td�
�
ntj||jdd|j
�}|jd|
�}n|tk	r�
||j}n|jd|
d	|�}tj||d	|�
j|
�
|}|r�
|j
|j
kr�
tj||j
�j�}n||fS|Sd
S(ss
    Return the weighted average of array over the given axis.

    Parameters
    ----------
    a : array_like
        Data to be averaged.
        Masked entries are not taken into account in the computation.
    axis : int, optional
        Axis along which to average `a`. If `None`, averaging is done over
        the flattened array.
    weights : array_like, optional
        The importance that each element has in the computation of the average.
        The weights array can either be 1-D (in which case its length must be
        the size of `a` along the given axis) or of the same shape as `a`.
        If ``weights=None``, then all data in `a` are assumed to have a
        weight equal to one.   If `weights` is complex, the imaginary parts
        are ignored.
    returned : bool, optional
        Flag indicating whether a tuple ``(result, sum of weights)``
        should be returned as output (True), or just the result (False).
        Default is False.

    Returns
    -------
    average, [sum_of_weights] : (tuple of) scalar or MaskedArray
        The average along the specified axis. When returned is `True`,
        return a tuple with the average as the first element and the sum
        of the weights as the second element. The return type is `np.float64`
        if `a` is of integer type and floats smaller than `float64`, or the
        input data-type, otherwise. If returned, `sum_of_weights` is always
        `float64`.

    Examples
    --------
    >>> a = np.ma.array([1., 2., 3., 4.], mask=[False, False, True, True])
    >>> np.ma.average(a, weights=[3, 1, 0, 0])
    1.25

    >>> x = np.ma.arange(6.).reshape(3, 2)
    >>> print(x)
    [[ 0.  1.]
     [ 2.  3.]
     [ 4.  5.]]
    >>> avg, sumweights = np.ma.average(x, axis=0, weights=[1, 2, 3],
    ...                                 returned=True)
    >>> print(avg)
    [2.66666666667 3.66666666667]

    tf8s;Axis must be specified when shapes of a and weights differ.i
s81D weights expected when shapes of a and weights differ.is5Length of weights not compatible with specified axis.i����RORUN(
i
(R3R7RbtmeanRUttypeR6RRt
asanyarrayt
issubclasstintegertbool_tresult_typeRTR�RR�tbroadcast_totswapaxesR=RQRMtmultiplyR|(	RVROtweightstreturnedRPtavgtscltwgttresult_dtype((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR�
s<3


!








$


%



c
C`
s�t|d
�szt
jt|dt�

d|
d|d|d|�
}t|t
j�rsd|jk
rst|dt	�

S|Snt
|d	td|
d|d|�
\}}|r�|j|�
S|Sd
S(s:	
    Compute the median along the specified axis.

    Returns the median of the array elements.

    Parameters
    ----------
    a : array_like
        Input array or object that can be converted to an array.
    axis : int, optional
        Axis along which the medians are computed. The default (None) is
        to compute the median along a flattened version of the array.
    out : ndarray, optional
        Alternative output array in which to place the result. It must
        have the same shape and buffer length as the expected output
        but the type will be cast if necessary.
    overwrite_input : bool, optional
        If True, then allow use of memory of input array (a) for
        calculations. The input array will be modified by the call to
        median. This will save memory when you do not need to preserve
        the contents of the input array. Treat the input as undefined,
        but it will probably be fully or partially sorted. Default is
        False. Note that, if `overwrite_input` is True, and the input
        is not already an `ndarray`, an error will be raised.
    keepdims : bool, optional
        If this is set to True, the axes which are reduced are left
        in the result as dimensions with size one. With this option,
        the result will broadcast correctly against the input array.

        .. versionadded:: 1.10.0

    Returns
    -------
    median : ndarray
        A new array holding the result is returned unless out is
        specified, in which case a reference to out is returned.
        Return data-type is `float64` for integers and floats smaller than
        `float64`, or the input data-type, otherwise.

    See Also
    --------
    mean

    Notes
    -----
    Given a vector ``V`` with ``N`` non masked values, the median of ``V``
    is the middle value of a sorted copy of ``V`` (``Vs``) - i.e.
    ``Vs[(N-1)/2]``, when ``N`` is odd, or ``{Vs[N/2 - 1] + Vs[N/2]}/2``
    when ``N`` is even.

    Examples
    --------
    >>> x = np.ma.array(np.arange(8), mask=[0]*4 + [1]*4)
    >>> np.ma.median(x)
    1.5

    >>> x = np.ma.array(np.arange(10).reshape(2, 5), mask=[0]*6 + [1]*4)
    >>> np.ma.median(x)
    2.5
    >>> np.ma.median(x, axis=-1, overwrite_input=True)
    masked_array(data = [ 2.  5.],
                 mask = False,
           fill_value = 1e+20)

    RQR}ROtouttoverwrite_inputtkeepdimsi
R|RpN(
RyRRR"RARIRFRCRR;RJRDt_mediantreshape(RVROR�R�R�RPt
rRz((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR"3sB


	
!




cC`
sb|rD|
dkr+|j
�}|j�
qV|jd
|
�

|}nt|d
|
�

}|
dkrkd}
n|
dkr�|
|j7}
n|jdkr�tt|�
d�\}}|||d|d!jd|�
St|d
|
�

}|d}gt|j�
D]'\}	}
|	|
kr
t	j
|
�
^q
}t	jdtdd|�}|j
|
t	jd|d��
|t|�
}
|||
<|t|�
}|ddk}|jdkr�
t	j|
|d	|�

n|r�
|}
nt	j|jt	j�r:t	jj|
|gd
dd|�
}t	j|jd
ddd|j�
n$t	jj|
|gd
dd|�
}|S(
NROii
iR�tsparsetindexingtijtwhereg@tcastingtunsafe(RbtravelR?RtdivmodR6R�t	enumerateRTRRtarangetmeshgridRItinserttmaximumRGtcopytot
issubdtypeRUtinexactRcRMttrue_dividetdata(RVROR�R�tasortedtidxtoddtcountst
hR�Rqt	axes_gridR�tlowthight
s((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR��sB





	
	



#


!
 







	$
%$
c`
s�
t��
�t
��
}t|
t�r3|
f
}
nB|
dkrWtt�j�
�
}
nt|
t�sutd
�
�
ng|
D]%}|dkr�|�jn|^q|}
t	�f
d�|
D�
�
s�td�
�
nt
|
�
t
t|
�
�
kr�td�
�
n|tks
|j
�r
�jS|j	�r5
tg�
S�j}xk|
D]c}ttt|�
�
tt|d�j��
�
}|td�
f
||j
d|�
f
}qE
W|S(	s�Supress slices from multiple dimensions which contain masked values.

    Parameters
    ----------
    x : array_like, MaskedArray
        The array to operate on. If not a MaskedArray instance (or if no array
        elements are masked, `x` is interpreted as a MaskedArray with `mask`
        set to `nomask`.
    axis : tuple of ints or int, optional
        Which dimensions to supress slices from can be configured with this
        parameter.
        - If axis is a tuple of ints, those are the axes to supress slices from.
        - If axis is an int, then that is the only axis to supress slices from.
        - If axis is None, all axis are selected.

    Returns
    -------
    compress_array : ndarray
        The compressed array.
    sInvalid type for axis argumentic
3`
s.|]$}
d|
k
o#�jkn
V
qd
S(iN(
R(t.0tax(
Rq(sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pys	<genexpr>�ss'axis' entry is out of boundssduplicate value in 'axis'i
RON(R3R7RFtintRbRGR�RR�tallRjtsetR=tanyt_datatnxarrayRHR�(RqRORPR�R�R�((
RqsB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR
�s,





2






	


2
/
cC`
s4t|�
j
d
kr$td�
�
nt|d|
�

S(s�
    Suppress the rows and/or columns of a 2-D array that contain
    masked values.

    The suppression behavior is selected with the `axis` parameter.

    - If axis is None, both rows and columns are suppressed.
    - If axis is 0, only rows are suppressed.
    - If axis is 1 or -1, only columns are suppressed.

    Parameters
    ----------
    x : array_like, MaskedArray
        The array to operate on.  If not a MaskedArray instance (or if no array
        elements are masked), `x` is interpreted as a MaskedArray with
        `mask` set to `nomask`. Must be a 2D array.
    axis : int, optional
        Axis along which to perform the operation. Default is None.

    Returns
    -------
    compressed_array : ndarray
        The compressed array.

    Examples
    --------
    >>> x = np.ma.array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0],
    ...                                                   [1, 0, 0],
    ...                                                   [0, 0, 0]])
    >>> x
    masked_array(data =
     [[-- 1 2]
     [-- 4 5]
     [6 7 8]],
                 mask =
     [[ True False False]
     [ True False False]
     [False False False]],
           fill_value = 999999)

    >>> np.ma.compress_rowcols(x)
    array([[7, 8]])
    >>> np.ma.compress_rowcols(x, 0)
    array([[6, 7, 8]])
    >>> np.ma.compress_rowcols(x, 1)
    array([[1, 2],
           [4, 5],
           [7, 8]])

    is*compress_rowcols works for 2D arrays only.RO(R3RtNotImplementedErrorR
(RqRO((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR�s3

c

C`
s7t|�
}|j
d
kr*td�
�
nt|d�S(s�
    Suppress whole rows of a 2-D array that contain masked values.

    This is equivalent to ``np.ma.compress_rowcols(a, 0)``, see
    `extras.compress_rowcols` for details.

    See Also
    --------
    extras.compress_rowcols

    is'compress_rows works for 2D arrays only.i(R3RR�R(
RV((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR s


c

C`
s7t|�
}|j
d
kr*td�
�
nt|d�S(s�
    Suppress whole columns of a 2-D array that contain masked values.

    This is equivalent to ``np.ma.compress_rowcols(a, 1)``, see
    `extras.compress_rowcols` for details.

    See Also
    --------
    extras.compress_rowcols

    is'compress_cols works for 2D arrays only.i
(R3RR�R(
RV((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR1s


cC`
s
t|d
�S(s�
    Mask rows of a 2D array that contain masked values.

    This function is a shortcut to ``mask_rowcols`` with `axis` equal to 0.

    See Also
    --------
    mask_rowcols : Mask rows and/or columns of a 2D array.
    masked_where : Mask where a condition is met.

    Examples
    --------
    >>> import numpy.ma as ma
    >>> a = np.zeros((3, 3), dtype=np.int)
    >>> a[1, 1] = 1
    >>> a
    array([[0, 0, 0],
           [0, 1, 0],
           [0, 0, 0]])
    >>> a = ma.masked_equal(a, 1)
    >>> a
    masked_array(data =
     [[0 0 0]
     [0 -- 0]
     [0 0 0]],
          mask =
     [[False False False]
     [False  True False]
     [False False False]],
          fill_value=999999)
    >>> ma.mask_rows(a)
    masked_array(data =
     [[0 0 0]
     [-- -- --]
     [0 0 0]],
          mask =
     [[False False False]
     [ True  True  True]
     [False False False]],
          fill_value=999999)

    i(
R(RVRO((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyRBs+cC`
s
t|d
�S(s�
    Mask columns of a 2D array that contain masked values.

    This function is a shortcut to ``mask_rowcols`` with `axis` equal to 1.

    See Also
    --------
    mask_rowcols : Mask rows and/or columns of a 2D array.
    masked_where : Mask where a condition is met.

    Examples
    --------
    >>> import numpy.ma as ma
    >>> a = np.zeros((3, 3), dtype=np.int)
    >>> a[1, 1] = 1
    >>> a
    array([[0, 0, 0],
           [0, 1, 0],
           [0, 0, 0]])
    >>> a = ma.masked_equal(a, 1)
    >>> a
    masked_array(data =
     [[0 0 0]
     [0 -- 0]
     [0 0 0]],
          mask =
     [[False False False]
     [False  True False]
     [False False False]],
          fill_value=999999)
    >>> ma.mask_cols(a)
    masked_array(data =
     [[0 -- 0]
     [0 -- 0]
     [0 -- 0]],
          mask =
     [[False  True False]
     [False  True False]
     [False  True False]],
          fill_value=999999)

    i
(
R(RVRO((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyRos+cC`
s�tj
|�
j}|d
|d }|g
}|dk	rL|jd|�
n|
dk	rh|j|
�

nt|�
d
kr�t|�
}n|S(s!

    Compute the differences between consecutive elements of an array.

    This function is the equivalent of `numpy.ediff1d` that takes masked
    values into account, see `numpy.ediff1d` for details.

    See Also
    --------
    numpy.ediff1d : Equivalent function for ndarrays.

    i
i����iN(RcR�tflatRbR�RlRjR(RNtto_endtto_begintedRt((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR�s

	


cC`
sotj
|d
|
d|�
}t|t�r\t|�
}|djt�
|d<t|�
}n|jt�
}|S(s

    Finds the unique elements of an array.

    Masked values are considered the same element (masked). The output array
    is always a masked array. See `numpy.unique` for more details.

    See Also
    --------
    numpy.unique : Equivalent function for ndarrays.

    treturn_indextreturn_inversei(RRR*RFRGRHRXR/(tar1R�R�toutput((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR*�s

	




cC`
sc|rtj
||
f�
}n!tj
t|�
t|
�
f�
}|j�
|d
 |d|d
 kS(s.
    Returns the unique elements common to both arrays.

    Masked values are considered equal one to the other.
    The output is always a masked array.

    See `numpy.intersect1d` for more details.

    See Also
    --------
    numpy.intersect1d : Equivalent function for ndarrays.

    Examples
    --------
    >>> x = array([1, 3, 3, 3], mask=[0, 0, 0, 1])
    >>> y = array([3, 1, 1, 1], mask=[0, 0, 0, 1])
    >>> intersect1d(x, y)
    masked_array(data = [1 3 --],
                 mask = [False False  True],
           fill_value = 999999)

    i����i
(RcR4R*R?(R�tar2t
assume_uniquetaux((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR�s

!


cC`
s�|s!t|�
}t|
�
}
nt
j||
f�
}|jd
krI|S|j�
|j�}t
jtg
|d|d ktg
f�
}|d|d k}||S(s�
    Set exclusive-or of 1-D arrays with unique elements.

    The output is always a masked array. See `numpy.setxor1d` for more details.

    See Also
    --------
    numpy.setxor1d : Equivalent function for ndarrays.

    ii
i����(R*RcR4tsizeR?R5RI(R�R�R�R�tauxftflagtflag2((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR)�s






,
cC`
s�|s-t|d
t
�

\}}t|
�
}
ntj||
f�
}|jdd�
}||}|r{|d|d k}n|d|d k}tj||g
f�
}	|jdd�
t|�
 }
|r�|	|
S|	|
|SdS(s#

    Test whether each element of an array is also present in a second
    array.

    The output is always a masked array. See `numpy.in1d` for more details.

    See Also
    --------
    numpy.in1d : Equivalent function for ndarrays.

    Notes
    -----
    .. versionadded:: 1.4.0

    R�tkindt	mergesorti
i����N(R*RIRcR4targsortRj(R�R�R�tinverttrev_idxtartordertsartbool_arR�tindx((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyRs








cC`
stt
j||
f�
�
S(
s�
    Union of two arrays.

    The output is always a masked array. See `numpy.union1d` for more details.

    See also
    --------
    numpy.union1d : Equivalent function for ndarrays.

    (R*RcR4(R�R�((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR+7scC`
sS|rtj
|�
j�}nt|�
}t|
�
}
|t||
d
tdt�S(s�

    Set difference of 1D arrays with unique elements.

    The output is always a masked array. See `numpy.setdiff1d` for more
    details.

    See Also
    --------
    numpy.setdiff1d : Equivalent function for ndarrays.

    Examples
    --------
    >>> x = np.ma.array([1, 2, 3, 4], mask=[0, 1, 0, 1])
    >>> np.ma.setdiff1d(x, [1, 2])
    masked_array(data = [3 --],
                 mask = [False  True],
           fill_value = 999999)

    R�R�(RcR3R�R*RRI(R�R�R�((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR(Es



c
C`
stj
|d
ddtdt�
}tj|�
}|rR|j�rRtd�
�
n|jddkrnt}ntt	|�
�
}d|}|r�t
d	�
d	f}nd	t
d	�
f}|
d	kr�tj
|�
jt�
}n
t
|
dtd
ddt�
}
tj|
�
}|r-
|j�r-
td�
�
n|j�sE
|j�r�
|
j|jkr�
tj||�}	|	tk	r�
|	}|_|
_}t|_t|
_q�
q�
ntj||
f|�}tj
tj||f|��
jt�
}||jd|�
|8}|||fS(
s_
    Private function for the computation of covariance and correlation
    coefficients.

    tndminiR|RUsCannot process masked data.ii
RON(RcR2RItfloatR8R�R�RTR�tboolR�RbRRtlogical_nottastypeRJt
logical_orR=RYt_sharedmaskR4R�(
Rqt
ytrowvartallow_maskedtxmaskROttuptxnotmasktymasktcommon_mask((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyt
_covhelperfs8!


	












	


*

c	C`
s
|dk	r-|t
|�
kr-td
�
�
n|dkrQ|rHd}qQd}nt||
||�\}}}|s�tj|j|�d|}t|j|j�dt�
|j	�}nEtj||j�d|}t||jj�dt�
|j	�}|S(sJ
    Estimate the covariance matrix.

    Except for the handling of missing data this function does the same as
    `numpy.cov`. For more details and examples, see `numpy.cov`.

    By default, masked values are recognized as such. If `x` and `y` have the
    same shape, a common mask is allocated: if ``x[i,j]`` is masked, then
    ``y[i,j]`` will also be masked.
    Setting `allow_masked` to False will raise an exception if values are
    missing in either of the input arrays.

    Parameters
    ----------
    x : array_like
        A 1-D or 2-D array containing multiple variables and observations.
        Each row of `x` represents a variable, and each column a single
        observation of all those variables. Also see `rowvar` below.
    y : array_like, optional
        An additional set of variables and observations. `y` has the same
        form as `x`.
    rowvar : bool, optional
        If `rowvar` is True (default), then each row represents a
        variable, with observations in the columns. Otherwise, the relationship
        is transposed: each column represents a variable, while the rows
        contain observations.
    bias : bool, optional
        Default normalization (False) is by ``(N-1)``, where ``N`` is the
        number of observations given (unbiased estimate). If `bias` is True,
        then normalization is by ``N``. This keyword can be overridden by
        the keyword ``ddof`` in numpy versions >= 1.5.
    allow_masked : bool, optional
        If True, masked values are propagated pair-wise: if a value is masked
        in `x`, the corresponding value is masked in `y`.
        If False, raises a `ValueError` exception when some values are missing.
    ddof : {None, int}, optional
        If not ``None`` normalization is by ``(N - ddof)``, where ``N`` is
        the number of observations; this overrides the value implied by
        ``bias``. The default value is ``None``.

        .. versionadded:: 1.5

    Raises
    ------
    ValueError
        Raised if some values are missing and `allow_masked` is False.

    See Also
    --------
    numpy.cov

    sddof must be an integerii
g�?tstrictN(
RbR�R�R
RRRt
TtconjRJtsqueeze(	RqR�R�tbiasR
tddofR
tfactR�((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR�s6


		


+
(
cC`
s�d
}|tj
k	s$|tj
k	r7tj|t�
nt||
||�\}}}|s�tj|j|�d}t|j|j�dt	�
|j
�}	nAtj||j�d}t||jj�dt	�
|j
�}	ytj|	�
}
Wnt
k
r



dSX|j�r5
tjtjj|
|
��
}nw
t|
�
}t	|_|jd|}|r�
xH
t|d�
D]�}
xzt|
d|�D]e}tt||
||f�
�
jdd�
}tjtjj|�
�
||
|f<|||
f<q�
Wqr
Wn�x�t|d�
D]�}
x�t|
d|�D]}}tt|dd�|
f|dd�|ff�
�
jdd�
}tjtjj|�
�
||
|f<|||
f<q'Wq
W|	|S(s6
    Return Pearson product-moment correlation coefficients.

    Except for the handling of missing data this function does the same as
    `numpy.corrcoef`. For more details and examples, see `numpy.corrcoef`.

    Parameters
    ----------
    x : array_like
        A 1-D or 2-D array containing multiple variables and observations.
        Each row of `x` represents a variable, and each column a single
        observation of all those variables. Also see `rowvar` below.
    y : array_like, optional
        An additional set of variables and observations. `y` has the same
        shape as `x`.
    rowvar : bool, optional
        If `rowvar` is True (default), then each row represents a
        variable, with observations in the columns. Otherwise, the relationship
        is transposed: each column represents a variable, while the rows
        contain observations.
    bias : _NoValue, optional
        Has no effect, do not use.

        .. deprecated:: 1.10.0
    allow_masked : bool, optional
        If True, masked values are propagated pair-wise: if a value is masked
        in `x`, the corresponding value is masked in `y`.
        If False, raises an exception.  Because `bias` is deprecated, this
        argument needs to be treated as keyword only to avoid a warning.
    ddof : _NoValue, optional
        Has no effect, do not use.

        .. deprecated:: 1.10.0

    See Also
    --------
    numpy.corrcoef : Equivalent function in top-level NumPy module.
    cov : Estimate the covariance matrix.

    Notes
    -----
    This function accepts but discards arguments `bias` and `ddof`.  This is
    for backwards compatibility with previous versions of this function.  These
    arguments had no effect on the return values of the function and can be
    safely ignored in this and previous versions of numpy.
    s/bias and ddof have no effect and are deprecatedg�?R
i
RON(RRt_NoValuetwarningstwarntDeprecationWarningR
RR
R	
RJR

RctdiagonalR�R�tsqrtR�touterRR�RTR�RR-tvartreduce(RqR�R�R
R
R
tmsgR
R

t
ctdiagt_denomR�R�R�t_x((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR�s:0


+
(




!
	




,
>


A
;
tMAxisConcatenatorcB`
s#eZ
dZd
d�
Zd�ZRS(s�
    Translate slice objects to concatenation along an axis.

    For documentation on usage, see `mr_class`.

    See Also
    --------
    mr_class

    icC`
stj
||
d
t�

dS(Ntmatrix(RER`RJ(R^RO((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR`@s
c
C`
s�t|
t
�rtd
�
�
nt|
t�s9|
f
}
ng}g}d}xtt|
�
�
D]�
}t}t|
|t�r"
|
|j	}|
|j
}|
|j}	|dkr�d}n|dkr�d}nt|t�r

t
t|�
�
}
tj||	d|
�
}q�
tj||	|�}n�t|
|t
�r�
|
|dkrg
t|_|
|dk|_q^nyt
|
|�
|_w^Wq�
ttfk
r�



td�
�
q�
XnLt|
|�
tjkr�
t|
|g
�
}|j|�

t}n
|
|}|j|�

t|t�r^|r^|dkr1|j}qO|j|krO|j}qOq^q^W|dk	r�x(|D]}||j|�
||<qfWntt|�
d|j�

}|j |�
S(	NsUnavailable for masked array.ii
tnumtrcR
sUnknown special directiveRO(!RFtstrR0RGRbR�RjRJR�tsteptstarttstoptcomplexR�tabsRRtlinspaceR�RIR
tcolROR�R�R�t
ScalarTypeR3RlRCRUR�R4t_retval(
R^tkeytobjstscalarstfinal_dtypedescrRztscalarR!
R"
R#
R�tnewobjRu((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyt__getitem__Cs^

















	

	





	











	













(R[RwR]R`R0
(((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR
4s
tmr_classc
B`
seZ
dZd
�ZRS(sG

    Translate slice objects to concatenation along the first axis.

    This is the masked array version of `lib.index_tricks.RClass`.

    See Also
    --------
    lib.index_tricks.RClass

    Examples
    --------
    >>> np.ma.mr_[np.ma.array([1,2,3]), 0, 0, np.ma.array([4,5,6])]
    array([1, 2, 3, 0, 0, 4, 5, 6])

    c

C`
stj
|d
�
dS(Ni(R
R`(
R^((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR`�s
(R[RwR]R`(((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR1
vs
c
C`
szt|�
}
|
t
ks(tj|
�
rBtjd
|jdg�
Stj|
�
}t|�
d
krr|d
dgSdSdS(s�
    Find the indices of the first and last unmasked values.

    Expects a 1-D `MaskedArray`, returns None if all values are masked.

    Parameters
    ----------
    a : array_like
        Input 1-D `MaskedArray`

    Returns
    -------
    edges : ndarray or None
        The indices of first and last non-masked value in the array.
        Returns None if all values are masked.

    See Also
    --------
    flatnotmasked_contiguous, notmasked_contiguous, notmasked_edges,
    clump_masked, clump_unmasked

    Notes
    -----
    Only accepts 1-D arrays.

    Examples
    --------
    >>> a = np.ma.arange(10)
    >>> flatnotmasked_edges(a)
    [0,-1]

    >>> mask = (a < 3) | (a > 8) | (a == 5)
    >>> a[mask] = np.ma.masked
    >>> np.array(a[~a.mask])
    array([3, 4, 6, 7, 8])

    >>> flatnotmasked_edges(a)
    array([3, 8])

    >>> a[:] = np.ma.masked
    >>> print(flatnotmasked_edges(ma))
    None

    ii
i����N(	R7R=RRR�R2R�tflatnonzeroRjRb(RVRPtunmasked((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR�s-




cC`
s�t|�
}|
dks'|jd
kr1t|�
St|�
}ttj|j�
dtj|g
|j�
�

}t	gt
|j�
D]}||j|
�
j�^q��
t	gt
|j�
D]}||j
|
�
j�^q��
gS(s`
    Find the indices of the first and last unmasked values along an axis.

    If all values are masked, return None.  Otherwise, return a list
    of two tuples, corresponding to the indices of the first and last
    unmasked values respectively.

    Parameters
    ----------
    a : array_like
        The input array.
    axis : int, optional
        Axis along which to perform the operation.
        If None (default), applies to a flattened version of the array.

    Returns
    -------
    edges : ndarray or list
        An array of start and end indexes if there are any masked data in
        the array. If there are no masked data in the array, `edges` is a
        list of the first and last index.

    See Also
    --------
    flatnotmasked_contiguous, flatnotmasked_edges, notmasked_contiguous,
    clump_masked, clump_unmasked

    Examples
    --------
    >>> a = np.arange(9).reshape((3, 3))
    >>> m = np.zeros_like(a)
    >>> m[1:, 1:] = 1

    >>> am = np.ma.array(a, mask=m)
    >>> np.array(am[~am.mask])
    array([0, 1, 2, 3, 6])

    >>> np.ma.notmasked_edges(ma)
    array([0, 6])

    i
RQN(R3RbRRR8R2RRtindicesRTRGR�tmint
compressedR�(RVRORPR�R�((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR%�s*




1
8
c
C`
s�t|�
}
|
t
kr+td
|jd�Sd
}g}xbtj|
j��
D]K\}}tt	|�
�
}|s�|j
t|||��

n||7}qMW|p�dS(s^
    Find contiguous unmasked data in a masked array along the given axis.

    Parameters
    ----------
    a : narray
        The input array.

    Returns
    -------
    slice_list : list
        A sorted sequence of slices (start index, end index).

    See Also
    --------
    flatnotmasked_edges, notmasked_contiguous, notmasked_edges,
    clump_masked, clump_unmasked

    Notes
    -----
    Only accepts 2-D arrays at most.

    Examples
    --------
    >>> a = np.ma.arange(10)
    >>> np.ma.flatnotmasked_contiguous(a)
    slice(0, 10, None)

    >>> mask = (a < 3) | (a > 8) | (a == 5)
    >>> a[mask] = np.ma.masked
    >>> np.array(a[~a.mask])
    array([3, 4, 6, 7, 8])

    >>> np.ma.flatnotmasked_contiguous(a)
    [slice(3, 5, None), slice(6, 9, None)]
    >>> a[:] = np.ma.masked
    >>> print(np.ma.flatnotmasked_edges(a))
    None

    iN(R7R=R�R�Rbt	itertoolstgroupbyR�RjRHRl(RVRPR�R�Rzt
gR�((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR�s)




"




cC`
s�t|�
}|j
}|d
kr0td�
�
n|
dksH|dkrRt|�
Sg}|
dd
}ddg}tdd�||
<xBt|j|�
D]-}|||<|jt||�
p�d�

q�W|S(s�
    Find contiguous unmasked data in a masked array along the given axis.

    Parameters
    ----------
    a : array_like
        The input array.
    axis : int, optional
        Axis along which to perform the operation.
        If None (default), applies to a flattened version of the array.

    Returns
    -------
    endpoints : list
        A list of slices (start and end indexes) of unmasked indexes
        in the array.

    See Also
    --------
    flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges,
    clump_masked, clump_unmasked

    Notes
    -----
    Only accepts 2-D arrays at most.

    Examples
    --------
    >>> a = np.arange(9).reshape((3, 3))
    >>> mask = np.zeros_like(a)
    >>> mask[1:, 1:] = 1

    >>> ma = np.ma.array(a, mask=mask)
    >>> np.array(ma[~ma.mask])
    array([0, 1, 2, 3, 6])

    >>> np.ma.notmasked_contiguous(ma)
    [slice(0, 4, None), slice(6, 7, None)]

    is%Currently limited to atmost 2D array.i
iN(	R3RR�RbRR�R�RTRl(RVROR�R�totherR�R�((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR$.s)
	









!
c
C`
sU
|jd
kr|j
�}n|d
|d Aj�}
|
dd
}
|dr�t|
�
dkrstd|j�g
Std|
d�g
}|jd�t|
d
dd�|
ddd��D�
�

nat|
�
dkr�gSgt|
ddd�|
d
dd��D]\}}t||�^q
}|drQ
|jt|
d|j��

n|S(sv
    Finds the clumps (groups of data with the same values) for a 1D bool array.

    Returns a series of slices.
    i
i����ic
s`
s$|]\}
}t|
|�V
qdS(
N(
R�(R�tlefttright((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pys	<genexpr>zs
iN(	RR�tnonzeroRjR�R�textendtzipRl(RQR�R�R;
R<
((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyt_ezclumpjs 







1
K

 
c
C`
s<t|d
t
�}
|
t
kr1td|j�g
St|
�
S(s�
    Return list of slices corresponding to the unmasked clumps of a 1-D array.
    (A "clump" is defined as a contiguous region of the array).

    Parameters
    ----------
    a : ndarray
        A one-dimensional masked array.

    Returns
    -------
    slices : list of slice
        The list of slices, one for each continuous region of unmasked
        elements in `a`.

    Notes
    -----
    .. versionadded:: 1.4.0

    See Also
    --------
    flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges,
    notmasked_contiguous, clump_masked

    Examples
    --------
    >>> a = np.ma.masked_array(np.arange(10))
    >>> a[[0, 1, 2, 6, 8, 9]] = np.ma.masked
    >>> np.ma.clump_unmasked(a)
    [slice(3, 6, None), slice(7, 8, None)]

    RYi(RaR=R�R�R@
(RVRQ((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR
�s!


c
C`
s)tj
|�
}
|
tkrgSt|
�
S(
s
    Returns a list of slices corresponding to the masked clumps of a 1-D array.
    (A "clump" is defined as a contiguous region of the array).

    Parameters
    ----------
    a : ndarray
        A one-dimensional masked array.

    Returns
    -------
    slices : list of slice
        The list of slices, one for each continuous region of masked elements
        in `a`.

    Notes
    -----
    .. versionadded:: 1.4.0

    See Also
    --------
    flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges,
    notmasked_contiguous, clump_unmasked

    Examples
    --------
    >>> a = np.ma.masked_array(np.arange(10))
    >>> a[[0, 1, 2, 6, 8, 9]] = np.ma.masked
    >>> np.ma.clump_masked(a)
    [slice(0, 3, None), slice(6, 7, None), slice(8, 10, None)]

    (RcR7R=R@
(RVRQ((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR	�s!


cC`
s;tj
||
�}t|�
}|tk	r7d
||<n|S(sD
    Masked values in the input array result in rows of zeros.

    i(RRR,R7R=(RqR�t_vanderRP((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR,�s





c
C`
s�
t|�
}t|
�
}
t
|�
}|
jd
krKt|t
|
�
�}n^|
jdkr�t
t|
�
�
}|tk	r�t||dd�df�}q�ntd�
�
|dk	r 
t|�
}|jd
kr�td�
�
n|jd|
jdkr
td�
�
nt|t
|�
�}n|tk	rs
|}	|dk	rL
||	}nt	j
||	|
|	|||||�St	j
||
|||||�SdS(sE
    Any masked values in x is propagated in y, and vice-versa.

    i
iNis Expected a 1D or 2D array for y!s expected a 1-d array for weightss(expected w and y to have the same length(R3R7RR<RR=R�RbRTRRR&(
RqR�tdegtrcondtfullt
wRRPtmytnot_m((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyR&�s.






%










'((dR]t
__future__RR
Rt__all__R7
R
tR.RcR/R0R1R2R3R4R5R6R7R8R9R:R;R<R=R>R?R@RARBRRtnumpyRRRCR�tnumpy.core.umathtumathtnumpy.lib.function_baseRDtnumpy.lib.index_tricksRERLRbRR�R R!RZRRRR-R'RRRRRR{RRtfindtrstripRJRR"R�R
RRRRRRR*RR)RR+R(RIR
RR
RR
R1
R#RR%RR$R@
R
R	R,tdoc_noteR&(((sB/opt/alt/python27/lib64/python2.7/site-packages/numpy/ma/extras.pyt<module>
s�










�



		63	:L




	
	U	
	

bR218		-2 '	!+I
YB		73	5<		'	,"