\Kc @ s 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, d- d. d/ d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 d: d; d< d= d> d? d@ dA dB dC dD dE dF dG dH dI dJ dK dL dM dN dO dP dQ dR dS dT dU dV dW dX dY dZ d[ d\ d] d^ d_ d` da db dc dd de df dg dh di dj dk dl dm dn do dp dq dr ds dt du dv dw dx dy dz 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 d d d d d d d d d d d d g Z d d k Z d d k Z d d k Z d d k l Z l Z l
Z
l Z l Z d d k l
Z d d k i i Z d d k i i Z d d k l Z l Z d d k l Z d d k Z e i Z e d Z e i d d d Z d Z d e f d YZ! d e! f d YZ" h e# d 6d d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6Z$ e i% Z& e& i' g Z( e i) e i* g D] Z+ e( e+ e i, f q[( e i- Z. e. i' g Z/ e i) e i* g D] Z+ e/ e+ e i,
f q[/ d e i0 j o> e& i' e i1 e i, f g e. i' e i1 e i,
f g n d Z2 d Z3 d Z4 d Z5 d Z6 d Z7 d Z8 d Z9 d Z: d Z; e< d Z= d Z> e# d Z? e? Z@ e e# e< d ZA h ZB h ZC d f d YZD d f d YZE d f d YZF d f d YZG d f d YZH d f d YZI d f d YZJ d f d YZK eI e iL ZL eI e iM ZM eI e iN ZN eI e iO ZO eI e iP ZP eI e iQ ZQ eI e iR ZR eI e iS ZS eI e iT ZT eI e iU ZU eI e iV ZW ZV eI e iX ZX eI e iY ZY eI e iZ ZZ eI e i[ Z[ eI e i\ Z] eI e i^ Z^ eI e i_ d eH d Z_ eI e i` d eG d Z` eI e ia d eG d Za eI e iP d eE d ZP eI e ib d eD d d Zb eI e ic d eD d d Zc eI e id d eH d Zd eI e ie d eD d d d d Ze eJ e if Zf eJ e ig Zg eJ e ih d d Zh eJ e ii d d Zi eJ e ij Zj e< ej _k eJ e il Zl e< el _k eJ e im Zm e< em _k eJ e in Zn e< en _k eJ e io Zo e< eo _k eJ e ip Zp e< ep _k eJ e iq Zq eJ e iq d d ik Zr eJ e is Zs es ik Zt eJ e iu Zu eJ e iv Zv eJ e iw Zw eJ e ix Zx eJ e iy Zy eK e iz eF d d Zz eK e i{ eF d d Z{ eK e i| eF d d Z| eK e i} eF d d Z} eK e i~ eF d d Z~ eK e i eF d d Z e d Z d Z d Z e Z d Z d Z e e# e< e d Z e< d Z e e# d Z d Z d Z e# d Z e# d Z e# d Z e# d Z e# d Z e# d Z e# d Z e# d Z e# d Z e# e# d Z dde# e# d Z e# d Z d f d
YZ e d Z d Z e d
ddddddd Z d Z de f d YZ de f d YZ d Z d e f d YZ d Z d Z e Z e Z e d d e i d e# Z e Z e Z e< e e e e< e# e e# e# d d
Z
e i e
_ d! Z d"e f d# YZ d$e f d% YZ d&e f d' YZ e< e< e< d( Z e i i e _ e< e< e< d) Z e i i e _ e< e< e< d* Z e i i e _ d+f d, YZ e d Z e d Z Z e d Z e d* Z e d2 Z e d3 Z e d. Z e d6 Z e dP Z e dS Z e Z e d~ Z e Z e d Z e d Z e d Z e d Z e d Z e d- Z e d Z e d Z e d Z e d Z e d Z e d Z e d Z e< d. Z e< d/e< e< d0 Z e i i e _ e< e< d1 Z e i i e _ e< e< d2 Z e i i e _ d d/e< e# e< d3 Z e i i e _ d4 Z d d5 Z e< d6 Z e i i e _ d d7 Z d8 Z d9 Z d: Z d;d< Z d= Z e< d> Z d?d@ Z dA Z dB Z e i i e _ dC Z e i i e _ e< dD Z e i i e _ e< e< dE Z e< d;dF Z d e< dG Z\ e\ Z dH Z e e i i dI e _ e Z dJ Z e e i i dI e _ e Z e# dK Z e# dde< dL Z e< e< dM Z e< dN Z dO Z dP Z dQ Z dR Z e d dSdT Z dU Z dVf dW YZ e d Z e i Z e i Z e d; Z e d< Z e dH Z e dJ Z e dR Z e i Z e d Z e d Z e i Z d S(X s
numpy.ma : a package to handle missing or invalid values.
This package was initially written for numarray by Paul F. Dubois
at Lawrence Livermore National Laboratory.
In 2006, the package was completely rewritten by Pierre Gerard-Marchant
(University of Georgia) to make the MaskedArray class a subclass of ndarray,
and to improve support of structured arrays.
Copyright 1999, 2000, 2001 Regents of the University of California.
Released for unlimited redistribution.
* Adapted for numpy_core 2005 by Travis Oliphant and (mainly) Paul Dubois.
* Subclassing of the base `ndarray` 2006 by Pierre Gerard-Marchant
(pgmdevlist_AT_gmail_DOT_com)
* Improvements suggested by Reggie Dugard (reggie_AT_merfinllc_DOT_com)
.. moduleauthor:: Pierre Gerard-Marchant
s Pierre GF Gerard-Marchants restructuredtext ent MAErrort MaskErrort MaskTypet MaskedArrayt bool_t abst absolutet addt allt allcloset allequalt alltruet amaxt amint anomt anomaliest anyt aranget arccost arccosht arcsint arcsinht arctant arctan2t arctanht argmaxt argmint argsortt aroundt arrayt asarrayt
asanyarrayt bitwise_andt
bitwise_ort bitwise_xort ceilt chooset clipt common_fill_valuet compresst
compressedt concatenatet conjugatet copyt cost cosht countt cumprodt cumsumt default_fill_valuet diagt diagonalt difft dividet dumpt dumpst emptyt
empty_liket equalt expt expand_dimst fabst flatten_maskt fmodt filledt floort floor_dividet fix_invalidt flatten_structured_arrayt
frombuffert fromflext fromfunctiont getdatat getmaskt getmaskarrayt greatert
greater_equalt harden_maskt hypott identityt idst indicest innert innerproductt isMAt
isMaskedArrayt is_maskt is_maskedt isarrayt
left_shiftt lesst
less_equalt loadt loadst logt log10t logical_andt logical_nott
logical_ort logical_xort make_maskt make_mask_descrt make_mask_nonet mask_ort maskedt masked_arrayt masked_equalt masked_greatert masked_greater_equalt
masked_insidet masked_invalidt masked_lesst masked_less_equalt masked_not_equalt
masked_objectt masked_outsidet masked_print_optiont masked_singletont
masked_valuest masked_wheret maxt maximumt maximum_fill_valuet meant mint minimumt minimum_fill_valuet modt multiplyt negativet nomaskt nonzerot not_equalt onest outert outerproductt powert prodt productt ptpt putt putmaskt rankt ravelt remaindert repeatt reshapet resizet right_shiftt round_t roundt set_fill_valuet shapet sint sinht sizet sometruet sortt soften_maskt sqrtt squeezet stdt subtractt sumt swapaxest taket tant tanht tracet transposet true_dividet vart wheret zerosiN( t ndarrayR R
t iscomplexobjR ( R ( t
getargspect
formatargspec( R< i t ignorec C s8 | d j o d S| d j o | Sd } | | | f S( s8
Adds a Notes section to an existing docstring.
Ns(
%s
Notes
-----
%s
( t None( t
initialdoct notet newdoc( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt doc_noteo s
c C s> y t t | } Wn! t j
o } d } d } n X| S( s$
Get the signature from obj
sG Unable to retrieve the signature of %s '%s'
(Initial error message: %s)t ( R R t TypeError( t objt sigt errmsgt msg( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt get_object_signature s c B s e Z d Z RS( s& Class for masked array related errors.( t __name__t
__module__t __doc__( ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s c B s e Z d Z RS( s Class for mask related errors.( R R R ( ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s t bg@x Dy t ct fi?B t it ?t Os N/At St us ???t Vt Ut float128c C s0 t | d o t d
| i } nt | t i oC | i o t i | i d i d } q,t i | i d } n t | t
o t d } n t | t p t | t o t d } ne t | t
o t d } nG t | t o t d } n) t | t o t d } n t d } | S( sh
Return the default fill value for the argument object.
The default filling value depends on the datatype of the input
array or the type of the input scalar:
======== ========
datatype default
======== ========
bool True
int 999999
float 1.e20
complex 1.e20+0j
object '?'
string 'N/A'
======== ========
Parameters
----------
obj : ndarray, dtype or scalar
The array data-type or scalar for which the default fill value
is returned.
Returns
-------
fill_value : scalar
The default fill value.
Examples
--------
>>> np.ma.default_fill_value(1)
999999
>>> np.ma.default_fill_value(np.array([1.1, 2., np.pi]))
1e+20
>>> np.ma.default_fill_value(np.dtype(complex))
(1e+20+0j)
t dtypei R R R R R R R N( t hasattrt _check_fill_valueR R t
isinstancet npt subdtypet default_fillert gett kindt floatt intt longt strt unicodet complex( R t defval( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR1 s$ (
c C sZ | i } | oB g } x. | D]& } t | | | } | i | q Wt | S| | S( N( t namest _recursive_extremum_fill_valuet appendt tuple( t ndtypet extremumR t deflistt namet fval( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s c C s d } t | d o t | i t St | t o t t i d St | t o t t i d St | t o t t i d St | t
i o t | St | d S( sX
Return the maximum value that can be represented by the dtype of an object.
This function is useful for calculating a fill value suitable for
taking the minimum of an array with a given dtype.
Parameters
----------
obj : ndarray or dtype
An object that can be queried for it's numeric type.
Returns
-------
val : scalar
The maximum representable value.
Raises
------
TypeError
If `obj` isn't a suitable numeric type.
See Also
--------
maximum_fill_value : The inverse function.
set_fill_value : Set the filling value of a masked array.
MaskedArray.fill_value : Return current fill value.
Examples
--------
>>> import numpy.ma as ma
>>> a = np.int8()
>>> ma.minimum_fill_value(a)
127
>>> a = np.int32()
>>> ma.minimum_fill_value(a)
2147483647
An array of numeric data can also be passed.
>>> a = np.array([1, 2, 3], dtype=np.int8)
>>> ma.minimum_fill_value(a)
127
>>> a = np.array([1, 2, 3], dtype=np.float32)
>>> ma.minimum_fill_value(a)
inf
s( Unsuitable type for calculating minimum.R t float_t int_t uintN( R R R t
min_fillerR R t ntypest typeDictR R R R ( R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR~ s 0 c C s d } t | d o t | i t St | t o t t i d St | t o t t i d St | t o t t i d St | t
i o t | St | d S( s\
Return the minimum value that can be represented by the dtype of an object.
This function is useful for calculating a fill value suitable for
taking the maximum of an array with a given dtype.
Parameters
----------
obj : {ndarray, dtype}
An object that can be queried for it's numeric type.
Returns
-------
val : scalar
The minimum representable value.
Raises
------
TypeError
If `obj` isn't a suitable numeric type.
See Also
--------
minimum_fill_value : The inverse function.
set_fill_value : Set the filling value of a masked array.
MaskedArray.fill_value : Return current fill value.
Examples
--------
>>> import numpy.ma as ma
>>> a = np.int8()
>>> ma.maximum_fill_value(a)
-128
>>> a = np.int32()
>>> ma.maximum_fill_value(a)
-2147483648
An array of numeric data can also be passed.
>>> a = np.array([1, 2, 3], dtype=np.int8)
>>> ma.maximum_fill_value(a)
-128
>>> a = np.array([1, 2, 3], dtype=np.float32)
>>> ma.maximum_fill_value(a)
-inf
s( Unsuitable type for calculating maximum.R R R R N( R R R t
max_fillerR R R R R R R R ( R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRz 9 s 0 c C st g } xa | D]Y } | d } t | t o | i t t | q
| i t t i | q
Wt | S( Ni ( R t listR R t! _recursive_set_default_fill_valueR1 R R ( t
dtypedescrR t currentdescrt currenttype( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR x s
c C s t i | t | } g } xy t | | D]h \ } } | d } t | t o | i t t | | q. | i t i | d | i
q. Wt | S( Ni R ( R R t lent zipR R R R t _recursive_set_fill_valueR t item( t fillvalueR t output_valueR t descrt cdtype( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s
&c C s t i | } | i } | d j o? | o( | i } t i t | d | } qt | } nA| o g } | i D] } | | d | d f qy ~ } t | t oU y t i | d t
d | } Wq)t j
o# d } t | | | f q)Xq| i } t i t | | d | } nx t | t
o | i d j o t | } nH y% t i | d t
d | i } Wn t j
o t | } n X| S( s
Private function validating the given `fill_value` for the given dtype.
If fill_value is None, it is set to the default corresponding to the dtype
if this latter is standard (no fields). If the datatype is flexible (named
fields), fill_value is set to a tuple whose elements are the default fill
values corresponding to each field.
If fill_value is not None, its value is forced to the given dtype.
R i i R+ s" Unable to transform %s to dtype %st SVN( R R t fieldsR R R R R1 R R t Falset
ValueErrorR t
basestringt charR t
OverflowError( t
fill_valueR R R t _[1]t _t fdtypet err_msg( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s4
2
%c C s- t | t o t | | i | _ n d S( s
Set the filling value of a, if a is a masked array.
This function changes the fill value of the masked array `a` in place.
If `a` is not a masked array, the function returns silently, without
doing anything.
Parameters
----------
a : array_like
Input array.
fill_value : dtype
Filling value. A consistency test is performed to make sure
the value is compatible with the dtype of `a`.
Returns
-------
None
Nothing returned by this function.
See Also
--------
maximum_fill_value : Return the default fill value for a dtype.
MaskedArray.fill_value : Return current fill value.
MaskedArray.set_fill_value : Equivalent method.
Examples
--------
>>> import numpy.ma as ma
>>> a = np.arange(5)
>>> a
array([0, 1, 2, 3, 4])
>>> a = ma.masked_where(a < 3, a)
>>> a
masked_array(data = [-- -- -- 3 4],
mask = [ True True True False False],
fill_value=999999)
>>> ma.set_fill_value(a, -999)
>>> a
masked_array(data = [-- -- -- 3 4],
mask = [ True True True False False],
fill_value=-999)
Nothing happens if `a` is not a masked array.
>>> a = range(5)
>>> a
[0, 1, 2, 3, 4]
>>> ma.set_fill_value(a, 100)
>>> a
[0, 1, 2, 3, 4]
>>> a = np.arange(5)
>>> a
array([0, 1, 2, 3, 4])
>>> ma.set_fill_value(a, 100)
>>> a
array([0, 1, 2, 3, 4])
N( R R R R t _fill_value( t aR ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s <c C s- t | t o
| i } n
t | } | S( sr
Return the filling value of a, if any. Otherwise, returns the
default filling value for that type.
( R R R R1 ( R t result( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt get_fill_value s
c C s. t | } t | } | | j o | Sd S( s
Return the common filling value of two masked arrays, if any.
If ``a.fill_value == b.fill_value``, return the fill value,
otherwise return None.
Parameters
----------
a, b : MaskedArray
The masked arrays for which to compare fill values.
Returns
-------
fill_value : scalar or None
The common fill value, or None.
Examples
--------
>>> x = np.ma.array([0, 1.], fill_value=3)
>>> y = np.ma.array([0, 1.], fill_value=3)
>>> np.ma.common_fill_value(x, y)
3.0
N( R R ( R R t t1t t2( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR& s
c C se t | d o | i | St | t o | St | t o t i | d St i | Sd S( sD
Return input as an array with masked data replaced by a fill value.
If `a` is not a `MaskedArray`, `a` itself is returned.
If `a` is a `MaskedArray` and `fill_value` is None, `fill_value` is set to
``a.fill_value``.
Parameters
----------
a : MaskedArray or array_like
An input object.
fill_value : scalar, optional
Filling value. Default is None.
Returns
-------
a : ndarray
The filled array.
Examples
--------
>>> x = np.ma.array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0],
... [1, 0, 0],
... [0, 0, 0]])
>>> x.filled()
array([[999999, 1, 2],
[999999, 4, 5],
[ 6, 7, 8]])
R@ R N( R R@ R R t dictR R ( R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR@ ( s c G s t | d j o4 | d } t | t o t | } q t } n{ g } | D] } | t | qR ~ } | d } t | t p
t } n x, | d D] } t | | o
| } q q W| S( s
Return the youngest subclass of MaskedArray from a list of (masked) arrays.
In case of siblings, the first listed takes over.
i i ( R R R t typet
issubclass( t arrayst arrt rclsR R t arrclst cls( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt get_masked_subclassR s
'
c C sW y
| i } Wn. t j
o" t i | d t d | } n X| p | i t S| S( sF
Return the data of a masked array as an ndarray.
Return the data of `a` (if any) as an ndarray if `a` is a ``MaskedArray``,
else return `a` as a ndarray or subclass (depending on `subok`) if not.
Parameters
----------
a : array_like
Input ``MaskedArray``, alternatively a ndarray or a subclass thereof.
subok : bool
Whether to force the output to be a `pure` ndarray (False) or to
return a subclass of ndarray if appropriate (True, default).
See Also
--------
getmask : Return the mask of a masked array, or nomask.
getmaskarray : Return the mask of a masked array, or full array of False.
Examples
--------
>>> import numpy.ma as ma
>>> a = ma.masked_equal([[1,2],[3,4]], 2)
>>> a
masked_array(data =
[[1 --]
[3 4]],
mask =
[[False True]
[False False]],
fill_value=999999)
>>> ma.getdata(a)
array([[1, 2],
[3, 4]])
Equivalently use the ``MaskedArray`` `data` attribute.
>>> a.data
array([[1, 2],
[3, 4]])
R+ t subok( t _datat AttributeErrorR R R t viewR ( R R t data( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRH i s ,
c C s t | d | d | d t } t i t i | i } | i p | S| i | O_ | d j o
| i } n | | i | <| S( s
Return input with invalid data masked and replaced by a fill value.
Invalid data means values of `nan`, `inf`, etc.
Parameters
----------
a : array_like
Input array, a (subclass of) ndarray.
copy : bool, optional
Whether to use a copy of `a` (True) or to fix `a` in place (False).
Default is True.
fill_value : scalar, optional
Value used for fixing invalid data. Default is None, in which case
the ``a.fill_value`` is used.
Returns
-------
b : MaskedArray
The input array with invalid entries fixed.
Notes
-----
A copy is performed by default.
Examples
--------
>>> x = np.ma.array([1., -1, np.nan, np.inf], mask=[1] + [0]*3)
>>> x
masked_array(data = [-- -1.0 nan inf],
mask = [ True False False False],
fill_value = 1e+20)
>>> np.ma.fix_invalid(x)
masked_array(data = [-- -1.0 -- --],
mask = [ True False True True],
fill_value = 1e+20)
>>> fixed = np.ma.fix_invalid(x)
>>> fixed.data
array([ 1.00000000e+00, -1.00000000e+00, 1.00000000e+20,
1.00000000e+20])
>>> x.data
array([ 1., -1., NaN, Inf])
R+ t maskR N(
Ri t TrueR Ra t isfiniteR R t _maskR R ( R R R+ R t invalid( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRC s .
t _DomainCheckIntervalc B s e Z d Z d Z d Z RS( s~
Define a valid interval, so that :
``domain_check_interval(a,b)(x) == True`` where
``x < a`` or ``x > b``.
c C s4 | | j o | | } } n | | _ | | _ d S( s9 domain_check_interval(a,b)(x) = true where x < a or y > bN( R R ( t selfR R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt __init__ s
c C s. t i t i | | i t i | | i S( s Execute the call behavior.( t umathRb RK R RZ R ( R t x( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt __call__ s ( R R R R! R$ ( ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s t
_DomainTanc B s e Z d Z d Z d Z RS( sz Define a valid interval for the `tan` function, so that:
``domain_tan(eps) = True`` where ``abs(cos(x)) < eps``
c C s
| | _ d S( s/ domain_tan(eps) = true where abs(cos(x)) < eps)N( t eps( R R& ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR! s c C s% t i t i t i | | i S( s Executes the call behavior.( R" RZ R R, R& ( R R# ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR$ s ( R R R R! R$ ( ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR% s t _DomainSafeDividec B s# e Z d Z d d Z d Z RS( s" Define a domain for safe division.c C s
| | _ d S( N( t tolerance( R R( ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR! s c C sL | i d j o t i t i | _ n t i | | i t i | j S( N( R( R R t finfoR t tinyR" R ( R R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR$ s N( R R R R R! R$ ( ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR' s t _DomainGreaterc B s e Z d Z d Z d Z RS( s) DomainGreater(v)(x) is True where x <= v.c C s
| | _ d S( s' DomainGreater(v)(x) = true where x <= vN( t critical_value( R R, ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR! s c C s t i | | i S( s Executes the call behavior.( R" R[ R, ( R R# ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR$ s ( R R R R! R$ ( ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR+ s t _DomainGreaterEqualc B s e Z d Z d Z d Z RS( s- DomainGreaterEqual(v)(x) is True where x < v.c C s
| | _ d S( s+ DomainGreaterEqual(v)(x) = true where x < vN( R, ( R R, ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR! # s c C s t i | | i S( s Executes the call behavior.( R" RZ R, ( R R# ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR$ ' s ( R R R R! R$ ( ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR- ! s t _MaskedUnaryOperationc B s/ e Z d Z d d d Z d Z d Z RS( s
Defines masked version of unary operations, where invalid values are
pre-masked.
Parameters
----------
mufunc : callable
The function for which to define a masked version. Made available
as ``_MaskedUnaryOperation.f``.
fill : scalar, optional
Filling value, default is 0.
domain : class instance
Domain for the function. Should be one of the ``_Domain*``
classes. Default is None.
i c C si | | _ | | _ | | _ t | d t | | _ t | d t | | _ | t | <| t | >> import numpy.ma as ma
>>> dtype = np.dtype({'names':['foo', 'bar'],
'formats':[np.float32, np.int]})
>>> dtype
dtype([('foo', '>> ma.make_mask_descr(dtype)
dtype([('foo', '|b1'), ('bar', '|b1')])
>>> ma.make_mask_descr(np.float32)
( R R R RR t bool( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRe s c C s t | d t S( s1
Return the mask of a masked array, or nomask.
Return the mask of `a` as an ndarray if `a` is a `MaskedArray` and the
mask is not `nomask`, else return `nomask`. To guarantee a full array
of booleans of the same shape as a, use `getmaskarray`.
Parameters
----------
a : array_like
Input `MaskedArray` for which the mask is required.
See Also
--------
getdata : Return the data of a masked array as an ndarray.
getmaskarray : Return the mask of a masked array, or full array of False.
Examples
--------
>>> import numpy.ma as ma
>>> a = ma.masked_equal([[1,2],[3,4]], 2)
>>> a
masked_array(data =
[[1 --]
[3 4]],
mask =
[[False True]
[False False]],
fill_value=999999)
>>> ma.getmask(a)
array([[False, True],
[False, False]], dtype=bool)
Equivalently use the `MaskedArray` `mask` attribute.
>>> a.mask
array([[False, True],
[False, False]], dtype=bool)
Result when mask == `nomask`
>>> b = ma.masked_array([[1,2],[3,4]])
>>> b
masked_array(data =
[[1 2]
[3 4]],
mask =
False,
fill_value=999999)
>>> ma.nomask
False
>>> ma.getmask(b) == ma.nomask
True
>>> b.mask == ma.nomask
True
R ( R1 R ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRI s ;c C sB t | } | t j o% t t i | t | i } n | S( s
Return the mask of a masked array, or full boolean array of False.
Return the mask of `arr` as an ndarray if `arr` is a `MaskedArray` and
the mask is not `nomask`, else return a full boolean array of False of
the same shape as `arr`.
Parameters
----------
arr : array_like
Input `MaskedArray` for which the mask is required.
See Also
--------
getmask : Return the mask of a masked array, or nomask.
getdata : Return the data of a masked array as an ndarray.
Examples
--------
>>> import numpy.ma as ma
>>> a = ma.masked_equal([[1,2],[3,4]], 2)
>>> a
masked_array(data =
[[1 --]
[3 4]],
mask =
[[False True]
[False False]],
fill_value=999999)
>>> ma.getmaskarray(a)
array([[False, True],
[False, False]], dtype=bool)
Result when mask == ``nomask``
>>> b = ma.masked_array([[1,2],[3,4]])
>>> b
masked_array(data =
[[1 2]
[3 4]],
mask =
False,
fill_value=999999)
>>> >ma.getmaskarray(b)
array([[False, False],
[False, False]], dtype=bool)
( RI R Rf R R RH R ( R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRJ s 2
%c C s/ y | i i t j SWn t j
o t SXd S( s2
Return True if m is a valid, standard mask.
This function does not check the contents of the input, only that the
type is MaskType. In particular, this function returns False if the
mask has a flexible dtype.
Parameters
----------
m : array_like
Array to test.
Returns
-------
result : bool
True if `m.dtype.type` is MaskType, False otherwise.
See Also
--------
isMaskedArray : Test whether input is an instance of MaskedArray.
Examples
--------
>>> import numpy.ma as ma
>>> m = ma.masked_equal([0, 1, 0, 2, 3], 0)
>>> m
masked_array(data = [-- 1 -- 2 3],
mask = [ True False True False False],
fill_value=999999)
>>> ma.is_mask(m)
False
>>> ma.is_mask(m.mask)
True
Input must be an ndarray (or have similar attributes)
for it to be considered a valid mask.
>>> m = [False, True, False]
>>> ma.is_mask(m)
False
>>> m = np.array([False, True, False])
>>> m
array([False, True, False], dtype=bool)
>>> ma.is_mask(m)
True
Arrays with complex dtypes don't return True.
>>> dtype = np.dtype({'names':['monty', 'pithon'],
'formats':[np.bool, np.bool]})
>>> dtype
dtype([('monty', '|b1'), ('pithon', '|b1')])
>>> m = np.array([(True, False), (False, True), (True, False)],
dtype=dtype)
>>> m
array([(True, False), (False, True), (True, False)],
dtype=[('monty', '|b1'), ('pithon', '|b1')])
>>> ma.is_mask(m)
False
N( R R
R R R ( R= ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRV K s >c C s | d j o t i d t | } n | t j o t St | t ok t | t } t | } | i
| j o! | o | i } q | } q t i
| d | d | } n t i
t | t d t } | o! | i
i o | i o t S| Sd S( s
Create a boolean mask from an array.
Return `m` as a boolean mask, creating a copy if necessary or requested.
The function can accept any sequence that is convertible to integers,
or ``nomask``. Does not require that contents must be 0s and 1s, values
of 0 are interepreted as False, everything else as True.
Parameters
----------
m : array_like
Potential mask.
copy : bool, optional
Whether to return a copy of `m` (True) or `m` itself (False).
shrink : bool, optional
Whether to shrink `m` to ``nomask`` if all its values are False.
flag : bool, optional
Deprecated equivalent of `shrink`.
dtype : dtype, optional
Data-type of the output mask. By default, the output mask has
a dtype of MaskType (bool). If the dtype is flexible, each field
has a boolean dtype.
Returns
-------
result : ndarray
A boolean mask derived from `m`.
Examples
--------
>>> import numpy.ma as ma
>>> m = [True, False, True, True]
>>> ma.make_mask(m)
array([ True, False, True, True], dtype=bool)
>>> m = [1, 0, 1, 1]
>>> ma.make_mask(m)
array([ True, False, True, True], dtype=bool)
>>> m = [1, 0, 2, -3]
>>> ma.make_mask(m)
array([ True, False, True, True], dtype=bool)
Effect of the `shrink` parameter.
>>> m = np.zeros(4)
>>> m
array([ 0., 0., 0., 0.])
>>> ma.make_mask(m)
False
>>> ma.make_mask(m, shrink=False)
array([False, False, False, False], dtype=bool)
Using a flexible `dtype`.
>>> m = [1, 0, 1, 1]
>>> n = [0, 1, 0, 0]
>>> arr = []
>>> for man, mouse in zip(m, n):
... arr.append((man, mouse))
>>> arr
[(1, 0), (0, 1), (1, 0), (1, 0)]
>>> dtype = np.dtype({'names':['man', 'mouse'],
'formats':[np.int, np.int]})
>>> arr = np.array(arr, dtype=dtype)
>>> arr
array([(1, 0), (0, 1), (1, 0), (1, 0)],
dtype=[('man', '>> ma.make_mask(arr, dtype=dtype)
array([(True, False), (False, True), (True, False), (True, False)],
dtype=[('man', '|b1'), ('mouse', '|b1')])
s' The flag 'flag' is now called 'shrink'!R R+ N( R t warningst warnt DeprecationWarningR R R R@ R Re R R+ R R R R R ( R= R+ t shrinkt flagR R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRd s$ H
#c C sE | d j o t i | d t } n t i | d t | } | S( s/
Return a boolean mask of the given shape, filled with False.
This function returns a boolean ndarray with all entries False, that can
be used in common mask manipulations. If a complex dtype is specified, the
type of each field is converted to a boolean type.
Parameters
----------
newshape : tuple
A tuple indicating the shape of the mask.
dtype: {None, dtype}, optional
If None, use a MaskType instance. Otherwise, use a new datatype with
the same fields as `dtype`, converted to boolean types.
Returns
-------
result : ndarray
An ndarray of appropriate shape and dtype, filled with False.
See Also
--------
make_mask : Create a boolean mask from an array.
make_mask_descr : Construct a dtype description list from a given dtype.
Examples
--------
>>> import numpy.ma as ma
>>> ma.make_mask_none((3,))
array([False, False, False], dtype=bool)
Defining a more complex dtype.
>>> dtype = np.dtype({'names':['foo', 'bar'],
'formats':[np.float32, np.int]})
>>> dtype
dtype([('foo', '>> ma.make_mask_none((3,), dtype=dtype)
array([(False, False), (False, False), (False, False)],
dtype=[('foo', '|b1'), ('bar', '|b1')])
R N( R R R R Re ( t newshapeR R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRf s +
c s\ f d | t j p
| t j o/ t | d t } t | d | d | d | S| t j p
| t j o/ t | d t } t | d | d | d | S| | j o t | o | St | d d t | d d } } | | j o t d | | f n | i o$ t i
| } | | | | St t i | | d | d | S( s
Combine two masks with the ``logical_or`` operator.
The result may be a view on `m1` or `m2` if the other is `nomask`
(i.e. False).
Parameters
----------
m1, m2 : array_like
Input masks.
copy : bool, optional
If copy is False and one of the inputs is `nomask`, return a view
of the other input mask. Defaults to False.
shrink : bool, optional
Whether to shrink the output to `nomask` if all its values are
False. Defaults to True.
Returns
-------
mask : output mask
The result masks values that are masked in either `m1` or `m2`.
Raises
------
ValueError
If `m1` and `m2` have different flexible dtypes.
Examples
--------
>>> m1 = np.ma.make_mask([0, 1, 1, 0])
>>> m2 = np.ma.make_mask([1, 0, 0, 0])
>>> np.ma.mask_or(m1, m2)
array([ True, True, True, False], dtype=bool)
c so | i i } x\ | D]T } | | } | i i o | | | | | q t i | | | | | q Wd S( N( R R R" Rb ( t m1t m2t newmaskR R t current1( t _recursive_mask_or( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRb G s
R R+ R[ s Incompatible dtypes '%s'<>'%s'N(
R R R1 R Rd RV R R R R R9 R" Rb ( R^ R_ R+ R[ R t dtype1t dtype2R` ( ( Rb s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRg # s" $
%
c sg d } f d t i | } | | } t i g } | D]
} | | qJ ~ d t S( sG
Returns a completely flattened version of the mask, where nested fields
are collapsed.
Parameters
----------
mask : array_like
Input array, which will be interpreted as booleans.
Returns
-------
flattened_mask : ndarray of bools
The flattened input.
Examples
--------
>>> mask = np.array([0, 0, 1], dtype=np.bool)
>>> flatten_mask(mask)
array([False, False, True], dtype=bool)
>>> mask = np.array([(0, 0), (0, 1)], dtype=[('a', bool), ('b', bool)])
>>> flatten_mask(mask)
array([False, False, False, True], dtype=bool)
>>> mdtype = [('a', bool), ('b', [('ba', bool), ('bb', bool)])]
>>> mask = np.array([(0, (0, 0)), (0, (0, 1))], dtype=mdtype)
>>> flatten_mask(mask)
array([False, False, False, False, False, True], dtype=bool)
c S sE | i i } | o* g } | D] } | t | | q ~ S| Sd S( sC Flatten the mask and returns a (maybe nested) sequence of booleans.N( R R R> ( R t mnamesR R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt _flatmask s *c 3 si yJ xC | D]; } t | d o x" | D] } | Vq- Wq
| Vq
WWn t j
o | Vn Xd S( s. Generates a flattened version of the sequence.t __iter__N( R R ( t sequencet elementR ( t
_flatsequence( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRj s
R ( R R R RW ( R Rf t flattenedR R ( ( Rj s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR> c s
c C s" | t j o | i d | St S( s: Check whether there are masked values along the given axisRJ ( R R ( R RJ ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt _check_mask_axis s
c C s t | } t i | d | d t } | i | i } } | o' | | j o t d | | f n t | d o" t | | i } t | } n t
} | i | } | | _ | S( st
Mask an array where a condition is met.
Return `a` as an array masked where `condition` is True.
Any masked values of `a` or `condition` are also masked in the output.
Parameters
----------
condition : array_like
Masking condition. When `condition` tests floating point values for
equality, consider using ``masked_values`` instead.
a : array_like
Array to mask.
copy : bool
If True (default) make a copy of `a` in the result. If False modify
`a` in place and return a view.
Returns
-------
result : MaskedArray
The result of masking `a` where `condition` is True.
See Also
--------
masked_values : Mask using floating point equality.
masked_equal : Mask where equal to a given value.
masked_not_equal : Mask where `not` equal to a given value.
masked_less_equal : Mask where less than or equal to a given value.
masked_greater_equal : Mask where greater than or equal to a given value.
masked_less : Mask where less than a given value.
masked_greater : Mask where greater than a given value.
masked_inside : Mask inside a given interval.
masked_outside : Mask outside a given interval.
masked_invalid : Mask invalid values (NaNs or infs).
Examples
--------
>>> import numpy.ma as ma
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> ma.masked_where(a <= 2, a)
masked_array(data = [-- -- -- 3],
mask = [ True True True False],
fill_value=999999)
Mask array `b` conditional on `a`.
>>> b = ['a', 'b', 'c', 'd']
>>> ma.masked_where(a == 2, b)
masked_array(data = [a b -- d],
mask = [False False True False],
fill_value=N/A)
Effect of the `copy` argument.
>>> c = ma.masked_where(a <= 2, a)
>>> c
masked_array(data = [-- -- -- 3],
mask = [ True True True False],
fill_value=999999)
>>> c[0] = 99
>>> c
masked_array(data = [99 -- -- 3],
mask = [False True True False],
fill_value=999999)
>>> a
array([0, 1, 2, 3])
>>> c = ma.masked_where(a <= 2, a, copy=False)
>>> c[0] = 99
>>> c
masked_array(data = [99 -- -- 3],
mask = [False True True False],
fill_value=999999)
>>> a
array([99, 1, 2, 3])
When `condition` or `a` contain masked values.
>>> a = np.arange(4)
>>> a = ma.masked_where(a == 2, a)
>>> a
masked_array(data = [0 1 -- 3],
mask = [False False True False],
fill_value=999999)
>>> b = np.arange(4)
>>> b = ma.masked_where(b == 0, b)
>>> b
masked_array(data = [-- 1 2 3],
mask = [ True False False False],
fill_value=999999)
>>> ma.masked_where(a == 3, b)
masked_array(data = [-- 1 -- --],
mask = [ True False True True],
fill_value=999999)
R+ R sF Inconsistant shape between the condition and the input (got %s and %s)R ( Rd R R R R t
IndexErrorR Rg R R
R R ( t conditionR R+ t condt cshapet ashapeR R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRw s c c C s t t | | | d | S( s
Mask an array where greater than a given value.
This function is a shortcut to ``masked_where``, with
`condition` = (x > value).
See Also
--------
masked_where : Mask where a condition is met.
Examples
--------
>>> import numpy.ma as ma
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> ma.masked_greater(a, 2)
masked_array(data = [0 1 2 --],
mask = [False False False True],
fill_value=999999)
R+ ( Rw RK ( R# t valueR+ ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRk s c C s t t | | | d | S( s
Mask an array where greater than or equal to a given value.
This function is a shortcut to ``masked_where``, with
`condition` = (x >= value).
See Also
--------
masked_where : Mask where a condition is met.
Examples
--------
>>> import numpy.ma as ma
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> ma.masked_greater_equal(a, 2)
masked_array(data = [0 1 -- --],
mask = [False False True True],
fill_value=999999)
R+ ( Rw RL ( R# Rr R+ ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRl 5 s c C s t t | | | d | S( s
Mask an array where less than a given value.
This function is a shortcut to ``masked_where``, with
`condition` = (x < value).
See Also
--------
masked_where : Mask where a condition is met.
Examples
--------
>>> import numpy.ma as ma
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> ma.masked_less(a, 2)
masked_array(data = [-- -- 2 3],
mask = [ True True False False],
fill_value=999999)
R+ ( Rw RZ ( R# Rr R+ ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRo O s c C s t t | | | d | S( s
Mask an array where less than or equal to a given value.
This function is a shortcut to ``masked_where``, with
`condition` = (x <= value).
See Also
--------
masked_where : Mask where a condition is met.
Examples
--------
>>> import numpy.ma as ma
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> ma.masked_less_equal(a, 2)
masked_array(data = [-- -- -- 3],
mask = [ True True True False],
fill_value=999999)
R+ ( Rw R[ ( R# Rr R+ ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRp i s c C s t t | | | d | S( s
Mask an array where `not` equal to a given value.
This function is a shortcut to ``masked_where``, with
`condition` = (x != value).
See Also
--------
masked_where : Mask where a condition is met.
Examples
--------
>>> import numpy.ma as ma
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> ma.masked_not_equal(a, 2)
masked_array(data = [-- -- 2 --],
mask = [ True True False True],
fill_value=999999)
R+ ( Rw R ( R# Rr R+ ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRq s c C s+ t t | | | d | } | | _ | S( sa
Mask an array where equal to a given value.
This function is a shortcut to ``masked_where``, with
`condition` = (x == value). For floating point arrays,
consider using ``masked_values(x, value)``.
See Also
--------
masked_where : Mask where a condition is met.
masked_values : Mask using floating point equality.
Examples
--------
>>> import numpy.ma as ma
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> ma.masked_equal(a, 2)
masked_array(data = [0 1 -- 3],
mask = [False False True False],
fill_value=999999)
R+ ( Rw R: R ( R# Rr R+ t output( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRj s c C sS | | j o | | } } n t | } | | j | | j @} t | | d | S( sw
Mask an array inside a given interval.
Shortcut to ``masked_where``, where `condition` is True for `x` inside
the interval [v1,v2] (v1 <= x <= v2). The boundaries `v1` and `v2`
can be given in either order.
See Also
--------
masked_where : Mask where a condition is met.
Notes
-----
The array `x` is prefilled with its filling value.
Examples
--------
>>> import numpy.ma as ma
>>> x = [0.31, 1.2, 0.01, 0.2, -0.4, -1.1]
>>> ma.masked_inside(x, -0.3, 0.3)
masked_array(data = [0.31 1.2 -- -- -0.4 -1.1],
mask = [False False True True False False],
fill_value=1e+20)
The order of `v1` and `v2` doesn't matter.
>>> ma.masked_inside(x, 0.3, -0.3)
masked_array(data = [0.31 1.2 -- -- -0.4 -1.1],
mask = [False False True True False False],
fill_value=1e+20)
R+ ( R@ Rw ( R# t v1t v2R+ t xfRn ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRm s
!
c C sS | | j o | | } } n t | } | | j | | j B} t | | d | S( st
Mask an array outside a given interval.
Shortcut to ``masked_where``, where `condition` is True for `x` outside
the interval [v1,v2] (x < v1)|(x > v2).
The boundaries `v1` and `v2` can be given in either order.
See Also
--------
masked_where : Mask where a condition is met.
Notes
-----
The array `x` is prefilled with its filling value.
Examples
--------
>>> import numpy.ma as ma
>>> x = [0.31, 1.2, 0.01, 0.2, -0.4, -1.1]
>>> ma.masked_outside(x, -0.3, 0.3)
masked_array(data = [-- -- 0.01 0.2 -- --],
mask = [ True True False False True True],
fill_value=1e+20)
The order of `v1` and `v2` doesn't matter.
>>> ma.masked_outside(x, 0.3, -0.3)
masked_array(data = [-- -- 0.01 0.2 -- --],
mask = [ True True False False True True],
fill_value=1e+20)
R+ ( R@ Rw ( R# Rt Ru R+ Rv Rn ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRs s
!
c C s t | o" t i | i | } | i } n" t i t i | | } t } t | t | d | } t
| d | d | d | S( s
Mask the array `x` where the data are exactly equal to value.
This function is similar to `masked_values`, but only suitable
for object arrays: for floating point, use `masked_values` instead.
Parameters
----------
x : array_like
Array to mask
value : object
Comparison value
copy : {True, False}, optional
Whether to return a copy of `x`.
shrink : {True, False}, optional
Whether to collapse a mask full of False to nomask
Returns
-------
result : MaskedArray
The result of masking `x` where equal to `value`.
See Also
--------
masked_where : Mask where a condition is met.
masked_equal : Mask where equal to a given value (integers).
masked_values : Mask using floating point equality.
Examples
--------
>>> import numpy.ma as ma
>>> food = np.array(['green_eggs', 'ham'], dtype=object)
>>> # don't eat spoiled food
>>> eat = ma.masked_object(food, 'green_eggs')
>>> print eat
[-- ham]
>>> # plain ol` ham is boring
>>> fresh_food = np.array(['cheese', 'ham', 'pineapple'], dtype=object)
>>> eat = ma.masked_object(fresh_food, 'green_eggs')
>>> print eat
[cheese ham pineapple]
Note that `mask` is set to ``nomask`` if possible.
>>> eat
masked_array(data = [cheese ham pineapple],
mask = False,
fill_value=?)
R[ R R+ R ( RU R" R: R R R R R Rg Rd Ri ( R# Rr R+ R[ Rn R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRr s 3
gh㈵>g:0yE>c
C s t i } t | | } t | i i t i o@ t i | | | | | | | } t | d t
} n t i | | } t
} t | t
| d | } t | d | d | d | S( s
Mask using floating point equality.
Return a MaskedArray, masked where the data in array `x` are approximately
equal to `value`, i.e. where the following condition is True
(abs(x - value) <= atol+rtol*abs(value))
The fill_value is set to `value` and the mask is set to ``nomask`` if
possible. For integers, consider using ``masked_equal``.
Parameters
----------
x : array_like
Array to mask.
value : float
Masking value.
rtol : float, optional
Tolerance parameter.
atol : float, optional
Tolerance parameter (1e-8).
copy : bool, optional
Whether to return a copy of `x`.
shrink : bool, optional
Whether to collapse a mask full of False to ``nomask``.
Returns
-------
result : MaskedArray
The result of masking `x` where approximately equal to `value`.
See Also
--------
masked_where : Mask where a condition is met.
masked_equal : Mask where equal to a given value (integers).
Examples
--------
>>> import numpy.ma as ma
>>> x = np.array([1, 1.1, 2, 1.1, 3])
>>> ma.masked_values(x, 1.1)
masked_array(data = [1.0 -- 2.0 -- 3.0],
mask = [False True False True False],
fill_value=1.1)
Note that `mask` is set to ``nomask`` if possible.
>>> ma.masked_values(x, 1.5)
masked_array(data = [ 1. 1.1 2. 1.1 3. ],
mask = False,
fill_value=1.5)
For integers, the fill value will be different in general to the
result of ``masked_equal``.
>>> x = np.arange(5)
>>> x
array([0, 1, 2, 3, 4])
>>> ma.masked_values(x, 2)
masked_array(data = [0 1 -- 3 4],
mask = [False False True False False],
fill_value=2)
>>> ma.masked_equal(x, 2)
masked_array(data = [0 1 -- 3 4],
mask = [False False True False False],
fill_value=999999)
R R[ R R+ R ( R" R R@ R R R
R t floatingR[ R1 R R: Rg Rd Ri (
R# Rr t rtolt atolR+ R[ t mabst xnewRn R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRv M s E *c C s t i | d | d t } t | d d } | d j oA t i t | } | t j o | | O} n t | } n t i | } t } | i
| } | | _ | S( s
Mask an array where invalid values occur (NaNs or infs).
This function is a shortcut to ``masked_where``, with
`condition` = ~(np.isfinite(a)). Any pre-existing mask is conserved.
Only applies to arrays with a dtype where NaNs or infs make sense
(i.e. floating point types), but accepts any array_like object.
See Also
--------
masked_where : Mask where a condition is met.
Examples
--------
>>> import numpy.ma as ma
>>> a = np.arange(5, dtype=np.float)
>>> a[2] = np.NaN
>>> a[3] = np.PINF
>>> a
array([ 0., 1., NaN, Inf, 4.])
>>> ma.masked_invalid(a)
masked_array(data = [0.0 1.0 -- -- 4.0],
mask = [False False True True False],
fill_value=1e+20)
R+ R R N( R R R R1 R R RH R R
R R R ( R R+ R Rn R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRn s
t _MaskedPrintOptionc B sM e Z d Z d Z d Z d Z d Z d d Z d Z e Z RS( sN
Handle the string used to represent missing data in a masked array.
c C s | | _ t | _ d S( s& Create the masked_print_option object.N( t _displayR t _enabled( R t display( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR! s c C s | i S( s. Display the string to print for masked values.( R} ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s c C s
| | _ d S( s* Set the string to print for masked values.N( R} ( R t s( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt set_display s c C s | i S( s( Is the use of the display value enabled?( R~ ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt enabled s i c C s
| | _ d S( s$ Set the enabling shrink to `shrink`.N( R~ ( R R[ ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt enable s c C s
t | i S( N( R R} ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR? s (
R R R R! R R R R R? t __repr__( ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR| s s --c C sj | i i } xW | D]O } | | | | } } | i i o t | | | q t i | | | q Wd S( se
Puts printoptions in result where mask is True.
Private function allowing for recursion
N( R R t _recursive_printoptionR R ( R R t printoptR R t curdatat curmask( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s
R se masked_%(name)s(data =
%(data)s,
%(nlen)s mask =
%(mask)s,
%(nlen)s fill_value = %(fill)s)
t shortsc masked_%(name)s(data = %(data)s,
%(nlen)s mask = %(mask)s,
%(nlen)s fill_value = %(fill)s)
t long_flxs masked_%(name)s(data =
%(data)s,
%(nlen)s mask =
%(mask)s,
%(nlen)s fill_value = %(fill)s,
%(nlen)s dtype = %(dtype)s)
t short_flxs masked_%(name)s(data = %(data)s,
%(nlen)s mask = %(mask)s,
%(nlen)s fill_value = %(fill)s,
%(nlen)s dtype = %(dtype)s)
c C so | i i } x\ | D]T } | | } | i i o t | | | | | q t i | | | | | q Wd S( sF
Recursively fill `a` with `fill_value`.
Private function
N( R R t _recursive_filledR R ( R R R R R t current( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s
t _arraymethodc B s8 e Z d Z e d Z d Z d d Z d Z RS( s
Define a wrapper for basic array methods.
Upon call, returns a masked array, where the new ``_data`` array is
the output of the corresponding method called on the original
``_data``.
If `onmask` is True, the new mask is the output of the method called
on the initial mask. Otherwise, the new mask is just a reference
to the initial mask.
Attributes
----------
_onmask : bool
Holds the `onmask` parameter.
obj : object
The object calling `_arraymethod`.
Parameters
----------
funcname : str
Name of the function to apply on data.
onmask : bool
Whether the mask must be processed also (True) or left
alone (False). Default is True. Make available as `_onmask`
attribute.
c C s. | | _ | | _ d | _ | i | _ d S( N( R t _onmaskR R t getdocR ( R t funcnamet onmask( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR! G s c C sD t t | i d p t t | i d } | d j o | i Sd S( s< Return the doc of the function (from the doc of the method).N( R1 R R R R R ( R t methdoc( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR M s
c C s
| | _ | S( N( R ( R R t objtype( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt __get__T s c O s | i } | i } | d j o t | } | i d } n | i } | i } t | } t | | | | i | } | i
| | i oO | i p | i
| q
| t j o# | i
t | | | | q
n+ | i o | i i o | i o t S| S( Ni ( R R R R t popR R R
R1 R R8 R7 R t __setmask__R R R R Rh ( R R9 t paramst
methodnamet instanceR R R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR$ X s$
!
'%N( R R R R R! R R R R$ ( ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR * s
t MaskedIteratorc B s; e Z d Z d Z d Z d Z d Z d Z RS( s
Flat iterator object to iterate over masked arrays.
A `MaskedIterator` iterator is returned by ``x.flat`` for any masked array
`x`. It allows iterating over the array as if it were a 1-D array,
either in a for-loop or by calling its `next` method.
Iteration is done in C-contiguous style, with the last index varying the
fastest. The iterator can also be indexed using basic slicing or
advanced indexing.
See Also
--------
MaskedArray.flat : Return a flat iterator over an array.
MaskedArray.flatten : Returns a flattened copy of an array.
Notes
-----
`MaskedIterator` is not exported by the `ma` module. Instead of
instantiating a `MaskedIterator` directly, use `MaskedArray.flat`.
Examples
--------
>>> x = np.ma.array(arange(6).reshape(2, 3))
>>> fl = x.flat
>>> type(fl)
>>> for item in fl:
... print item
...
0
1
2
3
4
5
Extracting more than a single element b indexing the `MaskedIterator`
returns a masked array:
>>> fl[2:4]
masked_array(data = [2 3],
mask = False,
fill_value = 999999)
c C sH | | _ | i i | _ | i t j o
d | _ n | i i | _ d S( N( RF R t flatt dataiterR R R t maskiter( R RF ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR! s
c C s | S( N( ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRg s c C sc | i i | i t | i } | i d j o+ | i i | } | i | _ | | _ n | S( N( R t __getitem__R R
RF R R R R ( R t indxR R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s $
c C s> t | | i | <| i d j o t | | i | >> x = np.ma.array([3, 2], mask=[0, 1])
>>> fl = x.flat
>>> fl.next()
3
>>> fl.next()
masked_array(data = --,
mask = True,
fill_value = 1e+20)
>>> fl.next()
Traceback (most recent call last):
File "", line 1, in
File "/home/ralf/python/numpy/numpy/ma/core.py", line 2243, in next
d = self.dataiter.next()
StopIteration
N( R t nextR R Rh ( R R; ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s
( R R R R! Rg R R R ( ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR o s . c
s_ f d t i | } | i } | i } t | t o t i g } | i D] } | t | i qW ~ } | i
t } t i g } t | D] } | t | i q ~ | _ n= t i g } | D] } | t | i q ~ } t
| d j o2 t | i } | | d >> ndtype = [('a', int), ('b', float)]
>>> a = np.array([(1, 1), (2, 2)], dtype=ndtype)
>>> flatten_structured_array(a)
array([[1., 1.],
[2., 2.]])
c 3 sP xI t | D]; } t | d o x" | D] } | Vq0 Wq
| Vq
Wd S( s( Flattens a compound of nested iterables.Rg N( t iterR ( t iterablet elmR ( t flatten_sequence( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s
i i ( R R R R R R R R R R R RJ R R R ( R t inishapeR R; t outt _[2]t _[3]R] ( ( R s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRD s ?
<<
c B s e Z d Z d Z e Z e Z e Z dy e dy e e d dy e dy dy e d Z d Z
d Z dy d Z dy dy d Z e i i e _ d Z d Z d
Z d Z d Z e d
Z e Z d Z e d e d e d d Z d Z d Z e d e Z d Z d Z e d d d d Z d Z! e d d d d Z" d Z# e d d d d Z$ d Z% e d e% Z& e d e% Z' d Z( d! Z) d" Z* e d e) d e* d d# Z+ d$ Z, dy d% Z- e d e, d e- d d& Z. dy d' Z/ d( Z0 dy dy d) Z1 d* Z2 d+ Z3 d, Z4 d- Z5 d. Z6 d/ Z7 d0 Z8 d1 Z9 d2 Z: d3 Z; d4 Z< d5 Z= d6 Z> d7 Z? d8 Z@ d9 ZA d: ZB d; ZC d< ZD d= ZE d> ZF d? ZG e d eG d d@ ZH dA ZI e d eI d dB ZJ dy dC ZK eL dD ZM dE ZN eL dF ZO dG ZP e e dH ZQ dI dJ ZR dK ZS dL ZT dy dy dM ZU dy dy dN ZV dO ZW d d dP dy dy dQ ZX e iX i eX _ dy dy dy dR ZY dy dy dy dS ZZ dy dy dy dT Z[ e[ Z\ dy dy dy dU Z] dy dy dy dV Z^ dy dy dW Z_ dy dy dy d dX Z` ea i` i e` _ dy dy dy d dY Zb ea ib i eb _ d dy dZ Zc e ic i ec _ dy dy d[ dy d\ Zd dy dy dy d] Ze dy dy dy d^ Zf d_ d[ dy e dy d` Zg dy dy dy da Zh dy db Zi dy dy dy dc Zj dy dy dy dd Zk eL de Zl eL df Zm eL dg Zn eL dh Zo e d di Zp eL dj Zq eL dk dl e Zr eL de Zl eL dm Zs dy dn Zt dy do dp Zu dq dr ds Zv dt Zw ew Zx du Zy dv Zz dw Z{ dy dx Z| RS(z s
An array class with possibly masked values.
Masked values of True exclude the corresponding element from any
computation.
Construction::
x = MaskedArray(data, mask=nomask, dtype=None, copy=True,
fill_value=None, keep_mask=True, hard_mask=False,
shrink=True)
Parameters
----------
data : array_like
Input data.
mask : sequence, optional
Mask. Must be convertible to an array of booleans with the same
shape as `data`. True indicates a masked (i.e. invalid) data.
dtype : dtype, optional
Data type of the output.
If `dtype` is None, the type of the data argument (``data.dtype``)
is used. If `dtype` is not None and different from ``data.dtype``,
a copy is performed.
copy : bool, optional
Whether to copy the input data (True), or to use a reference instead.
Default is False.
subok : bool, optional
Whether to return a subclass of `MaskedArray` if possible (True) or a
plain `MaskedArray`. Default is True.
ndmin : int, optional
Minimum number of dimensions. Default is 0.
fill_value : scalar, optional
Value used to fill in the masked values when necessary.
If None, a default based on the data-type is used.
keep_mask : bool, optional
Whether to combine `mask` with the mask of the input data, if any
(True), or to use only `mask` for the output (False). Default is True.
hard_mask : bool, optional
Whether to use a hard mask or not. With a hard mask, masked values
cannot be unmasked. Default is False.
shrink : bool, optional
Whether to force compression of an empty mask. Default is True.
i i c
s |
d j o t i d t |
} n t i | d | d | d t d | }
t | d t |
} t | t
o | i |
i j o
t } n t | | p | o t i
|
| }
n t i
|
t | }
t | d o' t | t o | i |
_ t } n |
i i p d } | o t |
i } n t } | t j o3| p3 | o
t |
_ qt i |
i d | |
_ q%t | t t f o y: t i g } | D] } | t | q~ d | } Wn t j
o
t } n X| t j o# | i o | |
_ t |
_ qq%| oE |
i i |
_ t |
_ t | t j o | i | i _ qq%t |
_ ny t i | d | d | } WnV t j
oJ t i g } | D] } | t | g t | q~ d | } n X| i |
i j o |
i! | i! } } | d j o t i" | |
i } nD | | j o t i# | |
i } n d d
} t$ | | | f t } n |
i t j o | |
_ | |
_ nj | p | |
_ | |
_ nL | o# f d |
i | n t i% | |
i |
_ t |
_ | d j o t | d d } n | d j o t& | |
i |
_' n | d j o t | d
t |
_( n
| |
_( | |
_) |
S( s
Create a new masked array from scratch.
Notes
-----
A masked array can also be created by taking a .view(MaskedArray).
s' The flag 'flag' is now called 'shrink'!R R+ R t ndmint
_baseclassR i s/ Mask and data not compatible: data size is %i, s mask size is %i.c sX xQ | i i D]C } | | | | } } | i i o | | q
| | O} q
Wd S( s' do a|=b on each field of a, recursivelyN( R R ( R R R t aft bf( t
_recursive_or( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR
s
R t _hardmaskN( (* R RX RY RZ R R R R1 R
R R R R R R R R R Re R R R R R RJ R R R t _sharedmaskR+ RI R R R R R R Rb R R R R ( R R R R R+ R R R t keep_maskt hard_maskR\ R[ t optionsR R R t names_t mdtypeR R= R t ndt nmR ( ( R s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt __new__@
s
'#
!
-
:
c C s+ | d j o t | t o t | } n t } h } | i t | d h | i t | d h t | t p | i t | d h n t d t | d d d t | d t d t | d t d t | d t d t | d | d | d | } | i i | | i i | d S(
s/ Copies some attributes of obj to self.
t _optinfot _basedictt __dict__R R R t _isfieldR N(
R R R R
t updateR1 R R R R ( R R R R t _dict( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR8
s$ c C s | i | t | t oK | i } | i o" t | d t | i | } qn t | d t } n t } | | _ | i t j o6 y | i | i _ Wq t
j
o t | _ q Xn d S( s$ Finalizes the masked array.
R N( R8 R R R R R1 Rf R R R R ( R R t odtypeR ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt __array_finalize__
s
" c
C s | i t | } | i | | d j o| i i | _ | \ } } } t t g } | D] } | t | qa ~ } t i
| d }
|
d j o t | d j o t t |
| t
} n t |
| t
} y t | d } Wn8 t j
o t | } n t j
o | i } n X| i } t i | | | | t j o | t j o
| } qq| | B} n | i d j o | o t S| | _ t | _ n | S( sp
Special hook for ufuncs.
Wraps the numpy array and sets the mask according to context.
i iN( ( R R
R8 R R R+ RH Rg RJ R2 R R R@ R R3 R t KeyErrorR R R R R Rh R R (
R R t contextR t funcR9 R R t argR= R0 R; R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt __array_wrap__
s8
0
c C sa | d j o6 | d j o t i | } q t i | | } n | d j on yB t | t o t i | | } d } n t i | | } Wq t j
o t i | | } q Xn t i | | | } t | d t t j oQ | d j o
| i } n t | } | i i | t | _ | i
| i _
n t | d d o
d | _ n | S( NR R ( R R R R R R1 R R Re R R R ( R R R
Rs R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s,
c C s t i | } | i i | i t | } | i | | i i } | d j o | i i t
| _ nT | i t j o
t | _ n7 | i i g } | D] } | | t
f q ~ | _ | i d j o t
| i | | _ n | S( s
Returns a copy of the MaskedArray cast to given newtype.
Returns
-------
output : MaskedArray
A copy of self cast to input newtype.
The returned record shape matches self.shape.
Examples
--------
>>> x = np.ma.array([[1,2,3.1],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
>>> print x
[[1.0 -- 3.1]
[-- 5.0 --]
[7.0 -- 9.0]]
>>> print x.astype(int32)
[[1 -- 3]
[-- 5 --]
[7 -- 9]]
N( R R R t astypeR R
R8 R R R RW R R R ( R RT Rs R R t n( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR > s !
6c C s7 t i t i | t | } | i } t | d t po t | t i o; | | } t | i
o t | d | } q | Sq3| t j o | | o t
Sn | i t | } | i | t | t o1 | i d j o | i | | _ n t | _ n | t j o | | | _ t | _ n | S( s` x.__getitem__(y) <==> x[y]
Return the item described by i, as a masked array.
R7 R N( R R R R R1 R R R t voidR> R Ri R Rh R
R8 R R R R R R ( R R t doutR R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR e s(
c C s5 | t j o
t d n t | t oc t i | i | | | i t j o t | i
| i | _ n t i | i | t | d S| i } t i
| d } t i
| d } t | i p d } | t j or | t j o t | i
| } | _ n | o t t g | | | x[i]=y
Set item described by index. If value is masked, masks those
locations.
s Cannot alter the masked element.NR R s. Flexible 'hard' masks are not yet supported...R+ i ( ( Rh R R R R R R R R Rf R R RI t __getattribute__R R R R R R R R1 R t unshare_maskR R R" Ra t NotImplementedErrorRg R ( R R Rr R t _dtypeR t nbfieldst dvalt mvalR t mindxt dindx( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR sf
c C s | i t | | S( s x.__getslice__(i, j) <==> x[i:j]
Return the slice described by (i, j). The use of negative
indices is not supported.
( R t slice( R R t j( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt __getslice__ s c C s | i t | | | d S( s x.__setslice__(i, j, value) <==> x[i:j]=value
Set the slice (i,j) of a to value. If value is masked, mask
those locations.
N( R R ( R R R Rr ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt __setslice__ s c C s t i | d } t i | d } | t j o
t } n | t j o/ | t j o d St | i | } | _ n | i d j o% | i
o | | O} q| | _ n8| i } t
i | d t } | i pX | i i d j o2 t
i t | i g t | d | } q| i | } ny y t
i | d | d | } WnV t j
oJ t
i g } | D] } | t | g t | qm~ d | } n X| i
o, x2 | i D] } | | c | | Oh s s Hardness of the maskc C s- | i o | i i | _ t | _ n | S( sS
Copy the mask and set the sharedmask flag to False.
Whether the mask is shared between masked arrays can be seen from
the `sharedmask` property. `unshare_mask` ensures the mask is not shared.
A copy of the mask is only made if it was shared.
See Also
--------
sharedmask
( R R R+ R ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR l s
c C s | i S( ( R ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR ~ s s% Share status of the mask (read-only).c C s2 | i } | i o | i o
t | _ n | S( s
Reduce a mask to nomask when possible.
Parameters
----------
None
Returns
-------
None
Examples
--------
>>> x = np.ma.array([[1,2 ], [3, 4]], mask=[0]*4)
>>> x.mask
array([[False, False],
[False, False]], dtype=bool)
>>> x.shrink_mask()
>>> x.mask
False
( R R7 R R ( R R= ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt shrink_mask s
c C s | i S( ( R ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s s) Class of the underlying data (read-only).c C s t i | | i S( sU Return the current data, as a view of the original
underlying data.
( R R R ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt _get_data s c C s t i d t | i S( s
Return the data part of the masked array.
DEPRECATED: You should really use ``.data`` instead.
Examples
--------
>>> x = np.ma.array([1, 2, 3], mask=[False, True, False])
>>> x
masked_array(data = [1 -- 3],
mask = [False True False],
fill_value = 999999)
>>> x.data
array([1, 2, 3])
s Use .data instead.( RX RY RZ R ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt raw_data s c C s
t | S( s! Return a flat iterator.
( R ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt _get_flat s c C s | i } | | (d S( s3 Set a flattened version of self to value.
N( R ( R Rr t y( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt _set_flat s s Flat version of the array.c C s0 | i d j o t d | i | _ n | i S( s
Return the filling value of the masked array.
Returns
-------
fill_value : scalar
The filling value.
Examples
--------
>>> for dt in [np.int32, np.int64, np.float64, np.complex128]:
... np.ma.array([0, 1], dtype=dt).get_fill_value()
...
999999
999999
1e+20
(1e+20+0j)
>>> x = np.ma.array([0, 1.], fill_value=-np.inf)
>>> x.get_fill_value()
-inf
N( R R R R ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s c C s t | | i | _ d S( s
Set the filling value of the masked array.
Parameters
----------
value : scalar, optional
The new filling value. Default is None, in which case a default
based on the data type is used.
See Also
--------
ma.set_fill_value : Equivalent function.
Examples
--------
>>> x = np.ma.array([0, 1.], fill_value=-np.inf)
>>> x.fill_value
-inf
>>> x.set_fill_value(np.pi)
>>> x.fill_value
3.1415926535897931
Reset to default:
>>> x.set_fill_value()
>>> x.fill_value
1e+20
N( R R R ( R Rr ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s s Filling value.c C s~ | i } | t j o | i S| d j o
| i } n t | | i } | t j o t i | S| i i
o& | i i } t | | i | n | i
p | i S| i i } y t i | | | Wn t t f j
o@ t | d t } | i t } t i | | | f } nT t j
oG | i i o qz| o t i | d | i } qz| i } n X| S( s
Return a copy of self, where masked values are filled with a fill value.
If `fill_value` is None, `MaskedArray.fill_value` is used instead.
Parameters
----------
fill_value : scalar, optional
The value to use for invalid entries. Default is None.
Notes
-----
The result is **not** a MaskedArray!
Examples
--------
>>> x = np.ma.array([1,2,3,4,5], mask=[0,0,1,0,1], fill_value=-999)
>>> x.filled()
array([1, 2, -999, 4, -999])
>>> type(x.filled())
Subclassing is preserved. This means that if the data part of the masked
array is a matrix, `filled` returns a matrix:
>>> x = np.ma.array(np.matrix([[1, 2], [3, 4]]), mask=[[0, 1], [1, 0]])
>>> x.filled()
matrix([[ 1, 999999],
[999999, 4]])
R N( R R R R R R R Ru R R R R+ R R R R R t narrayt objectR R$ Rm R R ( R R R= R R; ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR@
s6
c C sN t i | i } | i t j o( | i t i t i | i } n | S( s
Return all the non-masked data as a 1-D array.
Returns
-------
data : ndarray
A new `ndarray` holding the non-masked data is returned.
Notes
-----
The result is **not** a MaskedArray!
Examples
--------
>>> x = np.ma.array(np.arange(5), mask=[0]*2 + [1]*3)
>>> x.compressed()
array([0, 1])
>>> type(x.compressed())
( R R R R R R' R Ra ( R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR( R
s (c C s | i | i } } t i | d t d t } | i | d | d | i t | } | i | | t j o | i | d | | _ n | S( sI
Return `a` where condition is ``True``.
If condition is a `MaskedArray`, missing values are considered
as ``False``.
Parameters
----------
condition : var
Boolean 1-d array selecting which entries to return. If len(condition)
is less than the size of a along the axis, then output is truncated
to length of condition array.
axis : {None, int}, optional
Axis along which the operation must be performed.
out : {None, ndarray}, optional
Alternative output array in which to place the result. It must have
the same shape as the expected output but the type will be cast if
necessary.
Returns
-------
result : MaskedArray
A :class:`MaskedArray` object.
Notes
-----
Please note the difference with :meth:`compressed` !
The output of :meth:`compress` has a mask, the output of
:meth:`compressed` does not.
Examples
--------
>>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
>>> print x
[[1 -- 3]
[-- 5 --]
[7 -- 9]]
>>> x.compress([1, 0, 1])
masked_array(data = [1 3],
mask = [False False],
fill_value=999999)
>>> x.compress([1, 0, 1], axis=1)
masked_array(data =
[[1 3]
[-- --]
[7 9]],
mask =
[[False False]
[ True True]
[False False]],
fill_value=999999)
R+ R RJ R (
R R R R R R' R R
R8 R ( R Rn RJ R R R t _new( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR' n
s 8*
c C s t i opt } | t j o t | S| i } | t j o
| i } q| i d j o | i i o~ | i
t t | i f } | i
oB t i | i i d t } t i | | | t t | St | i Sq | o t | St | i Sn | i i } | d j o | i i d } | | | Raise self to the power other, masking the potential NaNs/Infs( R ( R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt __pow__D s c C s t | } | i t j oI | t j o8 | i o+ t | i | i | _ | i | 7_ q n! | t j o | i | 7_ n t i | i t
i | i d t | | S( s Add other to self in-place.i (
RI R R R Rf R R R t __iadd__R R R RH ( R R R= ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR H s
+c C s t | } | i t j oI | t j o8 | i o+ t | i | i | _ | i | 7_ q n! | t j o | i | 7_ n t i | i t
i | i d t | | S( s" Subtract other from self in-place.i (
RI R R R Rf R R R t __isub__R R R RH ( R R R= ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR U s
+c C s t | } | i t j oI | t j o8 | i o+ t | i | i | _ | i | 7_ q n! | t j o | i | 7_ n t i | i t
i | i d t | | S( s Multiply self by other in-place.i (
RI R R R Rf R R R t __imul__R R R RH ( R R R= ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR a s
+c C s t | } t i | i | } t | } t | | } | i o, t t i \ } } t i
| | | } n | i | O_ t i
| i t i
| i d | | S( s Divide self by other in-place.i ( RH R' R$ R RI Rg R R3 R R5 R R R t __idiv__( R R t
other_datat dom_maskt
other_maskt new_maskR R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR
m s
%c C s t | } t | } t i | i t i | i d | t i t i | i } | i
oI | i t j o | i | O_ n
| | _ t i | i | | i
n t | | } t | i | | _ | S( s( Raise self to the power other, in place.i ( RH RI R t __ipow__R R R R Ra R R R R R Rg ( R R R R
R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR | s %
c C sO | i d j o t d n | i o t i d t i St | i S( s Convert to float.i s7 Only length-1 arrays can be converted to Python scalarss, Warning: converting a masked element to nan.( R R R RX RY R t nanR R ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt __float__ s
c C sG | i d j o t d n | i o
t d n t | i S( s Convert to int.i s7 Only length-1 arrays can be converted to Python scalarss. Cannot convert masked element to a Python int.( R R R R R R ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt __int__ s
c C s/ | i i i t | } | i | i | S( s
Return the imaginary part of the masked array.
The returned array is a view on the imaginary part of the `MaskedArray`
whose `get_imag` method is called.
Parameters
----------
None
Returns
-------
result : MaskedArray
The imaginary part of the masked array.
See Also
--------
get_real, real, imag
Examples
--------
>>> x = np.ma.array([1+1.j, -2j, 3.45+1.6j], mask=[False, True, False])
>>> x.get_imag()
masked_array(data = [1.0 -- 1.6],
mask = [False True False],
fill_value = 1e+20)
( R t imagR R
R R ( R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt get_imag s s Imaginary part.c C s/ | i i i t | } | i | i | S( s
Return the real part of the masked array.
The returned array is a view on the real part of the `MaskedArray`
whose `get_real` method is called.
Parameters
----------
None
Returns
-------
result : MaskedArray
The real part of the masked array.
See Also
--------
get_imag, real, imag
Examples
--------
>>> x = np.ma.array([1+1.j, -2j, 3.45+1.6j], mask=[False, True, False])
>>> x.get_real()
masked_array(data = [1.0 -- 3.45],
mask = [False True False],
fill_value = 1e+20)
( R t realR R
R R ( R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt get_real s s Real partc C s | i } | i } t | } | t j oo | d j o d S| d j o | d S| d j o | i S| | } t | } | | =t i | | Sn t i | | } | i t
i | } | d j o | | St | | Sd S( s
Count the non-masked elements of the array along the given axis.
Parameters
----------
axis : int, optional
Axis along which to count the non-masked elements. If `axis` is
`None`, all non-masked elements are counted.
Returns
-------
result : int or ndarray
If `axis` is `None`, an integer count is returned. When `axis` is
not `None`, an array with shape determined by the lengths of the
remaining axes, is returned.
See Also
--------
count_masked : Count masked elements in array or along a given axis.
Examples
--------
>>> import numpy.ma as ma
>>> a = ma.arange(6).reshape((2, 3))
>>> a[1, :] = ma.masked
>>> a
masked_array(data =
[[0 1 2]
[-- -- --]],
mask =
[[False False False]
[ True True True]],
fill_value = 999999)
>>> a.count()
3
When the `axis` keyword is specified an array of appropriate size is
returned.
>>> a.count(axis=0)
array([1, 1, 1])
>>> a.count(axis=1)
array([3, 0])
i i N(
R R R R R R R R R R R R R ( R RJ R= R t lsR RL t n1t n2( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR. s& .
t flattenc C sp t i | i i t | } | i | | i t j o% t i | i i | i | _ n
t | _ | S( s
Returns a 1D version of self, as a view.
Returns
-------
MaskedArray
Output view is of shape ``(self.size,)`` (or
``(np.ma.product(self.shape),)``).
Examples
--------
>>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
>>> print x
[[1 -- 3]
[-- 5 --]
[7 -- 9]]
>>> print x.ravel()
[1 -- 3 -- 5 -- 7 -- 9]
(
R R R R R
R8 R R R R ( R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR + s !
% R c O s | i d | i d d | i i | | i t | } | i | | i } | t j o | i | | | _ n | S( s
Give a new shape to the array without changing its data.
Returns a masked array containing the same data, but with a new shape.
The result is a view on the original array; if this is not possible, a
ValueError is raised.
Parameters
----------
shape : int or tuple of ints
The new shape should be compatible with the original shape. If an
integer is supplied, then the result will be a 1-D array of that
length.
order : {'C', 'F'}, optional
Determines whether the array data should be viewed as in C
(row-major) or FORTRAN (column-major) order.
Returns
-------
reshaped_array : array
A new view on the array.
See Also
--------
reshape : Equivalent function in the masked array module.
numpy.ndarray.reshape : Equivalent method on ndarray object.
numpy.reshape : Equivalent function in the NumPy module.
Notes
-----
The reshaping operation cannot guarantee that a copy will not be made,
to modify the shape in place, use ``a.shape = s``
Examples
--------
>>> x = np.ma.array([[1,2],[3,4]], mask=[1,0,0,1])
>>> print x
[[-- 2]
[3 --]]
>>> x = x.reshape((4,1))
>>> print x
[[--]
[2]
[3]
[--]]
t ordert C( R R R R R R
R8 R R ( R R R: R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR J s 0 $
c C s d } t | d S( sv
.. warning::
This method does nothing, except raise a ValueError exception. A
masked array does not own its data and therefore cannot safely be
resized in place. Use the `numpy.ma.resize` function instead.
This method is difficult to implement safely and may be deprecated in
future releases of NumPy.
so A masked array does not own its data and therefore cannot be resized.
Use the numpy.ma.resize function instead.N( R ( R R] t refcheckR R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s t raisec C s1 | i } | i oq | i t j oa | i | } t | d t } t | d t d t } | i | i | | } | | } n | i i | | d | | t j o t
| } nk | i } t
| t j o | i | t d | n | i | | i d | t | d t d t } | | _ d S( s
Set storage-indexed locations to corresponding values.
Sets self._data.flat[n] = values[n] for each n in indices.
If `values` is shorter than `indices` then it will repeat.
If `values` has some masked values, the initial mask is updated
in consequence, else the corresponding values are unmasked.
Parameters
----------
indices : 1-D array_like
Target indices, interpreted as integers.
values : array_like
Values to place in self._data copy at target indices.
mode : {'raise', 'wrap', 'clip'}, optional
Specifies how out-of-bounds indices will behave.
'raise' : raise an error.
'wrap' : wrap around.
'clip' : clip to the range.
Notes
-----
`values` can be a scalar or length 1 array.
Examples
--------
>>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
>>> print x
[[1 -- 3]
[-- 5 --]
[7 -- 9]]
>>> x.put([0,4,8],[10,20,30])
>>> print x
[[10 -- 3]
[-- 20 --]
[7 -- 30]]
>>> x.put(4,999)
>>> print x
[[10 -- 3]
[-- 999 --]
[7 -- 30]]
R+ R t modeR[ N(
R R R R R R R R R R RI R+ Rd ( R RQ t valuesR R= R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s" -
c C s@ | i t j o | i i t t f S| i i | i i i f S( s
Return the addresses of the data and mask areas.
Parameters
----------
None
Examples
--------
>>> x = np.ma.array([1, 2, 3], mask=[0, 1, 1])
>>> x.ids()
(166670640, 166659832)
If the array has no mask, the address of `nomask` is returned. This address
is typically not close to the data in memory:
>>> x = np.ma.array([1, 2, 3])
>>> x.ids()
(166691080, 3083169284L)
( R R t ctypesR t id( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRP s c C s | i d S( s
Return a boolean indicating whether the data is contiguous.
Parameters
----------
None
Examples
--------
>>> x = np.ma.array([1, 2, 3])
>>> x.iscontiguous()
True
`iscontiguous` returns one of the flags of the masked array:
>>> x.flags
C_CONTIGUOUS : True
F_CONTIGUOUS : True
OWNDATA : False
WRITEABLE : True
ALIGNED : True
UPDATEIFCOPY : False
t
CONTIGUOUS( t flags( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt iscontiguous s c C s t | i | } | d j oV | i t i d | i t | } | i o | i | n
| o t
S| S| i t i d | d | t | t o& | i p | o | i | q n | S( s
Check if all of the elements of `a` are true.
Performs a :func:`logical_and` over the given axis and returns the result.
Masked values are considered as True during computation.
For convenience, the output array is masked where ALL the values along the
current axis are masked: if the output would have been a scalar and that
all the values are masked, then the output is `masked`.
Parameters
----------
axis : {None, integer}
Axis to perform the operation over.
If None, perform over flattened array.
out : {None, array}, optional
Array into which the result can be placed. Its type is preserved
and it must be of the right shape to hold the output.
See Also
--------
all : equivalent function
Examples
--------
>>> np.ma.array([1,2,3]).all()
True
>>> a = np.ma.array([1,2,3], mask=True)
>>> (a.all() is np.ma.masked)
True
RJ R N(
Rl R R R@ R R R R
R7 R Rh R R ( R RJ R R R; ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s
*
c C s t | i | } | d j o[ | i t i d | i t | } | i o | i | n | o
t
} n | S| i t i d | d | t | t o& | i p | o | i | q n | S( s
Check if any of the elements of `a` are true.
Performs a logical_or over the given axis and returns the result.
Masked values are considered as False during computation.
Parameters
----------
axis : {None, integer}
Axis to perform the operation over.
If None, perform over flattened array and return a scalar.
out : {None, array}, optional
Array into which the result can be placed. Its type is preserved
and it must be of the right shape to hold the output.
See Also
--------
any : equivalent function
RJ R N(
Rl R R R@ R R R R
R7 R Rh R R ( R RJ R R R; ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR F s
*
c C s t | i d d t i S( s
Return the indices of unmasked elements that are not zero.
Returns a tuple of arrays, one for each dimension, containing the
indices of the non-zero elements in that dimension. The corresponding
non-zero values can be obtained with::
a[a.nonzero()]
To group the indices by element, rather than dimension, use
instead::
np.transpose(a.nonzero())
The result of this is always a 2d array, with a row for each non-zero
element.
Parameters
----------
None
Returns
-------
tuple_of_arrays : tuple
Indices of elements that are non-zero.
See Also
--------
numpy.nonzero :
Function operating on ndarrays.
flatnonzero :
Return indices that are non-zero in the flattened version of the input
array.
ndarray.nonzero :
Equivalent ndarray method.
Examples
--------
>>> import numpy.ma as ma
>>> x = ma.array(np.eye(3))
>>> x
masked_array(data =
[[ 1. 0. 0.]
[ 0. 1. 0.]
[ 0. 0. 1.]],
mask =
False,
fill_value=1e+20)
>>> x.nonzero()
(array([0, 1, 2]), array([0, 1, 2]))
Masked elements are ignored.
>>> x[1, 1] = ma.masked
>>> x
masked_array(data =
[[1.0 0.0 0.0]
[0.0 -- 0.0]
[0.0 0.0 1.0]],
mask =
[[False False False]
[False True False]
[False False False]],
fill_value=1e+20)
>>> x.nonzero()
(array([0, 2]), array([0, 2]))
Indices can also be grouped by element.
>>> np.transpose(x.nonzero())
array([[0, 0],
[2, 2]])
A common use for ``nonzero`` is to find the indices of an array, where
a condition is True. Given an array `a`, the condition `a` > 3 is a
boolean array and since False is interpreted as 0, ma.nonzero(a > 3)
yields the indices of the `a` where the condition is true.
>>> a = ma.array([[1,2,3],[4,5,6],[7,8,9]])
>>> a > 3
masked_array(data =
[[False False False]
[ True True True]
[ True True True]],
mask =
False,
fill_value=999999)
>>> ma.nonzero(a > 3)
(array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))
The ``nonzero`` method of the condition array can also be called.
>>> (a > 3).nonzero()
(array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))
i R+ ( R R@ R R ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR j s ai c C s | i } | t j o; t t | i d | d | d | d | } | i | S| i d | d | d | } | i | i d i d d d | Sd S( s8
(this docstring should be overwritten)
t offsett axis1t axis2R i RJ N(
R R t superR R R R3 R@ R R ( R R& R' R( R R R= R t D( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s
c C s t i | d } t | | } | d j os | i d i | d | } t | d d } | o& | i t | } | i | n | o
t
} n | S| i d i | d | d | } t | t oF t | d t
} | t
j o t | i } | _ n | | _ n | S( s
Return the sum of the array elements over the given axis.
Masked elements are set to 0 internally.
Parameters
----------
axis : {None, -1, int}, optional
Axis along which the sum is computed. The default
(`axis` = None) is to compute over the flattened array.
dtype : {None, dtype}, optional
Determines the type of the returned array and of the accumulator
where the elements are summed. If dtype has the value None and
the type of a is an integer type of precision less than the default
platform integer, then the default platform integer precision is
used. Otherwise, the dtype is the same as that of a.
out : {None, 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.
Returns
-------
sum_along_axis : MaskedArray or scalar
An array with the same shape as self, with the specified
axis removed. If self is a 0-d array, or if `axis` is None, a scalar
is returned. If an output array is specified, a reference to
`out` is returned.
Examples
--------
>>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
>>> print x
[[1 -- 3]
[-- 5 --]
[7 -- 9]]
>>> print x.sum()
25
>>> print x.sum(axis=1)
[4 5 16]
>>> print x.sum(axis=0)
[8 5 12]
>>> print type(x.sum(axis=0, dtype=np.int64)[0])
R i R R7 R N( R R Rl R R@ R R1 R R
R Rh R R R Rf R R R ( R RJ R R R R` R t rndimt outmask( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s$ .
$
c C s | i d i d | d | d | } | d j o) t | t o | i | i n | S| i t | } | i | i | S( sg
Return the cumulative sum of the elements along the given axis.
The cumulative sum is calculated over the flattened array by
default, otherwise over the specified axis.
Masked values are set to 0 internally during the computation.
However, their position is saved, and the result will be masked at
the same locations.
Parameters
----------
axis : {None, -1, int}, optional
Axis along which the sum is computed. The default (`axis` = None) is to
compute over the flattened array. `axis` may be negative, in which case
it counts from the last to the first axis.
dtype : {None, dtype}, optional
Type of the returned array and of the accumulator in which the
elements are summed. If `dtype` is not specified, it defaults
to the dtype of `a`, unless `a` has an integer dtype with a
precision less than that of the default platform integer. In
that case, the default platform integer is used.
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.
Returns
-------
cumsum : ndarray.
A new array holding the result is returned unless ``out`` is
specified, in which case a reference to ``out`` is returned.
Notes
-----
The mask is lost if `out` is not a valid :class:`MaskedArray` !
Arithmetic is modular when using integer types, and no error is
raised on overflow.
Examples
--------
>>> marr = np.ma.array(np.arange(10), mask=[0,0,0,1,1,1,0,0,0,0])
>>> print marr.cumsum()
[0 1 3 -- -- -- 9 16 24 33]
i RJ R R N(
R@ R0 R R R R R R R
R ( R RJ R R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR0 ! s /'
c C s t i | d } t | | } | d j os | i d i | d | } t | d d } | o& | i t | } | i | n | o
t
} n | S| i d i | d | d | } t | t oF t | d t
} | t
j o t | i } | _ n | | _ n | S( s
Return the product of the array elements over the given axis.
Masked elements are set to 1 internally for computation.
Parameters
----------
axis : {None, int}, optional
Axis over which the product is taken. If None is used, then the
product is over all the array elements.
dtype : {None, dtype}, optional
Determines the type of the returned array and of the accumulator
where the elements are multiplied. If ``dtype`` has the value ``None``
and the type of a is an integer type of precision less than the default
platform integer, then the default platform integer precision is
used. Otherwise, the dtype is the same as that of a.
out : {None, array}, optional
Alternative output array in which to place the result. It must have
the same shape as the expected output but the type will be cast if
necessary.
Returns
-------
product_along_axis : {array, scalar}, see dtype parameter above.
Returns an array whose shape is the same as a with the specified
axis removed. Returns a 0d array when a is 1d or axis=None.
Returns a reference to the specified output array if specified.
See Also
--------
prod : equivalent function
Notes
-----
Arithmetic is modular when using integer types, and no error is raised
on overflow.
Examples
--------
>>> np.prod([1.,2.])
2.0
>>> np.prod([1.,2.], dtype=np.int32)
2
>>> np.prod([[1.,2.],[3.,4.]])
24.0
>>> np.prod([[1.,2.],[3.,4.]], axis=1)
array([ 2., 12.])
R i R R7 i R N( R R Rl R R@ R R1 R R
R Rh R R R Rf R R R ( R RJ R R R R` R R+ R, ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR Z s$ 1
$
c C s | i d i d | d | d | } | d j o) t | t o | i | i n | S| i t | } | i | i | S( ss
Return the cumulative product of the elements along the given axis.
The cumulative product is taken over the flattened array by
default, otherwise over the specified axis.
Masked values are set to 1 internally during the computation.
However, their position is saved, and the result will be masked at
the same locations.
Parameters
----------
axis : {None, -1, int}, optional
Axis along which the product is computed. The default
(`axis` = None) is to compute over the flattened array.
dtype : {None, dtype}, optional
Determines the type of the returned array and of the accumulator
where the elements are multiplied. If ``dtype`` has the value ``None``
and the type of ``a`` is an integer type of precision less than the
default platform integer, then the default platform integer precision
is used. Otherwise, the dtype is the same as that of ``a``.
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.
Returns
-------
cumprod : ndarray
A new array holding the result is returned unless out is specified,
in which case a reference to out is returned.
Notes
-----
The mask is lost if `out` is not a valid MaskedArray !
Arithmetic is modular when using integer types, and no error is
raised on overflow.
i RJ R R N( R@ R/ R R R R R R R
( R RJ R R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR/ s ('
c C s | i t j o% t t | i d | d | } n9 | i d | d | } | i d | } | d | } | d j op | | _ t | t oR t
| d t } | t j o t | i } | _ n t
| d t | _ n | S| S( s
Returns the average of the array elements.
Masked entries are ignored.
The average is taken over the flattened array by default, otherwise over
the specified axis. Refer to `numpy.mean` for the full documentation.
Parameters
----------
a : array_like
Array containing numbers whose mean is desired. If `a` is not an
array, a conversion is attempted.
axis : int, optional
Axis along which the means are computed. The default is to compute
the mean of the flattened array.
dtype : dtype, optional
Type to use in computing the mean. For integer inputs, the default
is float64; for floating point, inputs it is the same as the input
dtype.
out : ndarray, optional
Alternative output array in which to place the result. It must have
the same shape as the expected output but the type will be cast if
necessary.
Returns
-------
mean : ndarray, see dtype parameter above
If `out=None`, returns a new array containing the mean values,
otherwise a reference to the output array is returned.
See Also
--------
numpy.ma.mean : Equivalent function.
numpy.mean : Equivalent function on non-masked arrays.
numpy.ma.average: Weighted average.
Examples
--------
>>> a = np.ma.array([1,2,3], mask=[False, False, True])
>>> a
masked_array(data = [1 2 --],
mask = [False False True],
fill_value = 999999)
>>> a.mean()
1.5
RJ R g ?R N(
R R R) R R{ R R. R R R R1 Rf R ( R RJ R R R t dsumt cntR, ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR{ s 0%
c C s7 | i | | } | p | | S| t | | Sd S( s
Compute the anomalies (deviations from the arithmetic mean)
along the given axis.
Returns an array of anomalies, with the same shape as the input and
where the arithmetic mean is computed along the given axis.
Parameters
----------
axis : int, optional
Axis over which the anomalies are taken.
The default is to use the mean of the flattened array as reference.
dtype : dtype, optional
Type to use in computing the variance. For arrays of integer type
the default is float32; for arrays of float types it is the same as
the array type.
See Also
--------
mean : Compute the mean of the array.
Examples
--------
>>> a = np.ma.array([1,2,3])
>>> a.anom()
masked_array(data = [-1. 0. 1.],
mask = False,
fill_value = 1e+20)
N( R{ R< ( R RJ R R= ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s c C s | i t j o& | i i d | d | d | d | S| i d | | } | i d | d | } t | o t i | d } n | | 9} t | i
| | i t | } | i
o5 t | i i | | | j | _ | i | n t | d t or t } | d j o[ t | t o | i t n6 | i i d j o d } t | n
t i | _ | Sn | d j o2 | | _ t | t o | i | i n | S| S(
R RJ R R t ddofi R t bius> Masked data information would be lost in one or more location.N( R R R R R. R R R" R R5 R R R
R7 Rg R R8 R1 R Rh R R R R R R R R R R R R ( R RJ R R R/ R. t danomt dvarR ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR 9 s6 &
'
$
c C sa | i d | d | d | d | } | t j o, t | } | d j o | d C} | Sn | S( R RJ R R R/ g ?N( R Rh R R ( R RJ R R R/ R2 ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR c s $
c C s} | i i d | d | i t | } | i | _ | i | | d j o | St | t o | i | i n | S( s
Return an array rounded a to the given number of decimals.
Refer to `numpy.around` for full documentation.
See Also
--------
numpy.around : equivalent function
t decimalsR N(
R R R R
R R8 R R R R ( R R3 R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR o s *
t quicksortc C sQ | d j o t | } n | i | i t } | i d | d | d | S( s6
Return an ndarray of indices that sort the array along the
specified axis. Masked values are filled beforehand to
`fill_value`.
Parameters
----------
axis : int, optional
Axis along which to sort. The default is -1 (last axis).
If None, the flattened array is used.
fill_value : var, optional
Value used to fill the array before sorting.
The default is the `fill_value` attribute of the input array.
kind : {'quicksort', 'mergesort', 'heapsort'}, optional
Sorting algorithm.
order : list, optional
When `a` is an array with fields defined, this argument specifies
which fields to compare first, second, etc. Not all fields need be
specified.
Returns
-------
index_array : ndarray, int
Array of indices that sort `a` along the specified axis.
In other words, ``a[index_array]`` yields a sorted `a`.
See Also
--------
sort : Describes sorting algorithms used.
lexsort : Indirect stable sort with multiple keys.
ndarray.sort : Inplace sort.
Notes
-----
See `sort` for notes on the different sorting algorithms.
Examples
--------
>>> a = np.ma.array([3,2,1], mask=[False, False, True])
>>> a
masked_array(data = [3 2 --],
mask = [False False True],
fill_value = 999999)
>>> a.argsort()
array([1, 0, 2])
RJ R R N( R R1 R@ R R R ( R RJ R R R R; ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s 1
c C sH | d j o t | } n | i | i t } | i | d | S( s
Return array of indices to the minimum values along the given axis.
Parameters
----------
axis : {None, integer}
If None, the index is into the flattened array, otherwise along
the specified axis
fill_value : {var}, optional
Value used to fill in the masked values. If None, the output of
minimum_fill_value(self._data) is used instead.
out : {None, array}, optional
Array into which the result can be placed. Its type is preserved
and it must be of the right shape to hold the output.
Returns
-------
{ndarray, scalar}
If multi-dimension input, returns a new ndarray of indices to the
minimum values along the given axis. Otherwise, returns a scalar
of index to the minimum values along the given axis.
Examples
--------
>>> x = np.ma.array(arange(4), mask=[1,1,0,0])
>>> x.shape = (2,2)
>>> print x
[[-- --]
[2 3]]
>>> print x.argmin(axis=0, fill_value=-1)
[0 0]
>>> print x.argmin(axis=0, fill_value=9)
[1 1]
R N( R R~ R@ R R R ( R RJ R R R; ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s $
c C sK | d j o t | i } n | i | i t } | i | d | S( s
Returns array of indices of the maximum values along the given axis.
Masked values are treated as if they had the value fill_value.
Parameters
----------
axis : {None, integer}
If None, the index is into the flattened array, otherwise along
the specified axis
fill_value : {var}, optional
Value used to fill in the masked values. If None, the output of
maximum_fill_value(self._data) is used instead.
out : {None, array}, optional
Array into which the result can be placed. Its type is preserved
and it must be of the right shape to hold the output.
Returns
-------
index_array : {integer_array}
Examples
--------
>>> a = np.arange(6).reshape(2,3)
>>> a.argmax()
5
>>> a.argmax(0)
array([1, 1, 1])
>>> a.argmax(1)
array([2, 2])
R N( R Rz R R@ R R R ( R RJ R R R; ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s
ic C s | i t j o# t i | d | d | d | n | d j o' | o t | } qm t | } n | } t i | i } | i
| i d | d | d | | | <| i } | i | i
} | i | i
}
|
| i _
| | i _
d S( s
Return a sorted copy of an array.
Parameters
----------
a : array_like
Array to be sorted.
axis : int or None, optional
Axis along which to sort. If None, the array is flattened before
sorting. The default is -1, which sorts along the last axis.
kind : {'quicksort', 'mergesort', 'heapsort'}, optional
Sorting algorithm. Default is 'quicksort'.
order : list, optional
When `a` is a structured array, this argument specifies which fields
to compare first, second, and so on. This list does not need to
include all of the fields.
endwith : {True, False}, optional
Whether missing values (if any) should be forced in the upper indices
(at the end of the array) (True) or lower indices (at the beginning).
fill_value : {var}
Value used to fill in the masked values. If None, use
the the output of minimum_fill_value().
Returns
-------
sorted_array : ndarray
Array of the same type and shape as `a`.
See Also
--------
ndarray.sort : Method to sort an array in-place.
argsort : Indirect sort.
lexsort : Indirect stable sort on multiple keys.
searchsorted : Find elements in a sorted array.
Notes
-----
The various sorting algorithms are characterized by their average speed,
worst case performance, work space size, and whether they are stable. A
stable sort keeps items with the same key in the same relative
order. The three available algorithms have the following
properties:
=========== ======= ============= ============ =======
kind speed worst case work space stable
=========== ======= ============= ============ =======
'quicksort' 1 O(n^2) 0 no
'mergesort' 2 O(n*log(n)) ~n/2 yes
'heapsort' 3 O(n*log(n)) 0 no
=========== ======= ============= ============ =======
All the sort algorithms make temporary copies of the data when
sorting along any but the last axis. Consequently, sorting along
the last axis is faster and uses less space than sorting along
any other axis.
Examples
--------
>>> a = np.array([[1,4],[3,1]])
>>> np.sort(a) # sort along the last axis
array([[1, 4],
[1, 3]])
>>> np.sort(a, axis=None) # sort the flattened array
array([1, 1, 3, 4])
>>> np.sort(a, axis=0) # sort along the first axis
array([[1, 1],
[3, 4]])
Use the `order` keyword to specify a field to use when sorting a
structured array:
>>> dtype = [('name', 'S10'), ('height', float), ('age', int)]
>>> values = [('Arthur', 1.8, 41), ('Lancelot', 1.9, 38),
... ('Galahad', 1.7, 38)]
>>> a = np.array(values, dtype=dtype) # create a structured array
>>> np.sort(a, order='height') # doctest: +SKIP
array([('Galahad', 1.7, 38), ('Arthur', 1.8, 41),
('Lancelot', 1.8999999999999999, 38)],
dtype=[('name', '|S10'), ('height', '>> np.sort(a, order=['age', 'height']) # doctest: +SKIP
array([('Galahad', 1.7, 38), ('Lancelot', 1.8999999999999999, 38),
('Arthur', 1.8, 41)],
dtype=[('name', '|S10'), ('height', ' Masked data information would be lost in one or more location.N( R R Rl R R~ R@ R| R R
R7 R R R R Rh R R R1 R Rf R R R R R R R ( R RJ R R R R` R R, R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR| | s0
0
!
c C s, | d j o t | St i | | Sd S( s
Return the array minimum along the specified axis.
Parameters
----------
axis : int, optional
The axis along which to find the minima. Default is None, in which case
the minimum value in the whole array is returned.
Returns
-------
min : scalar or MaskedArray
If `axis` is None, the result is a scalar. Otherwise, if `axis` is
given and the array is at least 2-D, the result is a masked array with
dimension one smaller than the array on which `mini` is called.
Examples
--------
>>> x = np.ma.array(np.arange(6), mask=[0 ,1, 0, 0, 0 ,1]).reshape(3, 2)
>>> print x
[[0 --]
[2 3]
[4 --]]
>>> x.mini()
0
>>> x.mini(axis=0)
masked_array(data = [0 3],
mask = [False False],
fill_value = 999999)
>>> print x.mini(axis=1)
[0 2 4]
N( R R} RH ( R RJ ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt mini s "
c C s t i | d } t | | } | d j o t | } n | d j o | i | i d | d | i t | } | i o5 | i
| | i o t i | | | i
q n | o
t } n | S| i | i d | d | } t | t oF t | d t } | t j o t | i } | _ n | | _ n@ | i i d j o d } t | n t i | | t i | S( si
Return the maximum along a given axis.
Parameters
----------
axis : {None, int}, optional
Axis along which to operate. By default, ``axis`` is None and the
flattened input is used.
out : array_like, optional
Alternative output array in which to place the result. Must
be of the same shape and buffer length as the expected output.
fill_value : {var}, optional
Value used to fill in the masked values.
If None, use the output of maximum_fill_value().
Returns
-------
amax : array_like
New array holding the result.
If ``out`` was specified, ``out`` is returned.
See Also
--------
maximum_fill_value
Returns the maximum filling value for a given datatype.
R RJ R R0 s> Masked data information would be lost in one or more location.N( R R Rl R Rz R@ Rx R R
R7 R R R R Rh R R R1 R Rf R R R R R R R ( R RJ R R R R` R R, R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRx s0
0
!
c C s | d j o9 | i d | d | } | | i d | d | 8} | S| i d | d | d | | _ | | i d | d | 8} | S( s3
Return (maximum - minimum) along the the given dimension
(i.e. peak-to-peak value).
Parameters
----------
axis : {None, int}, optional
Axis along which to find the peaks. If None (default) the
flattened array is used.
out : {None, array_like}, 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.
fill_value : {var}, optional
Value used to fill in the masked values.
Returns
-------
ptp : ndarray.
A new array holding the result, unless ``out`` was
specified, in which case a reference to ``out`` is returned.
RJ R R N( R Rx R| R ( R RJ R R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s
! R+ R3 R R c C s
| i S( ( R ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR A s R R% R R c
C ss | d j o | i | i S| i i } | i } | t j o | S| i } t | i } | d j o t d g | S| d j ol | i d i } | o t d g | } n d } g } | D] } | t
i | | | q ~ nr xn t g }
| i D] } |
| i q~
D]9 } | } x | d D] } | | } qIWd | | d >> x = np.ma.array([[1,2,3], [4,5,6], [7,8,9]], mask=[0] + [1,0]*4)
>>> x.tolist()
[[1, None, 3], [None, 5, None], [7, None, 9]]
>>> x.tolist(-999)
[[1, -999, 3], [-999, 5, -999], [7, -999, 9]]
i i iN(
R R@ R R R R7 R R R R t operatort setitemR (
R R R R t nbdimst dtypesizet maskedidxt nodataR R R R7 t tmp( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR G s0
24 R c C s | i | i d | S( sS
Return the array data as a string containing the raw bytes in the array.
The array is filled with a fill value before the string conversion.
Parameters
----------
fill_value : scalar, optional
Value used to fill in the masked values. Deafult is None, in which
case `MaskedArray.fill_value` is used.
order : {'C','F','A'}, optional
Order of the data item in the copy. Default is 'C'.
- 'C' -- C order (row major).
- 'F' -- Fortran order (column major).
- 'A' -- Any, current order of array.
- None -- Same as 'A'.
See Also
--------
ndarray.tostring
tolist, tofile
Notes
-----
As for `ndarray.tostring`, information about the shape, dtype, etc.,
but also about `fill_value`, will be lost.
Examples
--------
>>> x = np.ma.array(np.array([[1, 2], [3, 4]]), mask=[[0, 1], [1, 0]])
>>> x.tostring()
'\x01\x00\x00\x00?B\x0f\x00?B\x0f\x00\x04\x00\x00\x00'
R ( R@ t tostring( R R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRC | s $R s %sc C s t d d S( s
Save a masked array to a file in binary format.
.. warning::
This function is not implemented yet.
Raises
------
NotImplementedError
When `tofile` is called.
s Not implemented yet, sorry...N( R ( R t fidt sept format( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt tofile s
c C s | i } | i } | d j o t | i | } n | i i } t i d | i d d | f d | f g } | i | d <| i | d <| S( sy
Transforms a masked array into a flexible-type array.
The flexible type array that is returned will have two fields:
* the ``_data`` field stores the ``_data`` part of the array.
* the ``_mask`` field stores the ``_mask`` part of the array.
Parameters
----------
None
Returns
-------
record : ndarray
A new flexible-type `ndarray` with two fields: the first element
containing a value, the second element containing the corresponding
mask boolean. The returned record shape matches self.shape.
Notes
-----
A side-effect of transforming a masked array into a flexible `ndarray` is
that meta information (``fill_value``, ...) will be lost.
Examples
--------
>>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
>>> print x
[[1 -- 3]
[-- 5 --]
[7 -- 9]]
>>> print x.toflex()
[[(1, False) (2, True) (3, False)]
[(4, True) (5, False) (6, True)]
[(7, False) (8, True) (9, False)]]
R R R R N( R R R Rf R R R R ( R t ddtypeR R t record( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt toflex s '
c C sY d | i i } d | i | i | i i | i i | t | i | | i f } | S( sW Return the internal state of the masked array, for pickling
purposes.
t CFi ( R$ t fncR R R RC RJ R ( R t cft state( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt __getstate__ s c C sf | \ } } } } } } } t i | | | | | f | i i | t | | | f | | _ d S( sk Restore the internal state of the masked array, for
pickling purposes. ``state`` is typically the output of the
``__getstate__`` output, and is a 5-tuple:
- class name
- a tuple giving the shape of the data
- a typecode for the data
- a binary string for the data
- a binary string for the mask.
N( R t __setstate__R Re R ( R RN t vert shpt typt isft rawt mskt flv( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRP s "c C s% t | i | i d d f | i f S( s6 Return a 3-tuple for pickling a MaskedArray.
i R ( i ( t _mareconstructt __class__R RO ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt
__reduce__ s c C s d d k l } t i t | | d t } | d j o
h } n | | t | Rj t baseshapet basetypeR R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRX s c C s
t | t S( s
Test whether input is an instance of MaskedArray.
This function returns True if `x` is an instance of MaskedArray
and returns False otherwise. Any object is accepted as input.
Parameters
----------
x : object
Object to test.
Returns
-------
result : bool
True if `x` is a MaskedArray.
See Also
--------
isMA : Alias to isMaskedArray.
isarray : Alias to isMaskedArray.
Examples
--------
>>> import numpy.ma as ma
>>> a = np.eye(3, 3)
>>> a
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
>>> m = ma.masked_values(a, 0)
>>> m
masked_array(data =
[[1.0 -- --]
[-- 1.0 --]
[-- -- 1.0]],
mask =
[[False True True]
[ True False True]
[ True True False]],
fill_value=0.0)
>>> ma.isMaskedArray(a)
False
>>> ma.isMaskedArray(m)
True
>>> ma.isMaskedArray([0, 1, 2])
False
( R R ( R# ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRU ) s 1R R c C s@ t | d | d | d | d | d | d | d | d |
d | S(
s. array(data, dtype=None, copy=False, order=False, mask=nomask,
fill_value=None, keep_mask=True, hard_mask=False, shrink=True,
subok=True, ndmin=0)
Acts as shortcut to MaskedArray, with options in a different order
for convenience. And backwards compatibility...
R R R+ R R R R R R[ ( R ( R R R+ R R R R R R[ R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR d s
! c C s4 t | } | t j o t S| i o t St S( s
Determine whether input has masked values.
Accepts any object as input, but always returns False unless the
input is a MaskedArray containing masked values.
Parameters
----------
x : array_like
Array to check for masked values.
Returns
-------
result : bool
True if `x` is a MaskedArray with masked values, False otherwise.
Examples
--------
>>> import numpy.ma as ma
>>> x = ma.masked_equal([0, 1, 0, 2, 3], 0)
>>> x
masked_array(data = [-- 1 -- 2 3],
mask = [ True False True False False],
fill_value=999999)
>>> ma.is_masked(x)
True
>>> x = ma.masked_equal([0, 1, 0, 2, 3], 42)
>>> x
masked_array(data = [0 1 0 2 3],
mask = False,
fill_value=999999)
>>> ma.is_masked(x)
False
Always returns False if `x` isn't a MaskedArray.
>>> x = [False, True, False]
>>> ma.is_masked(x)
False
>>> x = 'a string'
>>> ma.is_masked(x)
False
( RI R R R R ( R# R= ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRW v s -
t _extrema_operationc B s/ e Z d Z d d Z d d Z d Z RS( s
Generic class for maximum/minimum functions.
.. note::
This is the base class for `_maximum_operation` and
`_minimum_operation`.
c C s7 | d j o | i | St | i | | | | S( s Executes the call behavior.N( R RH R t compare( R R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR$ s
c C s t | d t d t } t | } | d j o h | d 6} n0 h } | i } | t j o | i } n | t j o | i i | | } n | i | i
| i t | } | i i | | } t
i i | | } t | d o
| | _ n | o
t } n | S( s# Reduce target along the given axis.R+ R RJ R N( R R R RI R R R t ufuncRH R@ t fill_value_funcR R
R" R` R R Rh ( R RI RJ R= t kargsRL ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRH s$
'
c C s t | } t | } | t j o | t j o
t } n+ t | } t | } t i | | } | i i t | t | } t | t p | i t } n | | _
| S( s< Return the function applied to the outer product of a and b.( RI R RJ Rb R Rq R@ R R R R ( R R R RF RG R= R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s
! N( R R R R R$ RH R ( ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRo s t _minimum_operationc B s e Z d Z d Z RS( s Object to calculate minimac C s+ t i | _ t | _ t | _ t | _ d S( sV minimum(a, b) or minimum(a)
In one argument case, returns the scalar minimum.
N( R" R} Rq R
t afuncRZ Rp R~ Rr ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR! s ( R R R R! ( ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRt s t _maximum_operationc B s e Z d Z d Z RS( s Object to calculate maximac C s+ t i | _ t | _ t | _ t | _ d S( s` maximum(a, b) or maximum(a)
In one argument case returns the scalar maximum.
N( R" Ry Rq R Ru RK Rp Rz Rr ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR! s ( R R R R! ( ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRv s c
C s_ y | i d | d | d | SWn8 t t f j
o& t | i d | d | d | SXd S( NRJ R R ( R| R R R ( R RJ R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR| s c
C s_ y | i d | d | d | SWn8 t t f j
o& t | i d | d | d | SXd S( NRJ R R ( Rx R R R ( R RJ R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRx s c C s\ y | i | d | d | SWn8 t t f j
o& t | i d | d | d | SXd S( s+ a.ptp(axis=None) = a.max(axis)-a.min(axis)R R RJ N( R R R R ( R RJ R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s t _frommethodc B s) e Z d Z d Z d Z d Z RS( s
Define functions from existing MaskedArray methods.
Parameters
----------
methodname : str
Name of the method to transform.
c C s | | _ | i | _ d S( N( R R R ( R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR! ' s c C sp t t | i d p t t | i d } | i t | } | d j o! d | t | d d f } | Sd S( s< Return the doc of the function (from the doc of the method).s %s
%sR N( R1 R R R R R ( R t metht signatureR ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR + s
c O s | i } t | | d } | d j o | | | St t | d } | d j o | t | | | St t | } | | | | S( N( R R1 R R R ( R R R9 R t method_namet method( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR$ 4 s
( R R R R! R R$ ( ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRw s R c C s[ | d j o
t d n t | } t | } t | | } t | } t | } t | t o t | } n t } t i | | t
i | | i | } | i
| t i t i | i t }
| t j o& | i p t S| |
O} | | _ n |
i o@ | i p t S| i t j o
|
| _ n | i | i |
Returns element-wise base array raised to power from second array.
This is the masked array version of `numpy.power`. For details see
`numpy.power`.
See Also
--------
numpy.power
Notes
-----
The *out* argument to `numpy.power` is not supported, `third` has to be
None.
s 3-argument power not supported.N( R R RI Rg RH R R R
R R R" R R R8 Ra R R R R7 Rh R R R R ( R R t thirdRF RG R= t fat fbRn R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR ^ s2
*
!
R4 c C si | d j o t | } n t | | } | d j o | i d | d | S| i | d | d | S( s) Function version of the eponymous method.R R N( R R1 R@ R ( R RJ R R R R; ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s
c C s< | d j o t | } n t | | } | i d | S( s) Function version of the eponymous method.RJ N( R R1 R@ R ( R RJ R R; ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s
c C sQ | d j o% t | } y | } Wq2 q2 Xn t | | } | i d | S( s) Function version of the eponymous method.RJ N( R R1 R@ R ( R RJ R R; ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s
c C s t | d t d t } | d j o | i } d } n | d j o' | o t | } qu t | } n | } t i | i i } t
| | i d | d | d | | | <| | S( s) Function version of the eponymous method.R+ R i RJ R R N( R R R R R~ Rz R RQ R R R@ R ( R RJ R R R5 R R6 R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s
+c C s/ t | t j o t i | S| i Sd S( s
Return all the non-masked data as a 1-D array.
This function is equivalent to calling the "compressed" method of a
`MaskedArray`, see `MaskedArray.compressed` for details.
See Also
--------
MaskedArray.compressed
Equivalent method.
N( RI R R R R( ( R# ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR( s
c
C s t i g } | D] } | t | q ~ | } t | } | i | } x* | D] } t | t j o PqU qU W| St i g } | D] } | t | q ~ | } | i i o | i
o
t | _ n | i | i
| _ | S( sK
Concatenate a sequence of arrays along the given axis.
Parameters
----------
arrays : sequence of array_like
The arrays must have the same shape, except in the dimension
corresponding to `axis` (the first, by default).
axis : int, optional
The axis along which the arrays will be joined. Default is 0.
Returns
-------
result : MaskedArray
The concatenated array with any masked entries preserved.
See Also
--------
numpy.concatenate : Equivalent function in the top-level NumPy module.
Examples
--------
>>> import numpy.ma as ma
>>> a = ma.arange(3)
>>> a[1] = ma.masked
>>> b = ma.arange(2, 5)
>>> a
masked_array(data = [0 -- 2],
mask = [False True False],
fill_value = 999999)
>>> b
masked_array(data = [2 3 4],
mask = False,
fill_value = 999999)
>>> ma.concatenate([a, b])
masked_array(data = [0 -- 2 2 3 4],
mask = [False True False False False False],
fill_value = 999999)
( R R) RH R R RI R RJ R R R R R R (
R RJ R R R; R R R# R t dm( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR) s )3 3
c C s7 t | t o | i | St | d t i | S( NR+ ( R R R. Ri R ( R RJ ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR. ! s c C sN t i | | i t } t | t j o t i | i | | _ n | S( s
Extract a diagonal or construct a diagonal array.
This function is the equivalent of `numpy.diag` that takes masked
values into account, see `numpy.diag` for details.
See Also
--------
numpy.diag : Equivalent function for ndarrays.
( R R2 R R RI R R ( R` R_ Rs ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR2 ( s c C se t | | } t | t oB | i } | i } | | _ | i t j o | | i _ qa n | S( s
Expand the shape of an array.
Expands the shape of the array by including a new axis before the one
specified by the `axis` parameter. This function behaves the same as
`numpy.expand_dims` but preserves masked elements.
See Also
--------
numpy.expand_dims : Equivalent function in top-level NumPy module.
Examples
--------
>>> import numpy.ma as ma
>>> x = ma.array([1, 2, 4])
>>> x[1] = ma.masked
>>> x
masked_array(data = [1 -- 4],
mask = [False True False],
fill_value = 999999)
>>> np.expand_dims(x, axis=0)
array([[1, 2, 4]])
>>> ma.expand_dims(x, axis=0)
masked_array(data =
[[1 -- 4]],
mask =
[[False True False]],
fill_value = 999999)
The same result can be achieved using slicing syntax with `np.newaxis`.
>>> x[np.newaxis, :]
masked_array(data =
[[1 -- 4]],
mask =
[[False True False]],
fill_value = 999999)
( t
n_expand_dimsR R R R R R ( R# RJ R t new_shape( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR< : s ( c C sk t | } | t j o# t i t | | } t | St i t | d | } t | d | Sd S( s
Shift the bits of an integer to the left.
This is the masked array version of `numpy.left_shift`, for details
see that function.
See Also
--------
numpy.left_shift
i R N( RI R R" RY R@ Ri ( R R R= R; ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRY l s
c C sk t | } | t j o# t i t | | } t | St i t | d | } t | d | Sd S( s
Shift the bits of an integer to the right.
This is the masked array version of `numpy.right_shift`, for details
see that function.
See Also
--------
numpy.right_shift
i R N( RI R R" R R@ Ri ( R R R= R; ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s
R c C sS y | i | | d | SWn2 t j
o& t | d t i | | d | SXd S( s
Set storage-indexed locations to corresponding values.
This function is equivalent to `MaskedArray.put`, see that method
for details.
See Also
--------
MaskedArray.put
R R+ N( R R R R ( R RQ R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s
c C s8 t | t p | i t } n t | t | } } t | t j oL | t j o; t | _ t | i | i
| _ t i
| i | | q n | i oF | t j o5 | i i } t i
| | | | i | O_ q n4 | t j o t | } n t i
| i | | t i
| i | | d S( sQ
Changes elements of an array based on conditional and input values.
This is the masked array version of `numpy.putmask`, for details see
`numpy.putmask`.
See Also
--------
numpy.putmask
Notes
-----
Using a masked array as `values` will **not** transform a `ndarray` into
a `MaskedArray`.
N( R R R RH RI R R R Rf R R R R R R R+ R RJ R ( R R R t valdatat valmaskR= ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s$
c C sJ y | i | SWn2 t j
o& t | d t i | i t SXd S( s
Permute the dimensions of an array.
This function is exactly equivalent to `numpy.transpose`.
See Also
--------
numpy.transpose : Equivalent function in top-level NumPy module.
Examples
--------
>>> import numpy.ma as ma
>>> x = ma.arange(4).reshape((2,2))
>>> x[1, 1] = ma.masked
>>>> x
masked_array(data =
[[0 1]
[2 --]],
mask =
[[False False]
[False True]],
fill_value = 999999)
>>> ma.transpose(x)
masked_array(data =
[[0 2]
[1 --]],
mask =
[[False False]
[False True]],
fill_value = 999999)
R+ N( R R R R R R ( R t axes( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s "R c C s\ y | i | d | SWn> t j
o2 t | d t i | d | } | i t SXd S( s
Returns an array containing the same data with a new shape.
Refer to `MaskedArray.reshape` for full documentation.
See Also
--------
MaskedArray.reshape : equivalent function
R R+ N( R R R R R R ( R R R t _tmp( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s
!c C sk t | } | t j o t i | | } n t i | | i t | } | i o
| | _ n | S( s4
Return a new masked array with the specified size and shape.
This is the masked equivalent of the `numpy.resize` function. The new
array is filled with repeated copies of `x` (in the order that the
data are stored in memory). If `x` is masked, the new array will be
masked, and the new mask will be a repetition of the old one.
See Also
--------
numpy.resize : Equivalent function in the top level NumPy module.
Examples
--------
>>> import numpy.ma as ma
>>> a = ma.array([[1, 2] ,[3, 4]])
>>> a[0, 1] = ma.masked
>>> a
masked_array(data =
[[1 --]
[3 4]],
mask =
[[False True]
[False False]],
fill_value = 999999)
>>> np.resize(a, (3, 3))
array([[1, 2, 3],
[4, 1, 2],
[3, 4, 1]])
>>> ma.resize(a, (3, 3))
masked_array(data =
[[1 -- 3]
[4 1 --]
[3 4 1]],
mask =
[[False True False]
[False False True]
[False False False]],
fill_value = 999999)
A MaskedArray is always returned, regardless of the input type.
>>> a = np.array([[1, 2] ,[3, 4]])
>>> ma.resize(a, (3, 3))
masked_array(data =
[[1 2 3]
[4 1 2]
[3 4 1]],
mask =
False,
fill_value = 999999)
( RI R R R R R R7 R ( R# R R= R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s 7
!
c C s t i t | S( s* maskedarray version of the numpy function.( R R RH ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR G s c C s t i t | S( s* maskedarray version of the numpy function.( R R RH ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR L s c C s t i t | | S( s* maskedarray version of the numpy function.( R R RH ( R RJ ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR Q s c C s | d j o! | d j o t | d i S| d j p
| d j o
t d n t | d i t } t i | } t | } t | } | t j o
| i
} n9 | t j o
| i
} n t i | i
| i
g g } t i | i
d | i t } | i } t i | | | i | t i | | | i | t i | i
d t }
| _ t i |
| t | t i |
| t | |
t | O}
|
i p
t | _ n | S( s
Return a masked array with elements from x or y, depending on condition.
Returns a masked array, shaped like condition, where the elements
are from `x` when `condition` is True, and from `y` otherwise.
If neither `x` nor `y` are given, the function returns a tuple of
indices where `condition` is True (the result of
``condition.nonzero()``).
Parameters
----------
condition : array_like, bool
The condition to meet. For each True element, yield the corresponding
element from `x`, otherwise from `y`.
x, y : array_like, optional
Values from which to choose. `x` and `y` need to have the same shape
as condition, or be broadcast-able to that shape.
Returns
-------
out : MaskedArray or tuple of ndarrays
The resulting masked array if `x` and `y` were given, otherwise
the result of ``condition.nonzero()``.
See Also
--------
numpy.where : Equivalent function in the top-level NumPy module.
Examples
--------
>>> x = np.ma.array(np.arange(9.).reshape(3, 3), mask=[[0, 1, 0],
... [1, 0, 1],
... [0, 1, 0]])
>>> print x
[[0.0 -- 2.0]
[-- 4.0 --]
[6.0 -- 8.0]]
>>> np.ma.where(x > 5) # return the indices where x > 5
(array([2, 2]), array([0, 2]))
>>> print np.ma.where(x > 5, x, -3.1416)
[[-3.1416 -- -3.1416]
[-- -3.1416 --]
[6.0 -- 8.0]]
i s/ Either both or neither x and y should be given.R N( R R@ R R R R R Ra RH Rh R t find_common_typeR8 R R R R R R R RI RJ R R ( Rn R# R t fct notfct xvt yvR R; R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR Z s0 /
!
c C s d } d } t | d } g } | D] } | | | q, ~ } g }
| D] } |
| | qS ~
} t i | | d | } t t | t | d d d t } t i | | d | d | i t }
| d j o& t
| t o | i | n | S|
i | |
S( s6
Use an index array to construct a new array from a set of choices.
Given an array of integers and a set of n choice arrays, this method
will create a new array that merges each of the choice arrays. Where a
value in `a` is i, the new array will have the value that choices[i]
contains in the same place.
Parameters
----------
a : ndarray of ints
This array must contain integers in ``[0, n-1]``, where n is the
number of choices.
choices : sequence of arrays
Choice arrays. The index array and all of the choices should be
broadcastable to the same shape.
out : array, optional
If provided, the result will be inserted into this array. It should
be of the appropriate shape and `dtype`.
mode : {'raise', 'wrap', 'clip'}, optional
Specifies how out-of-bounds indices will behave.
* 'raise' : raise an error
* 'wrap' : wrap around
* 'clip' : clip to the range
Returns
-------
merged_array : array
See Also
--------
choose : equivalent function
Examples
--------
>>> choice = np.array([[1,1,1], [2,2,2], [3,3,3]])
>>> a = np.array([2, 1, 0])
>>> np.ma.choose(a, choice)
masked_array(data = [3 2 1],
mask = False,
fill_value=999999)
c S s | t j o t St | S( s, Returns the filled array, or True if masked.( Rh R R@ ( R# ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt fmask s
c S s | t j o t St | S( s: Returns the mask, True if ``masked``, False if ``nomask``.( Rh R RI ( R# ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt nmask s
i R R+ R[ R N( R@ R R$ Rd Rg RI R R R R R R ( RQ t choicesR R R R R R R# t masksR R t
outputmaskR; ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR$ s - '''
c C se | d j o t i | | | St i t | | | t | d o t | | _ n | Sd S( s
Return a copy of a, rounded to 'decimals' places.
When 'decimals' is negative, it specifies the number of positions
to the left of the decimal point. The real and imaginary parts of
complex numbers are rounded separately. Nothing is done if the
array is not of float type and 'decimals' is greater than or equal
to 0.
Parameters
----------
decimals : int
Number of decimals to round to. May be negative.
out : array_like
Existing array to use for output.
If not given, returns a default copy of a.
Notes
-----
If out is given and does not have a mask attribute, the mask of a
is lost!
R N( R R R RH R RI R ( R R3 R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s
c C s} t | d } t | d } t | i d j o
d | _ n t | i d j o
d | _ n t i | | i t S( s
Returns the inner product of a and b for arrays of floating point types.
Like the generic NumPy equivalent the product sum is over the last dimension
of a and b.
Notes
-----
The first argument is not conjugated.
i i ( i ( i ( R@ R R R RR R R ( R R R} R~ ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRR s
s Masked values are replaced by 0.c C s t | d i } t | d i } t i | | } t | } t | } | t j o | t j o t | St | } t | } t d t i d | d | d d } t | d | S( s* maskedarray version of the numpy function.i i R+ R ( R@ R R R RI R Ri RJ Rd ( R R R} R~ R; RF RG R= ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR ) s *c C s t t | t | } | t j o5 t | } t | } t i | | } | i S| oY t | } t | } t i | | } t | d | d t } | i t
i d St Sd S( s
Return True if all entries of a and b are equal, using
fill_value as a truth value where either or both are masked.
Parameters
----------
a, b : array_like
Input arrays to compare.
fill_value : bool, optional
Whether masked values in a or b are considered equal (True) or not
(False).
Returns
-------
y : bool
Returns True if the two arrays are equal within the given
tolerance, False otherwise. If either array contains NaN,
then False is returned.
See Also
--------
all, any
numpy.ma.allclose
Examples
--------
>>> a = ma.array([1e10, 1e-7, 42.0], mask=[0, 0, 1])
>>> a
masked_array(data = [10000000000.0 1e-07 --],
mask = [False False True],
fill_value=1e+20)
>>> b = array([1e10, 1e-7, -42.0])
>>> b
array([ 1.00000000e+10, 1.00000000e-07, -4.20000000e+01])
>>> ma.allequal(a, b, fill_value=False)
False
>>> ma.allequal(a, b)
True
R R+ N( Rg RI R RH R" R: R R R R@ R R ( R R R R= R# R R; R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR
: s *
c C s | d j o t i d | } n t | d t } t | d t } t t | t | } t i t | d t d | i t } t i
| t t i | t j p t St i | pG t t i
t i | | | | t i | | }
t i
|
St i
t | | | | j | p t S| | } | | } t t i
t i | | | | t i | | }
t i
|
S( s
Returns True if two arrays are element-wise equal within a tolerance.
This function is equivalent to `allclose` except that masked values
are treated as equal (default) or unequal, depending on the `masked_equal`
argument.
Parameters
----------
a, b : array_like
Input arrays to compare.
masked_equal : bool, optional
Whether masked values in `a` and `b` are considered equal (True) or not
(False). They are considered equal by default.
rtol : float, optional
Relative tolerance. The relative difference is equal to ``rtol * b``.
Default is 1e-5.
atol : float, optional
Absolute tolerance. The absolute difference is equal to `atol`.
Default is 1e-8.
fill_value : bool, optional
*Deprecated* - Whether masked values in `a` or `b` are considered equal
(True) or not (False).
Returns
-------
y : bool
Returns True if the two arrays are equal within the given
tolerance, False otherwise. If either array contains NaN, then
False is returned.
See Also
--------
all, any
numpy.allclose : the non-masked `allclose`.
Notes
-----
If the following equation is element-wise True, then `allclose` returns
True::
absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))
Return True if all elements of `a` and `b` are equal subject to
given tolerances.
Examples
--------
>>> a = ma.array([1e10, 1e-7, 42.0], mask=[0, 0, 1])
>>> a
masked_array(data = [10000000000.0 1e-07 --],
mask = [False False True],
fill_value = 1e+20)
>>> b = ma.array([1e10, 1e-8, -42.0], mask=[0, 0, 1])
>>> ma.allclose(a, b)
False
>>> a = ma.array([1e10, 1e-8, 42.0], mask=[0, 0, 1])
>>> b = ma.array([1.00001e10, 1e-9, -42.0], mask=[0, 0, 1])
>>> ma.allclose(a, b)
True
>>> ma.allclose(a, b, masked_equal=False)
False
Masked values are not compared directly.
>>> a = ma.array([1e10, 1e-8, 42.0], mask=[0, 0, 1])
>>> b = ma.array([1.00001e10, 1e-9, 42.0], mask=[0, 0, 1])
>>> ma.allclose(a, b)
True
>>> ma.allclose(a, b, masked_equal=False)
False
sE The use of fill_value is deprecated. Please use masked_equal instead.R+ R N( R RX RY Ri R Rg RI R t isinfR@ R R R" R[ R ( R R Rj Rx Ry R R# R R= t xinfR; ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s s, K
*( ' c
C s" t | d | d t d t d t S( s
Convert the input to a masked array of the given data-type.
No copy is performed if the input is already an `ndarray`. If `a` is
a subclass of `MaskedArray`, a base class `MaskedArray` is returned.
Parameters
----------
a : array_like
Input data, in any form that can be converted to a masked array. This
includes lists, lists of tuples, tuples, tuples of tuples, tuples
of lists, ndarrays and masked arrays.
dtype : dtype, optional
By default, the data-type is inferred from the input data.
order : {'C', 'F'}, optional
Whether to use row-major ('C') or column-major ('FORTRAN') memory
representation. Default is 'C'.
Returns
-------
out : MaskedArray
Masked array interpretation of `a`.
See Also
--------
asanyarray : Similar to `asarray`, but conserves subclasses.
Examples
--------
>>> x = np.arange(10.).reshape(2, 5)
>>> x
array([[ 0., 1., 2., 3., 4.],
[ 5., 6., 7., 8., 9.]])
>>> np.ma.asarray(x)
masked_array(data =
[[ 0. 1. 2. 3. 4.]
[ 5. 6. 7. 8. 9.]],
mask =
False,
fill_value = 1e+20)
>>> type(np.ma.asarray(x))
R R+ R R ( Ri R R ( R R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s -c
C s" t | d | d t d t d t S( s
Convert the input to a masked array, conserving subclasses.
If `a` is a subclass of `MaskedArray`, its class is conserved.
No copy is performed if the input is already an `ndarray`.
Parameters
----------
a : array_like
Input data, in any form that can be converted to an array.
dtype : dtype, optional
By default, the data-type is inferred from the input data.
order : {'C', 'F'}, optional
Whether to use row-major ('C') or column-major ('FORTRAN') memory
representation. Default is 'C'.
Returns
-------
out : MaskedArray
MaskedArray interpretation of `a`.
See Also
--------
asarray : Similar to `asanyarray`, but does not conserve subclass.
Examples
--------
>>> x = np.arange(10.).reshape(2, 5)
>>> x
array([[ 0., 1., 2., 3., 4.],
[ 5., 6., 7., 8., 9.]])
>>> np.ma.asanyarray(x)
masked_array(data =
[[ 0. 1. 2. 3. 4.]
[ 5. 6. 7. 8. 9.]],
mask =
False,
fill_value = 1e+20)
>>> type(np.ma.asanyarray(x))
R R+ R R ( Ri R R ( R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s +c C s3 t | d p t | d } n t i | | S( s
Pickle a masked array to a file.
This is a wrapper around ``cPickle.dump``.
Parameters
----------
a : MaskedArray
The array to be pickled.
F : str or file-like object
The file to pickle `a` to. If a string, the full path to the file.
t readlinet w( R t opent cPickleR6 ( R t F( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR6 : s c C s
t i | S( s
Return a string corresponding to the pickling of a masked array.
This is a wrapper around ``cPickle.dumps``.
Parameters
----------
a : MaskedArray
The array for which the string representation of the pickle is
returned.
( R R7 ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR7 L s
c C s0 t | d p t | d } n t i | S( sz
Wrapper around ``cPickle.load`` which accepts either a file-like object
or a filename.
Parameters
----------
F : str or file
The file or file name to load.
See Also
--------
dump : Pickle an array
Notes
-----
This is different from `numpy.load`, which does not use cPickle but loads
the NumPy binary .npy format.
R R ( R R R R\ ( R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR\ [ s c C s
t i | S( s
Load a pickle from the current string.
The result of ``cPickle.loads(strg)`` is returned.
Parameters
----------
strg : str
The string to load.
See Also
--------
dumps : Return a string corresponding to the pickling of a masked array.
( R R] ( t strg( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR] s s R c C s t d d S( Ns Not yet implemented. Sorry( R ( t fileR R. RE ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt fromfile s c C s t | d d | d S( s
Build a masked array from a suitable flexible-type array.
The input array has to have a data-type with ``_data`` and ``_mask``
fields. This type of array is output by `MaskedArray.toflex`.
Parameters
----------
fxarray : ndarray
The structured input array, containing ``_data`` and ``_mask``
fields. If present, other fields are discarded.
Returns
-------
result : MaskedArray
The constructed masked array.
See Also
--------
MaskedArray.toflex : Build a flexible-type array from a masked array.
Examples
--------
>>> x = np.ma.array(np.arange(9).reshape(3, 3), mask=[0] + [1, 0] * 4)
>>> rec = x.toflex()
>>> rec
array([[(0, False), (1, True), (2, False)],
[(3, True), (4, False), (5, True)],
[(6, False), (7, True), (8, False)]],
dtype=[('_data', '>> x2 = np.ma.fromflex(rec)
>>> x2
masked_array(data =
[[0 -- 2]
[-- 4 --]
[6 -- 8]],
mask =
[[False True False]
[ True False True]
[False True False]],
fill_value = 999999)
Extra fields can be present in the structured array but are discarded:
>>> dt = [('_data', '>> rec2 = np.zeros((2, 2), dtype=dt)
>>> rec2
array([[(0, False, 0.0), (0, False, 0.0)],
[(0, False, 0.0), (0, False, 0.0)]],
dtype=[('_data', '>> y = np.ma.fromflex(rec2)
>>> y
masked_array(data =
[[0 0]
[0 0]],
mask =
[[False False]
[False False]],
fill_value = 999999)
R R R ( Ri ( t fxarray( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyRF s >t _convert2mac B s/ e Z d Z d Z d Z d Z d Z RS( s Convert functions from numpy to numpy.ma.
Parameters
----------
_methodname : string
Name of the method to transform.
c C s% t t | | _ | i | _ d S( N( R1 R t _funcR R ( R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR! s c C s^ t | i d d } t | i } | o/ | o d | i i | f } n | | } n | S( s< Return the doc of the function (from the doc of the method).R s %s%s
N( R1 R R R R ( R R R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s c O s | i i | | | i t S( N( R R$ R R ( R R R9 R ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR$ s N( R R R R R! R R$ ( ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyR s
( R t
__author__t
__docformat__t __all__R R< t numpyR R R R
R R R R t numpy.core.umatht coreR" t numpy.core.numerictypest numerictypesR t numpy.compatR R R< R RX R R R6 R R t ExceptionR R R R t _minvalsR R R t float32t float64R_ t inft _maxvalsR R R R R1 R R~ Rz R R R R R R& R R@ R RH t get_dataRC R2 R3 R R% R' R+ R- R. R@ RP R; R* R R, R R R R R- R R R R= R RA R# R R Ra R R^ R_ R R R R R R R R R: RH R R[ RL RZ RK R` R Rb R Rc R R! R" RN R5 R RB R R? R RR Re RI t get_maskRJ RV R Rd Rf Rg R> Rl Rw Rk Rl Ro Rp Rq Rj Rm Rs Rr Rv Rn R| Rt R R R R R R R RD R RX RU RX RT R Ru Rh Ri RW Ro Rt Rv R| Rx R Rw R R R R R' R/ R0 R+ R3 RM RP Ry R{ R} R R R R R R R R R R R R R R R R R R R( R) R. R2 RY R R R R R R R R R R R$ R RR RS R R R
R R R R6 R7 R\ R] R R RF R R R% R4 R8 R9 RE RG RO RQ R R R ( ( ( s3 /usr/lib64/python2.6/site-packages/numpy/ma/core.pyt s (
> > ! > ? ?
- @ ! * 3> RJ # < 7 Cd 1@ 9 t # ( (=Q . Ef 7
2 87 % A
> 2 & ' A MJ
9g/ 1 B