| Current File : //usr/lib64/python2.7/site-packages/numpy/ma/extras.pyo |
�
E�`Qc * @ s\ d Z d Z d Z d Z d Z d d d d d d
d d d
d d d d d d d d d d d d d d d d d d d d! d" d# d$ d% d& d' d( d) d* d+ d, d- d. g* Z d/ d0 l Z d/ d0 l Z d/ d0 l Z d/ d1 l m
Z
m Z m Z m
Z
m Z m Z m Z m Z m Z m Z m Z m Z m Z m Z m Z m Z m Z m Z d/ d0 l Z d/ d2 l m Z m
Z d/ d0 l j j! Z! d/ d3 l" m# Z# d/ d4 l$ m% Z% d5 � Z& d0 d6 � Z( e) d7 � Z* d8 � Z+ d9 d^ d: � � YZ, e, d � Z- e, d � Z. e, d � Z/ e, d. � Z0 Z1 e, d � Z2 e, d
� Z3 e, d � Z4 e, d � Z5 e, d � Z6 d; � Z7 d< � Z8 e j8 j e8 _ d= � Z9 e j9 j e9 _ d0 d0 e: d> � Z; d0 d0 e: d? � Z< d0 d@ � Z= dA � Z> dB � Z? d0 dC � Z@ d0 dD � ZA d0 dE � ZB e: dF � ZC d0 d0 dG � ZD e: e: dH � ZE e: dI � ZF e: dJ � ZG e: dK � ZH dL � ZI e: dM � ZJ d0 eK eK dN � ZL d0 eK e: eK d0 dO � ZM d0 eK e: eK d0 dP � ZN dQ e# f dR � � YZO dS eO f dT � � YZP eP � ZQ dU � ZR d0 dV � ZS dW � ZT d0 dX � ZU dY � ZV dZ � ZW d[ � ZX d0 d\ � ZY e jZ e jY j eY j � eY _ d0 e: d0 e: d] � Z[ e jZ e j[ j e[ j � e[ _ d0 S(_ s�
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 $
s5 Pierre GF Gerard-Marchant ($Author: jarrod.millman $)s 1.0s $Revision: 3473 $s5 $Date: 2007-10-29 17:18:13 +0200 (Mon, 29 Oct 2007) $t apply_along_axist apply_over_axest
atleast_1dt
atleast_2dt
atleast_3dt averaget clump_maskedt clump_unmaskedt column_stackt
compress_colst compress_rowcolst
compress_rowst count_maskedt corrcoeft covt diagflatt dott dstackt ediff1dt flatnotmasked_contiguoust flatnotmasked_edgest hsplitt hstackt in1dt intersect1dt mask_colst mask_rowcolst mask_rowst
masked_allt masked_all_liket mediant mr_t notmasked_contiguoust notmasked_edgest polyfitt row_stackt setdiff1dt setxor1dt uniquet union1dt vandert vstacki����N( t MaskedArrayt MAErrort addt arrayt asarrayt concatenatet countt filledt getmaskt getmaskarrayt make_mask_descrt maskedt masked_arrayt mask_ort nomaskt onest sortt zeros( t ndarrayR- ( t AxisConcatenator( t lstsqc C s t | t t t f � r t St S( s+ Is seq a sequence (ndarray, list or tuple)?( t
isinstanceR< t tuplet listt Truet False( t seq( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyt
issequence5 s c C s t | � } | 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])
( R3 t sum( t arrt axist m( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR ; s 3 c C s4 t t 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')
t mask( R6 t npt emptyR9 R4 ( t shapet dtypet a( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR q s /c C s@ t j | � j t � } t j | j d 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')
RN ( RK t
empty_liket viewR* R9 RM R4 RN t _mask( RG RO ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR � s 2$t _fromnxfunctionc B s) e Z d Z d � Z d � Z d � Z RS( 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``).
c C s | | _ | j � | _ d S( N( t __name__t getdoct __doc__( t selft funcname( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyt __init__� s c C sc t t | j d � } t | d d � } | r_ | j t j | � } d } d j | | | f � Sd S( 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
RV sL Notes
-----
The function is applied to both the _data and the _mask, if any.s
N( t getattrRK RT t Nonet mat get_object_signaturet join( RW t npfunct doct sigt locdoc( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyRU � s c
O s� t t | j � } t | � d k r| 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 | �Sn� g } t
| � } x< t | � d k rWt | d � rW| j
| j d � � q Wg } xZ | D]R } | t j | � | | � } | t | � | | � } | j
t | d | �� qeW| Sd S( Ni i RJ ( RZ RK RT t lenR? R< t __array__R3 R6 R@ RA R. RE t appendt pop(
RW t argst paramst funct xt _dt _mRO t arrayst res( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyt __call__ s*
1. %
( RT t
__module__RV RY RU Ro ( ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyRS � s c C s\ d } xO | t | � k rW x, t | | d � rI | | | | | d +q W| d 7} q W| S( s Flatten a sequence in place.i t __iter__i ( Rc t hasattr( RD t k( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyt flatten_inplace; s c O s� t | d t d t �} | j } | d k r: | | 7} n | | k r_ t d | | f � � n d g | d } t j | d � } t | � } | j | � t d
d
� | | <t j | j � j
| � } | j | | � | j � }
| | t | j � � | | � } t j | � } | sGy t | � WqGt k
rCt } qGXn g }
| r�|
j t j | � j � t | t � } | | t | � <t j | � } d } x�| | k r}| d c d 7<d } xP | | | | k r| d | k r| | d c d 7<d | | <| d 8} q�W| j | | � | | t | j � � | | � } | | t | � <|
j t | � j � | d 7} q�Wn�t | d t d t �} | j � }
t d
d
� g | j |
| <|
j | | � t j | � } | } t | j � } | j | | <|
j t | � j � t | � } t | t � } | | t t |
j � � � <d } x� | | k rO| d c d 7<d } xP | | | | k r�| d | k r�| | d c d 7<d | | <| d 8} q~W| j | | � |
j | | � | | t | j � � | | � } | | t t |
j � � � <|
j t | � j � | d 7} qYWt j t j |
� j � � } t | d � s�t j | d | �} n$ t | d | �} t j | � | _ | S( s0
(This docstring should be overwritten)
t copyt suboki s2 axis must be less than arr.ndim; axis=%d, rank=%d.i t Oi����RR RN N( R- RC RB t ndimt
ValueErrorRK R; t ranget removet sliceR[ R. RM t taket putRu R@ t tolistt isscalarRc t TypeErrorRe RN t objectt productRA Rt t maxRr R\ t default_fill_valuet
fill_value( t func1dRH RG Rg t kwargst ndt indt it indlistt outshapet jRn t asscalart dtypest outarrt NtotRs t nt holdshapet
max_dtypest result( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR E s�
"
'
"
'
" c C s t j | � } t | � } | j } t | � j d k rE | f } n x� | D]� } | d k rk | | } n | | f } t j | | | f � d | | | f � �} | j | j k r� | j | j } } qL t j | | � } | j | j k r| j | j } } qL t d � � qL W| S( s.
(This docstring will be overwritten)
i RJ s3 Function is not returning an array of correct shape(
RK R. R3 Rx R- R\ t _dataRR t expand_dimsRy ( Ri RO t axest valt mskt NRH Rg Rn ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR � s"
-c
C sQ t | � } | j } | j } | d k r3 d } n | d
k rb| t k r� | d
k r{ | j d d
� } t | j � } q_t | d � j � } t
j j | j
j � | � } t
j j | � } ~ qW| d
k r| j d � j d d
� } t t
j j | j � � � } qWt t | d � t d | �j � } t j | j � | � } t j | � } ~ n�| t k r�| d
k r�| | d } t j | j
| d t �} qWt | d � } | j } | d k r�d } n | | k r%t j | t d d �} t j | | | � } t j | | � } ~ qW| | | f k r�| | }
d
g t | � } t d
d
d � | | <t d t t | � � d
� } t j | | | d t �} t j | | d t �} ~ ~ qWt d � � n�| d
k r t j | | d t �} t
j j | d | d t �} n:t | d � } | j } | d k rJd } n | | k r�t | d t d | d d �} t j | | | d t �} t j | | d t �} n� | | | f k rH| | }
d
g t | � } t d
d
d � | | <t d t t | � � d � } t j | | | d t �} t j | | d t �} n t d � � ~ | t k so| t k rst S| | } ~ t | t � r9| d
k s�| d k r�| j d k r�| j t k r�| j
} n | r9t | t � s�t | � } n t | t � r6| j | j k r6t | j d t �| } q6q9n | rI| | f S| Sd
S( s(
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 the variance is computed. The default is to compute
the variance of 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.
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, otherwise it is of the same type as `a`.
If returned, `sum_of_weights` is of the same type as `average`.
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]
i RH g i RJ g �?RN Ru s w[s ] * ones(ash, float)s average: weights wrong shape.s( ] * masked_array(ones(ash, float), mask)N( ( i ( ( i ( ( i ( R. RJ RM R[ R8 RF t floatt sizeR1 t ravelt umathR, t reduceR� R- RK Rc R| t evalt reprR@ Ry R5 R? R* Rx R6 R< R9 (
RO RH t weightst returnedRJ t ashR� t dt wt wsht nit rR� ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR � s� 1 "$
"
' ""
c C s� d � } | rM | d k r4 | j � } | j � q_ | j d | � | } n t | d | �} | d k rz | | � } n t | | | � } | d k r� | } n | S( sA
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.
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.extras.median(x)
1.5
>>> x = np.ma.array(np.arange(10).reshape(2, 5), mask=[0]*6 + [1]*4)
>>> np.ma.extras.median(x)
2.5
>>> np.ma.extras.median(x, axis=-1, overwrite_input=True)
masked_array(data = [ 2. 5.],
mask = False,
fill_value = 1e+20)
c S sn t t | � d � } t | d � \ } } | rF t | | d � } n t | d | d � } | | j d � S( Ni i i ( R1 R0 t divmodR| t mean( t datat countst idxt rmdt choice( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyt _median1D� s RH N( R[ R� R: R ( RO RH t outt overwrite_inputR� t asortedR� ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR F s <
c C s' t | � } | j d k r* t d � � n t | � } | t k sO | j � rV | j S| j � rl t g � St t
| � � t | j d � } } | j � } | s� x+ t
j | d � D] } | j | � q� Wn | d k r x+ t
j | d � D] } | j | � q� Wn | j | d d � | f 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
----------
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.extras.compress_rowcols(x)
array([[7, 8]])
>>> np.ma.extras.compress_rowcols(x, 0)
array([[6, 7, 8]])
>>> np.ma.extras.compress_rowcols(x, 1)
array([[1, 2],
[4, 5],
[7, 8]])
i s$ compress2d works for 2D arrays only.i i i����N( Ni i����( R. Rx t NotImplementedErrorR2 R8 t anyR� t allt nxarrayRz Rc RM t nonzeroRK R& R{ R[ ( Rj RH RI t idxrt idxcR5 R� R� ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR
� s" /
& c C s
t | d � S( s�
Suppress whole rows of a 2-D array that contain masked values.
This is equivalent to ``np.ma.extras.compress_rowcols(a, 0)``, see
`extras.compress_rowcols` for details.
See Also
--------
extras.compress_rowcols
i ( R
( RO ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR � s c C s
t | d � S( s�
Suppress whole columns of a 2-D array that contain masked values.
This is equivalent to ``np.ma.extras.compress_rowcols(a, 1)``, see
`extras.compress_rowcols` for details.
See Also
--------
extras.compress_rowcols
i ( R
( RO ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR � s c C s� t | � } | j d k r* t d � � n t | � } | t k sO | j � rS | S| j � } | j j � | _ | s� t | t
j | d � <n | d k r� t | d d � t
j | d � f <n | S( s�
Mask rows and/or columns of a 2D array that contain masked values.
Mask whole rows and/or columns of a 2D array that contain
masked values. The masking behavior is selected using the
`axis` parameter.
- If `axis` is None, rows *and* columns are masked.
- If `axis` is 0, only rows are masked.
- If `axis` is 1 or -1, only columns are masked.
Parameters
----------
a : array_like, MaskedArray
The array to mask. If not a MaskedArray instance (or if no array
elements are masked). The result is a MaskedArray with `mask` set
to `nomask` (False). Must be a 2D array.
axis : int, optional
Axis along which to perform the operation. If None, applies to a
flattened version of the array.
Returns
-------
a : MaskedArray
A modified version of the input array, masked depending on the value
of the `axis` parameter.
Raises
------
NotImplementedError
If input array `a` is not 2D.
See Also
--------
mask_rows : Mask rows of a 2D array that contain masked values.
mask_cols : Mask cols of a 2D array that contain masked values.
masked_where : Mask where a condition is met.
Notes
-----
The input array's mask is modified by this function.
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_rowcols(a)
masked_array(data =
[[0 -- 0]
[-- -- --]
[0 -- 0]],
mask =
[[False True False]
[ True True True]
[False True False]],
fill_value=999999)
i s$ compress2d works for 2D arrays only.i i i����N( Ni i����(
R. Rx R� R2 R8 R� R� RR Ru R5 RK R& R[ ( RO RH RI t maskedval( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR s K &c C 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 ( RO RH ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR Z s +c C 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 ( RO RH ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR � s +c C s� | r? | j d k r? | j d k r? t | � } t | � } n t j t | d � t | d � � } t | � } t | � } t j | | � } t | d | �S( s�
Return the dot product of two arrays.
.. note::
Works only with 2-D arrays at the moment.
This function is the equivalent of `numpy.dot` that takes masked values
into account, see `numpy.dot` for details.
Parameters
----------
a, b : ndarray
Inputs arrays.
strict : bool, optional
Whether masked data are propagated (True) or set to 0 (False) for the
computation. Default is False.
Propagating the mask means that if a masked value appears in a row or
column, the whole row or column is considered masked.
See Also
--------
numpy.dot : Equivalent function for ndarrays.
Examples
--------
>>> a = ma.array([[1, 2, 3], [4, 5, 6]], mask=[[1, 0, 0], [0, 0, 0]])
>>> b = ma.array([[1, 2], [3, 4], [5, 6]], mask=[[1, 0], [0, 0], [0, 0]])
>>> np.ma.dot(a, b)
masked_array(data =
[[21 26]
[45 64]],
mask =
[[False False]
[False False]],
fill_value = 999999)
>>> np.ma.dot(a, b, strict=True)
masked_array(data =
[[-- --]
[-- 64]],
mask =
[[ True True]
[ True False]],
fill_value = 999999)
i i RJ ( Rx R R RK R R1 R3 R6 ( RO t bt strictR� t amt bmRI ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR � s /$ $
c C s� t j | � j } | d | d } | g } | d k rL | j d | � n | d k rh | j | � n t | � d k r� 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����i N( R\ t
asanyarrayt flatR[ t insertRe Rc R ( RG t to_endt to_begint edRm ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR � s c C so t j | d | d | �} t | t � r\ t | � } | d j t � | d <t | � } n | j t � } | 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_indext return_inversei ( RK R& R? R@ RA RQ R* ( t ar1R� R� t output( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR& s c C sc | r t j | | f � } n! t j t | � t | � f � } | j � | d | d | d k S( 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 ( R\ R/ R& R: ( R� t ar2t
assume_uniquet aux( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR ( s
!
c C s� | s! t | � } t | � } n t j | | f � } | j d k rI | S| j � | j � } t j t g | d | d k t g 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.
i i i����( R& R\ R/ R� R: R1 RB ( R� R� R� R� t auxft flagt flag2( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR% H s
,c
C s� | s- t | d t �\ } } t | � } n t j | | f � } | j d d � } | | } | d | d k } t j | t g f � } | j d d � t | � } | r� | | S| | | Sd S( 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� t kindt mergesorti i����N( R& RB R\ R/ t argsortRC Rc (
R� R� R� t rev_idxt art ordert sart equal_adjR� t indx( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR b s
c C s t t 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& R\ R/ ( R� R� ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR' � s c C sd | s! t | � } t | � } n t | | d t �} | j d k rI | St j | � | d k Sd 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.extras.setdiff1d(x, [1, 2])
masked_array(data = [3 --],
mask = [False True],
fill_value = 999999)
R� i N( R& R RB R� R\ R. ( R� R� R� R� ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR$ � s c
C s t j | d d d t d t �} t j | � } | rR | j � rR t d � � n | j d d k rn t } n t t | � � } d | } | r� t
d � d f } n d t
d � f } | d k r� t j
| � j t � } nt | d t d d d t �} t j | � } | r-| j � r-t d � � n | j � sE| j � r�| j | j k r�t j | | � } | t k r�| j � | j � | } | _ | _ } q�q�n t j | | f | � } t j
t j | | f | � � j t � } | | j d | � | 8} | | | f S(
s_
Private function for the computation of covariance and correlation
coefficients.
t ndmini Ru RN s Cannot process masked data...i i RH N( R\ R- RB R� R3 R� Ry RM t intt boolR| R[ RK t logical_nott astypeRC t
logical_orR8 t unshare_maskRR R/ R� (
Rj t yt rowvart allow_maskedt xmaskRH t tupt xnotmaskt ymaskt common_mask( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyt
_covhelper� s8 !
!*c C s | d k r- | t | � k r- t d � � n | d k rQ | rH d } qQ d } n t | | | | � \ } } } | s� t j | j | � d | } t | j | j � d t �| j � } nE t j | | j � d | } t | | j j � d t �| j � } | S( sK
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
.. versionadded:: 1.5
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``.
Raises
------
ValueError:
Raised if some values are missing and `allow_masked` is False.
See Also
--------
numpy.cov
s ddof must be an integeri i g �?R� N(
R[ R� Ry R� RK R t Tt conjRC t squeeze( Rj R� R� t biasR� t ddofR� t factR� ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR � s 6 + (c C s� | d k r- | t | � k r- t d � � n | d k rQ | rH d } qQ d } n t | | | | � \ } } } | s� t j | j | � d | } t | j | j � d t �| j � } nE t j | | j � d | } t | | j j � d t �| j � } y t
j | � } Wn t k
r)d SX| j � rWt
j
t
j j | | � � }
n�t | � }
| j d | } | r x\t | d � D]� } x� t | d | � D]o }
t t | | | |
f � � j d d d d | � } t
j
t
j j | � � |
| |
f <|
|
| f <q�Wq�Wn� x� t | d � D]� } x� t | d | � D]� }
t t | d d � | f | d d � |
f f � � j d d d d | � } t
j
t
j j | � � |
| |
f <|
|
| f <qJWq0W| |
S( s�
Return correlation coefficients of the input array.
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 : bool, optional
Default normalization (False) is by ``(N-1)``, where ``N`` is the
number of observations given (unbiased estimate). If `bias` is 1,
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 an exception.
ddof : {None, int}, optional
.. versionadded:: 1.5
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``.
See Also
--------
numpy.corrcoef : Equivalent function in top-level NumPy module.
cov : Estimate the covariance matrix.
s ddof must be an integeri i g �?R� RH R� N( R[ R� Ry R� RK R R� R� RC R� R\ t diagonalR� t sqrtt multiplyt outerR RM Rz R R) t varR� ( Rj R� R� R� R� R� R� R� t ct diagt _denomR� R� R� t _x( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR
- s@ + + (
! )
>A
;t MAxisConcatenatorc B s# e Z d Z d d � Z d � Z RS( s�
Translate slice objects to concatenation along an axis.
For documentation on usage, see `mr_class`.
See Also
--------
mr_class
i c C s t j | | d t �d S( Nt matrix( R= RY RC ( RW RH ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyRY � s c
C s� t | t � r t d � � n t | � t k r< | f } n g } g } d } xt t | � � D] } t } t | | � t k r1| | j
} | | j } | | j } | d k r� d } n | d k r� d } n t | � t d � k rt
t | � � }
t j | | d |
�} qt j | | | � } n� t | | � t k r�| | d k ryt | _ | | d k | _ qa n y t
| | � | _ wa Wqt t f k
r�t d � � qXnL t | | � t j k r�t | | g � } | j | � t } n
| | } | j | � t | t � ra | ra | d k rC| j } qa| j | k ra| j } qaqa qa W| d k r�x( | D] } | | j | � | | <qxWn t t | � d | j �} | j | � S(
Ns Unavailable for masked array.i i y �?t numt rcR� s Unknown special directiveRH ( R? t strR+ t typeR@ R[ Rz Rc RC R| t stept startt stopR� t absRK t linspacet arangeRB R� t colRH Ry R� t
ScalarTypeR. Re R< RN R� R/ t _retval(
RW t keyt objst scalarst final_dtypedescrRs t scalarR R R R� t newobjRn ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyt __getitem__� s^
( RT Rp RV RY R ( ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR� � s
t mr_classc B s e Z d Z d � Z RS( 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 s t j | d � d S( Ni ( R� RY ( RW ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyRY � s ( RT Rp RV RY ( ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR � s c C sz t | � } | t k s( t j | � rB t j d | j d g � St j | � } t | � d k rr | d d g Sd Sd S( s�
Find the indices of the first and last unmasked values.
Expects a 1-D `MaskedArray`, returns None if all values are masked.
Parameters
----------
arr : 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
i i i����N( R2 R8 RK R� R- R� t flatnonzeroRc R[ ( RO RI t unmasked( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR � s - c C s� t | � } | d k s' | j d k r1 t | � St | � } t t j | j � d t j | g | j � �} t g t
| j � D] } | | j | � j � ^ q� � t g t
| j � D] } | | j
| � j � ^ q� � g S( sg
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.extras.notmasked_edges(ma)
array([0, 6])
i RJ N( R. R[ Rx R R3 R- RK t indicesRM R@ Rz t mint
compressedR� ( RO RH RI R� R� ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR! s *
18c C s� t | � } | t k r+ t d | j d � Sd } g } xb t j | j � � D]K \ } } t t | � � } | s� | j
t | | | � � n | | 7} qM W| p� d S( sr
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.extras.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.extras.flatnotmasked_contiguous(a)
[slice(3, 5, None), slice(6, 9, None)]
>>> a[:] = np.ma.masked
>>> print np.ma.extras.flatnotmasked_edges(a)
None
i N( R2 R8 R| R� R[ t itertoolst groupbyR� Rc RA Re ( RO RI R� R� Rs t gR� ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR L s ) " c C s� t | � } | j } | d k r0 t d � � n | d k sH | d k rR t | � Sg } | d d } d d g } t d d � | | <xB t | j | � D]- } | | | <| j t | | � 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.extras.notmasked_contiguous(ma)
[slice(0, 4, None), slice(6, 7, None)]
i s% Currently limited to atmost 2D array.i i N( R. Rx R� R[ R R| Rz RM Re ( RO RH R� R� t otherR� R� ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR � s )
!c C s� | j d k r | j � } n | d | d j � } | d d } g t t j d g | � t j | t | � g � � D] \ } } t | | � ^ qx } | S( sv
Finds the clumps (groups of data with the same values) for a 1D bool array.
Returns a series of slices.
i i����i ( Rx R� R� t zipR t chainRc R| ( RJ R� t leftt rightt slices( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyt _ezclump� s =c C sz t | d t � } | t k r1 t d | j � g St | � } | d t k rc | d d d � } n | d d d � } | 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.extras.clump_unmasked(a)
[slice(3, 6, None), slice(7, 8, None)]
RR i i Ni ( RZ R8 R| R� R R5 ( RO RJ R R� ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR � s ! c C sw t j | � } | t k r g St | � } t | � rs | d t k r] | d d d � } qs | d d d � } n | 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.extras.clump_masked(a)
[slice(0, 3, None), slice(6, 7, None), slice(8, 10, None)]
i Ni i ( R\ R2 R8 R Rc R5 ( RO RJ R ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR � s ! c C s; t j | | � } t | � } | t k r7 d | | <n | S( sC
Masked values in the input array result in rows of zeros.
i ( RK R( R2 R8 ( Rj R� t _vanderRI ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR( , s
c C si t | � } t | � } t | � } | j d k rK t | t | � � } n^ | j d k r� t t | � � } | t k r� t | | d d � d f � } q� n t d � � | d k rt | � } | j d k r� t d � n | j d | j d k rt d � n t | t | � � } n | t k rJ| d k r@| | } qJ| } n t j
| | | | | | | � S( sD
Any masked values in x is propagated in y, and vice-versa.
i i Ni s 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( R. R2 Rx R7 R R8 R� R[ RM RK R" ( Rj R� t degt rcondt fullR� R RI t my( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyR" 8 s, %
( (\ RV t
__author__t __version__t __revision__t __date__t __all__R t warningst coreR\ R* R+ R, R- R. R/ R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R: R; t numpyRK R< R� t numpy.core.umathR� t numpy.lib.index_tricksR= t numpy.linalgR> RE R[ R R� R R RS R R R R) R# R R R R R Rt R R RC R R R
R R R R R R R R& R R% R R' R$ RB R� R R
R� R R R R! R R R R R R( t doc_noteR" ( ( ( s5 /usr/lib64/python2.7/site-packages/numpy/ma/extras.pyt <module>
s� v 6 3 :I
U �Z D Z - . > $ %+IZB 7 3 5 < , 2 !