U
|
P ±d×I ã ² @ sÖ d Z ddlZddlZddlZddlZddlZddlZddlmZ ddl Z
|
ddl m m Z ddlm mZ ddlmZ ddl mZmZmZmZmZmZ ddl mZ ddl m Z ddl m Z m Z m!Z!m"Z"m#Z# dd l m$Z$ dd
|
l%m&Z& d d d ddddddddddddddd d d d d d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcdddedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwdxdydzd{d|d}d~ddddddd
ddddddddddddddddddddddddddd d¡d¢d£d¤d¥d¦d§d¨d©dªd«d¬dd®d¯d°d±d²d³d´dµd¶d·d¸d¹dºd»d¼g²Z'e
|
jZ(e(dZ)G d½d¾ d¾e*Z+d¿dÀ Z,dÁd Z-dÃdÄ Z.G dÅd d e/Z0G dÆd d e0Z1dÇdÈdÉdÊdËdÌdÊdÍdÎdÏ Z2dÐD ]6Z3e
|
4dÑe3¡e2dÒe3 dÓ < e
|
5dÑe3¡e2dÔe3 dÓ < q¾e
|
j6e
|
j7e
|
j8e
|
j9e
|
j:e
|
j;e
|
j<gZ=ej>Z?e? @dÕdÖ e=dd×
D ¡ e? @dØdÖ e=dÙd
D ¡ ejAZBeB @dÚdÖ e=dd×
D ¡ eB @dÛdÖ e=dÙd
D ¡ [=dÜdÝ ZCdÞdß ZDdàd@ ZEdádâ ZFdãd ZGdäd ZHdådæ ZIdçdè ZJdéd¥ ZKdêdë ZLdìd3 ZMddídKZNdîdï ZOddðdUZPePZQe)dÇdfdñdLZRdòdó ZSi ZTi ZUG dôdõ dõZVG död÷ d÷ZWG dødù dùZXG dúdû dûZYG düdý dýZZG dþdÿ dÿZ[G d d de[Z\G dd de[Z]G dd de[Z^e\e j_Z_e\e j`Z`e\e jaZae\e jbZbe\e jcZce\e jdZde\e jeZee\e jfZfe\e jgZge\e jh ZiZhe\e Z e\e jjZje\e jkZke\e jlZle\e jmZme\e
|
jnZoe\e jpZpe\e jqdeZdZqe\e jrdeYdZre\e jsdeYdZse\e jtdeYdZte\e judeWdZue\e jvdeVd dZve\e jwdeVd dZwe\e jxdeZdZxe\e jydeVd
|
d Zye]e jzZze]e j{Z{e]e j|d d Z|e]e j}ddZ}e]e j~Z~de~_e]e jZde_e]e jZde_e]e jZde_e]e jZde_e]e jZde_e]e jZe]e jd d jZ
e]e jZejZe]e jZe]e jZe]e jZe]e jZe]e jZe^e jeX dd Ze^e jeX dd Ze^e jeX dd Ze^e jeX dd Ze^e jeX dd Ze^e jeX dd Zd d Zdd Zddq ZddV ZeZddW Zddc Zdd ZddÇe(fddpZdddrZdd Zdd dsZd dM Ze
|
jfd d Z dd dZ¡dd!dwZ¢dd"dxZ£dd#d{Z¤dd$d|Z¥dd%d}Z¦dd&dvZ§dd'dyZ¨dd(dZ©dd)d~Zªd d,dZ«d¡d-dzZ¬G d.d/ d/Zed0Z®d1d2 Z¯e°e ±d3¡e ±d4¡e ±d5¡e ±d6¡d7Z²d8d9 Z³d:dN Z´d¢d;d<ZµG d=d> d>Z¶G d?d deZ·d@dA Z¸G dBd de·Z¹dCdb ZºeºZ»eºZ¼G dDdE dEe·Z½e½ Z¾Z¿e·ZÀddde)ddÇddÇdÇdf
|
dFd)ZeÀj e_ dGdd ZÁG dHdI dIe[ZÂddde
|
jfdJdZÃe·jÃj eÃ_ ddde
|
jfdKdZÄe·jÄj eÄ_ ddde
|
jfdLdZÅe·jÅj eÅ_ G dMdN dNZÆeÆdZÇeÆd ZÈZÉeÆdZÊeÆd4dÇdOZËeÆd>ZÌeÆd?ZÍeÆd9ZÎeÆdBZÏeÆdZZÐeÆd]ZÑeÂe jÒeeHZÒeÆdZÓeÂe jÔeeGZÔeÆdZÕeÆdZÖeÆdZ×eÆdZØeÆdZÙeÆdPZÚeÆdªZÛeÆd¯ZÜeÆd±ZÝeÆd²ZÞeÆd¶ZßeÆd¹ZàeÆd=Zád£dRd³Zâd¤dSdZãeÆd&ZäeÆd%Zåe
|
jdddÇdfdTd'Zæe·jæj eæ_ d¥dVd¬ZçdWd5 Zèd¦dXd6Zéd§dYdAZêdZdf Zëd[d¢ Zìd¨d\dZíd]d Zîd©d^d·Zïdªd`d Zðdad¡ Zñdbd Zòe
|
jòj eò_ dcd¦ Zóe
|
jój eó_ d«ddd©Zôe
|
jôj eô_ eefdedºZõd¬dfd1Zöddgd¤ZnenZ÷d®dhdiZød¯djdkZùdld_ Zúe-e
|
júj dmeú_ eúZûdnd Züe-e
|
jüj dmeü_ eüZýdodp Zþd°drd:Zÿd±dtd8Z d²dudZd³dvdZd´dwd+Zdµdxd*ZedUdyfdzd{Zd|dS ZG d}d~ d~Zed e°ddddddZ ed2e°ddddddZ
|
edCe°dddd
ddZ edEe°ddddddZ edFdddZ edRdddZedTdddZed\e°ddddddZed^e°ddddddZede°ddddddZeddddZed®e°ddddddZed»e°ddddddZed¼dddZd¶dd ZdS (· aú
|
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
|
|
é N)Úreduce)Ú
|
multiarray)ÚndarrayÚamaxÚaminÚ iscomplexobjÚbool_Ú_NoValue)Úarray)Úangle)Ú
|
getargspecÚ formatargspecÚlongÚunicodeÚbytes)Ú expand_dims)Únormalize_axis_tupleÚMAErrorÚ MaskErrorÚMaskTypeÚ MaskedArrayÚabsÚabsoluteÚaddÚallÚallcloseÚallequalÚalltruer r r ÚanomÚ anomaliesÚanyÚappendÚarangeÚarccosÚarccoshÚarcsinÚarcsinhÚarctanÚarctan2ÚarctanhÚargmaxÚargminÚargsortÚaroundr
|
Ú
|
asanyarrayÚasarrayÚ bitwise_andÚ
|
bitwise_orÚ bitwise_xorr ÚceilÚchooseÚclipÚcommon_fill_valueÚcompressÚ
|
compressedÚ concatenateÚ conjugateÚconvolveÚcopyÚ correlateÚcosÚcoshÚcountÚcumprodÚcumsumÚdefault_fill_valueÚdiagÚdiagonalÚdiffÚdivideÚemptyÚ
|
empty_likeÚequalÚexpr ÚfabsÚfilledÚ fix_invalidÚ flatten_maskÚflatten_structured_arrayÚfloorÚ floor_divideÚfmodÚ
|
frombufferÚfromflexÚ fromfunctionÚgetdataÚgetmaskÚ getmaskarrayÚgreaterÚ greater_equalÚ harden_maskÚhypotÚidentityÚidsÚindicesÚinnerÚ innerproductÚisMAÚ isMaskedArrayÚis_maskÚ is_maskedÚisarrayÚ
|
left_shiftÚlessÚ
|
less_equalÚlogÚlog10Úlog2Ú logical_andÚ logical_notÚ
|
logical_orÚ logical_xorÚ make_maskÚmake_mask_descrÚmake_mask_noneÚmask_orÚmaskedÚ masked_arrayÚ masked_equalÚmasked_greaterÚmasked_greater_equalÚ masked_insideÚmasked_invalidÚ masked_lessÚmasked_less_equalÚmasked_not_equalÚ masked_objectÚmasked_outsideÚmasked_print_optionÚmasked_singletonÚ masked_valuesÚ masked_whereÚmaxÚmaximumÚmaximum_fill_valueÚmeanÚminÚminimumÚminimum_fill_valueÚmodÚmultiplyÚmvoidÚndimÚnegativeÚnomaskÚnonzeroÚ not_equalÚonesÚ ones_likeÚouterÚ outerproductÚpowerÚprodÚproductÚptpÚputÚputmaskÚravelÚ remainderÚrepeatÚreshapeÚresizeÚ right_shiftÚroundÚround_Úset_fill_valueÚshapeÚsinÚsinhÚsizeÚ soften_maskÚsometrueÚsortÚsqrtÚsqueezeÚstdÚsubtractÚsumÚswapaxesÚtakeÚtanÚtanhÚtraceÚ transposeÚ true_divideÚvarÚwhereÚzerosÚ
|
zeros_likec @ s e Zd ZdS )ÚMaskedArrayFutureWarningN)Ú__name__Ú
|
__module__Ú __qualname__© rà rà úDd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\numpy/ma/core.pyr¿ T s r¿ c C s& | j dkrdS tjdtdd dS dS )aª
|
Adjust the axis passed to argsort, warning if necessary
|
|
Parameters
|
----------
|
arr
|
The array which argsort was called on
|
|
np.ma.argsort has a long-term bug where the default of the axis argument
|
is wrong (gh-8701), which now must be kept for backwards compatibility.
|
Thankfully, this only makes a difference when arrays are 2- or more-
|
dimensional, so we only need a warning then.
|
é éÿÿÿÿz«In the future the default for argsort will be axis=-1, not the current None, to match its documentation and np.argsort. Explicitly pass -1 or None to silence this warning.é ©Ú
|
stacklevelN)r ÚwarningsÚwarnr¿ )Úarrrà rà rÄ Ú_deprecate_argsort_axisW s
|
ürÍ c C s\ | dkr dS |dkr| S t dt | ¡¡}dt |¡ }d |dd
|g |dd
¡S )z9
|
Adds a Notes section to an existing docstring.
|
|
Nz\n\s*?Notes\n\s*?-----z
|
|
Notes
|
-----
|
%s
|
Ú rÅ )ÚreÚsplitÚinspectÚcleandocÚjoin)Z
|
initialdocZnoteZ notesplitZnotedocrà rà rÄ Údoc_notes s rÔ c C s. zt t| }W n tk
|
r( d}Y nX |S )z%
|
Get the signature from obj
|
|
rÎ )r r Ú TypeError)ÚobjÚsigrà rà rÄ Úget_object_signature s
|
|
rØ c @ s e Zd ZdZdS )r z1
|
Class for masked array related errors.
|
|
N©rÀ rÁ r Ú__doc__rà rà rà rÄ r s c @ s e Zd ZdZdS )r z)
|
Class for mask related errors.
|
|
NrÙ rà rà rà rÄ r s Ty@µx ¯D g@µx ¯Di?B ú?s N/As ???zN/A) ÚbÚcÚfÚiÚOÚSÚuÚVÚU) ÚYÚMÚWÚDÚhÚmÚsÚmsÚusÚnsZpsÚfsÚasZNaTzM8[ú]zm8[c C s g | ]}|t j fqS rà ©ÚnpÚinf©Ú.0Úkrà rà rÄ Ú
|
<listcomp>¾ s rø é c C s" g | ]}|t tj tj fqS rà ©Úcomplexró rô rõ rà rà rÄ rø ¿ s éýÿÿÿc C s g | ]}|t j
|
fqS rà rò rõ rà rà rÄ rø  s c C s" g | ]}|t tj
|
tj
|
fqS rà rú rõ rà rà rÄ rø à s c sh j dk r6t fdd j D }tj| dd S jr\ j\}}t|}t ||¡S S dS )zR
|
Recursively produce a fill value for `dtype`, calling f on scalar dtypes
|
Nc 3 s" | ]}t t | ¡V qd S ©N)ró r
|
Ú_recursive_fill_value©rö Úname©ÚdtyperÞ rà rÄ Ú <genexpr>Ð s ÿz(_recursive_fill_value.<locals>.<genexpr>©r rà )ÚnamesÚtupleró r
|
Úsubdtyperþ Úfull)r rÞ ÚvalsÚsubtyper¨ Zsubvalrà r rÄ rþ Ç s
|
þ
|
|
rþ c C s0 t | tjr| S t| dr | jS t | ¡jS dS )z4 Convert the argument for *_fill_value into a dtype r N)Ú
|
isinstanceró r Úhasattrr. ©rÖ rà rà rÄ Ú _get_dtype_ofÜ s
|
|
r c C s dd }t | }t||S )aN
|
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'
|
======== ========
|
|
For structured types, a structured scalar is returned, with each field the
|
default fill value for its type.
|
|
For subarray types, the fill value is an array of the same size containing
|
the default scalar fill value.
|
|
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)
|
|
c S s2 | j dkr t | jdd
d¡S t | j d¡S d S )NZMmrÅ rÛ )ÚkindÚdefault_fillerÚgetÚstrr rà rà rÄ Ú_scalar_fill_value s
|
z.default_fill_value.<locals>._scalar_fill_value©r rþ )rÖ r r rà rà rÄ rC æ s -c s fdd}t | }t||S )Nc
|
sJ z
|
| W S t k
|
rD } z td| d dd W 5 d }~X Y nX d S )NzUnsuitable type z for calculating Ú.)ÚKeyErrorrÕ )r Úe©ÚextremumÚ extremum_namerà rÄ r s
|
ÿþz0_extremum_fill_value.<locals>._scalar_fill_valuer )rÖ r r r r rà r rÄ Ú_extremum_fill_value s r c C s t | tdS )a`
|
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, dtype or scalar
|
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
|
|
r )r Ú
|
min_fillerr rà rà rÄ r + s 0c C s t | tdS )ad
|
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 or scalar
|
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
|
|
r )r Ú
|
max_fillerr rà rà rÄ r ^ s 0c C s t | t|j¡} g }t| |jD ]X\}}|| }|jrB|jd }|jdk rb| tt||¡ q"| t j ||d
|
¡ ¡ q"t|S )aÆ
|
Create a fill value for a structured dtype.
|
|
Parameters
|
----------
|
fillvalue : scalar or array_like
|
Scalar or array representing the fill value. If it is of shorter
|
length than the number of fields in dt, it will be resized.
|
dt : dtype
|
The structured dtype for which to create the fill value.
|
|
Returns
|
-------
|
val : tuple
|
A tuple of values corresponding to the structured fill value.
|
|
r Nr ) ró r£ Úlenr Úzipr r! r Ú_recursive_set_fill_valuer
|
Úitem)Ú fillvalueÚdtZ output_valueÚfvalr Zcdtyperà rà rÄ r s
|
|
r c
|
C s0 t |¡}| dkr t|} n|jdk r¬t| tt jfrzt j| d|d} W qª tk
|
r } zd}t|| |f |W 5 d}~X Y qªX n"t j | t
|
d} t jt | ||d} nzt| t rÒ|j dkrÒd}t|| nTzt j| d|d} W n> ttfk
|
r$ } zd}t|| |f |W 5 d}~X Y nX t | ¡S ) a
|
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 fill_value is not None, its value is forced to the given dtype.
|
|
The result is always a 0d array.
|
|
NF©r< r z"Unable to transform %s to dtype %sr ZOSVUz6Cannot set fill value of string with array of dtype %sz(Cannot convert fill_value %s to dtype %s)ró r rC r r r Úvoidr
|
Ú
|
ValueErrorr/ Úobjectr r ÚcharrÕ Ú OverflowError)Ú
|
fill_valueÚndtyper Úerr_msgrà rà rÄ Ú_check_fill_value± s.
|
|
& ÿ$r. c C s t | tr| |¡ dS )aâ
|
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 = list(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§ ©Úar+ rà rà rÄ r§ Ý s <
|
|
c C s t | tr| j}nt| }|S )zr
|
Return the filling value of a, if any. Otherwise, returns the
|
default filling value for that type.
|
|
)r r r+ rC )r0 Úresultrà rà rÄ Úget_fill_value s
|
r2 c C s t | }t |}||kr |S dS )a
|
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)r2 )r0 rÜ Út1Út2rà rà rÄ r6 + s
|
c C sF t | dr| |¡S t| tr"| S t| tr8t | d¡S t | ¡S dS )aÈ
|
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 : array_like, optional.
|
Can be scalar or non-scalar. If non-scalar, the
|
resulting filled array should be broadcastable
|
over input array. Default is None.
|
|
Returns
|
-------
|
a : ndarray
|
The filled array.
|
|
See Also
|
--------
|
compressed
|
|
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]])
|
>>> x.filled(fill_value=333)
|
array([[333, 1, 2],
|
[333, 4, 5],
|
[ 6, 7, 8]])
|
>>> x.filled(fill_value=np.arange(3))
|
array([[0, 1, 2],
|
[0, 4, 5],
|
[6, 7, 8]])
|
|
rM rà N)r rM r r Údictró r
|
r/ rà rà rÄ rM K s -
|
|
|
|
c G s t | dkr.| d }t|tr(t|}qrt}nDdd | D }|d }t|tsRt}|dd
D ]}t||r^|}q^|jdkrtS |S )z
|
Return the youngest subclass of MaskedArray from a list of (masked) arrays.
|
|
In case of siblings, the first listed takes over.
|
|
rÅ r c S s g | ] }t |qS rà )Útype©rö r0 rà rà rÄ rø s z'get_masked_subclass.<locals>.<listcomp>NÚMaskedConstant)r r r r6 Ú
|
issubclassrÀ )ÚarraysrÌ ÚrclsZarrclsÚclsrà rà rÄ Úget_masked_subclass s
|
|
|
|
|
r= c C sB z
|
| j }W n$ tk
|
r. tj| d|d}Y nX |s>| t¡S |S )aE
|
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=2)
|
>>> ma.getdata(a)
|
array([[1, 2],
|
[3, 4]])
|
|
Equivalently use the ``MaskedArray`` `data` attribute.
|
|
>>> a.data
|
array([[1, 2],
|
[3, 4]])
|
|
F©r< Úsubok)Ú_dataÚAttributeErrorró r
|
Úviewr )r0 r? Údatarà rà rÄ rW s *
|
|
c C sX t | ||dd} t t | j¡¡}| ¡ s.| S | j|O _|dkrJ| j}|| j|< | S )aQ
|
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.
|
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.
|
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.e+00, -1.e+00, 1.e+20, 1.e+20])
|
>>> x.data
|
array([ 1., -1., nan, inf])
|
|
T)r< Úmaskr? N)rw ró ro Úisfiniter@ r Ú_maskr+ )r0 rD r< r+ Úinvalidrà rà rÄ rN Õ s 0
|
c C s, t | tp*t | to*| o*t dd | D ¡S )Nc s s | ]}t |tV qd S rý )r r )rö rë rà rà rÄ r s z/is_string_or_list_of_strings.<locals>.<genexpr>)r r ÚlistÚbuiltinsr )Úvalrà rà rÄ Ú is_string_or_list_of_strings s
|
þrK c @ s e Zd ZdZdd Zdd ZdS )Ú_DomainCheckIntervalz~
|
Define a valid interval, so that :
|
|
``domain_check_interval(a,b)(x) == True`` where
|
``x < a`` or ``x > b``.
|
|
c C s" ||kr|| }}|| _ || _dS )z9domain_check_interval(a,b)(x) = true where x < a or y > bN)r0 rÜ ©Úselfr0 rÜ rà rà rÄ Ú__init__& s
|
z _DomainCheckInterval.__init__c
|
C sD t jdd. t t || j¡t || j¡¡W 5 Q R £ S Q R X dS )úExecute the call behavior.Úignore©rG N)ró ÚerrstateÚumathrp rZ rÜ ri r0 ©rN Úxrà rà rÄ Ú__call__- s ÿz _DomainCheckInterval.__call__N©rÀ rÁ r rÚ rO rW rà rà rà rÄ rL s rL c @ s e Zd ZdZdd Zdd ZdS )Ú
|
_DomainTanz
|
Define a valid interval for the `tan` function, so that:
|
|
``domain_tan(eps) = True`` where ``abs(cos(x)) < eps``
|
|
c C s
|
|| _ dS )z/domain_tan(eps) = true where abs(cos(x)) < eps)N)Úeps)rN rZ rà rà rÄ rO > s z_DomainTan.__init__c
|
C s> t jdd( t t t |¡¡| j¡W 5 Q R £ S Q R X dS ©úExecutes the call behavior.rQ rR N)ró rS rT ri r r> rZ rU rà rà rÄ rW B s z_DomainTan.__call__NrX rà rà rà rÄ rY 6 s rY c @ s" e Zd ZdZdddZdd ZdS )Ú_DomainSafeDividez-
|
Define a domain for safe division.
|
|
Nc C s
|
|| _ d S rý )Ú tolerance)rN r^ rà rà rÄ rO N s z_DomainSafeDivide.__init__c
|
C sl | j d krt t¡j| _ t |¡t |¡ }}tjdd( t |¡| j t |¡kW 5 Q R £ S Q R X d S )NrQ rR ) r^ ró ZfinfoÚfloatZtinyr/ rS rT r rM rà rà rÄ rW Q s
|
|
z_DomainSafeDivide.__call__)NrX rà rà rà rÄ r] H s
|
r] c @ s e Zd ZdZdd Zdd ZdS )Ú_DomainGreaterz4
|
DomainGreater(v)(x) is True where x <= v.
|
|
c C s
|
|| _ dS )z'DomainGreater(v)(x) = true where x <= vN©Úcritical_value©rN rb rà rà rÄ rO c s z_DomainGreater.__init__c
|
C s2 t jdd t || j¡W 5 Q R £ S Q R X dS r[ )ró rS rT rj rb rU rà rà rÄ rW g s z_DomainGreater.__call__NrX rà rà rà rÄ r` ] s r` c @ s e Zd ZdZdd Zdd ZdS )Ú_DomainGreaterEqualz8
|
DomainGreaterEqual(v)(x) is True where x < v.
|
|
c C s
|
|| _ dS )z+DomainGreaterEqual(v)(x) = true where x < vNra rc rà rà rÄ rO s s z _DomainGreaterEqual.__init__c
|
C s2 t jdd t || j¡W 5 Q R £ S Q R X dS r[ )ró rS rT ri rb rU rà rà rÄ rW w s z _DomainGreaterEqual.__call__NrX rà rà rà rÄ rd m s rd c @ s e Zd Zdd Zdd ZdS )Ú _MaskedUFuncc C s || _ |j| _|j| _d S rý )rÞ rÚ rÀ )rN Úufuncrà rà rÄ rO ~ s z_MaskedUFunc.__init__c C s d| j S )NzMasked version of )rÞ ©rN rà rà rÄ Ú__str__ s z_MaskedUFunc.__str__N)rÀ rÁ r rO rh rà rà rà rÄ re } s re c s* e Zd ZdZd fdd Zdd Z ZS ) Ú_MaskedUnaryOperationaÈ
|
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.
|
|
r Nc s, t |¡ || _|| _|t|< |t|< d S rý )ÚsuperrO ÚfillÚdomainÚ ufunc_domainÚ ufunc_fills)rN Zmufuncrk rl ©Ú __class__rà rÄ rO s
|
z _MaskedUnaryOperation.__init__c O s t |}| jdk rftjddd | j|f||}W 5 Q R X t |¡ }|| |¡O }|t|O }n4tjddd | j|f||}W 5 Q R X t|}|js¬|r¨t S |S |t
|
k rÞztj |||d W n t k
|
rÜ Y nX | t|¡}||_| |¡ |S )ú-
|
Execute the call behavior.
|
|
NrQ ©rG rG ©r¼ )rW rl ró rS rÞ rT rE rX r rv r ÚcopytorÕ rB r= rF Ú _update_from)rN r0 ÚargsÚkwargsÚdr1 rê Ú masked_resultrà rà rÄ rW s.
|
|
z _MaskedUnaryOperation.__call__)r N©rÀ rÁ r rÚ rO rW Ú __classcell__rà rà ro rÄ ri s ri c sF e Zd ZdZd fdd Zdd Zddd Zd
|
d Zdd d Z Z S )Ú_MaskedBinaryOperationaC
|
Define masked version of binary operations, where invalid
|
values are pre-masked.
|
|
Parameters
|
----------
|
mbfunc : function
|
The function for which to define a masked version. Made available
|
as ``_MaskedBinaryOperation.f``.
|
domain : class instance
|
Default domain for the function. Should be one of the ``_Domain*``
|
classes. Default is None.
|
fillx : scalar, optional
|
Filling value for the first argument, default is 0.
|
filly : scalar, optional
|
Filling value for the second argument, default is 0.
|
|
r c s0 t |¡ || _|| _dt|< ||ft|< dS )zr
|
abfunc(fillx, filly) must be defined.
|
|
abfunc(x, filly) = x for all x to enable reduce.
|
|
N)rj rO ÚfillxÚfillyrm rn )rN Zmbfuncr} r~ ro rà rÄ rO å s
|
z _MaskedBinaryOperation.__init__c O s> t |t | }}t ¡ ( tjddd | j||f||}W 5 Q R X t|t| }} |tkr| tkrpt}
|
q¨t t || ¡}
|
n&| tkrt |t |¡}
|
n t || ¡}
|
|j
|
sº|
|
r¶t S |S |
|
tk rö|
|
¡ röztj ||d|
|
d W n tk
|
rô Y nX | t||¡} |
|
| _t|tr$| |¡ nt|tr:| |¡ | S )rq rQ rr Úunsafe©Úcastingr¼ )rW ró rS ZseterrrÞ rX r rT rp rY r rv r rt Ú ExceptionrB r= rF r r ru ) rN r0 rÜ rv rw ÚdaÚdbr1 ÚmaÚmbrê ry rà rà rÄ rW ò s8
|
|
z _MaskedBinaryOperation.__call__Nc
|
C s¬ t |}t|}t|| j}|jdkrJ| d¡}|tk rJt|dd}d|_|tkrf| j ||¡}t}n | jj |||d}t
|
j ||¡}|js|rt S |S | |¡} || _| S )z:
|
Reduce `target` along the given `axis`.
|
|
rà rÅ T©r< ©rÅ r )r= rX rM r~ r¨ r¢ r rr rÞ r rT rn rv rB rF )
|
rN ÚtargetÚaxisr Útclassrê ÚtÚtrÚmrZ masked_trrà rà rÄ r ! s(
|
|
|
z _MaskedBinaryOperation.reducec
|
C s® t |t | }}| j ||¡}t|}t|}|tkrF|tkrFt}n t|}t|}tj ||¡}|jsr|rrt S |tk rt
|
j |||d |j s|S | t||¡} || _| S )zO
|
Return the function applied to the outer product of a and b.
|
|
rs )rW rÞ r rX r rY rT rp r rv ró rt r¨ rB r= rF )
|
rN r0 rÜ r r rx r
r rê Zmasked_drà rà rÄ r ? s$
|
z _MaskedBinaryOperation.outerc C s0 t |}t|| j}| j ||¡}| |¡}|S )zSAccumulate `target` along `axis` after filling with y fill
|
value.
|
|
)r= rM r~ rÞ Ú
|
accumulaterB )rN r r r r r1 ry rà rà rÄ r X s
|
|
z!_MaskedBinaryOperation.accumulate)r r )r N)r )
|
rÀ rÁ r rÚ rO rW r r r r{ rà rà ro rÄ r| Ñ s /
|
r| c s* e Zd ZdZd fdd Zdd Z ZS )Ú_DomainedBinaryOperationaH
|
Define binary operations that have a domain, like divide.
|
|
They have no reduce, outer or accumulate.
|
|
Parameters
|
----------
|
mbfunc : function
|
The function for which to define a masked version. Made available
|
as ``_DomainedBinaryOperation.f``.
|
domain : class instance
|
Default domain for the function. Should be one of the ``_Domain*``
|
classes.
|
fillx : scalar, optional
|
Filling value for the first argument, default is 0.
|
filly : scalar, optional
|
Filling value for the second argument, default is 0.
|
|
r c s6 t |¡ || _|| _|| _|t|< ||ft|< dS )zjabfunc(fillx, filly) must be defined.
|
abfunc(x, filly) = x for all x to enable reduce.
|
N)rj rO rl r} r~ rm rn )rN Zdbfuncrl r} r~ ro rà rÄ rO z s z!_DomainedBinaryOperation.__init__c O s6 t |t | }}tjddd | j||f||}W 5 Q R X t |¡ }|t|O }|t|O }t | jd¡} | dk r|| ||O }|j s|rt
|
S |S z>tj |dd|d t ||¡}
|
tj |
|
j|jddrÖ||
|
7 }W n tk
|
rì Y nX | t||¡} || _t|tr | |¡ nt|tr2| |¡ | S ) rP rQ rr Nr r r Úsafe)r )rW ró rS rÞ rT rE rX rm r r rv rt r Zcan_castr r rB r= rF r r ru ) rN r0 rÜ rv rw r r r1 rê rl Z masked_dary rà rà rÄ rW
s6
|
z!_DomainedBinaryOperation.__call__)r r rz rà rà ro rÄ r e s r ç ç ð?gzø·¥ª8g ð¿g÷ÿÿÿÿÿï¿g÷ÿÿÿÿÿï?rÅ c C s¬ t }| jdk rdg }| jD ]>}| j| }t|dkr>|d |f}| |||d |f¡ qt |¡}n8| jrt| j}|| jd ||d< t t |¡}n|}|| kr¨| }|S )z=Private function allowing recursion in _replace_dtype_fields.NrÇ rÆ r )
|
Ú _replace_dtype_fields_recursiver Úfieldsr r! ró r r rH r )r Úprimitive_dtypeZ_recurseÚdescrr ÚfieldZ new_dtyperà rà rÄ r s"
|
|
|
|
r c C s t | ¡} t |¡}t| |S )zí
|
Construct a dtype description list from a given dtype.
|
|
Returns a new dtype object, with all fields and subtypes in the given type
|
recursively replaced with `primitive_dtype`.
|
|
Arguments are coerced to dtypes first.
|
)ró r r )r r rà rà rÄ Ú_replace_dtype_fields# s
|
|
r c C s
|
t | tS )að
|
Construct a dtype description list from a given dtype.
|
|
Returns a new dtype object, with the type of all fields in `ndtype` to a
|
boolean type. Field names are not altered.
|
|
Parameters
|
----------
|
ndtype : dtype
|
The dtype to convert.
|
|
Returns
|
-------
|
result : dtype
|
A dtype that looks like `ndtype`, the type of all fields is boolean.
|
|
Examples
|
--------
|
>>> import numpy.ma as ma
|
>>> dtype = np.dtype({'names':['foo', 'bar'],
|
... 'formats':[np.float32, np.int64]})
|
>>> dtype
|
dtype([('foo', '<f4'), ('bar', '<i8')])
|
>>> ma.make_mask_descr(dtype)
|
dtype([('foo', '|b1'), ('bar', '|b1')])
|
>>> ma.make_mask_descr(np.float32)
|
dtype('bool')
|
|
)r r )r, rà rà rÄ rs 1 s c C s t | dtS )a
|
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=2)
|
>>> ma.getmask(a)
|
array([[False, True],
|
[False, False]])
|
|
Equivalently use the `MaskedArray` `mask` attribute.
|
|
>>> a.mask
|
array([[False, True],
|
[False, False]])
|
|
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
|
|
rF )Úgetattrr )r0 rà rà rÄ rX R s 8c C s, t | }|tkr(tt | ¡t| dd}|S )ae
|
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=2)
|
>>> ma.getmaskarray(a)
|
array([[False, True],
|
[False, False]])
|
|
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]])
|
|
r N)rX r rt ró r¨ r )rÌ rD rà rà rÄ rY s /c C s* z| j jtkW S tk
|
r$ Y dS X dS )a)
|
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
|
--------
|
ma.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=0)
|
>>> 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])
|
>>> ma.is_mask(m)
|
True
|
|
Arrays with complex dtypes don't return True.
|
|
>>> dtype = np.dtype({'names':['monty', 'pithon'],
|
... 'formats':[bool, 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', '?'), ('pithon', '?')])
|
>>> ma.is_mask(m)
|
False
|
|
FN)r r6 r rA ©rê rà rà rÄ re Å s >c C s | j jdkr| ¡ stS | S dS )z-
|
Shrink a mask to nomask if possible
|
N)r r r r r rà rà rÄ Ú _shrink_mask s r Fc C sh | t kr t S t|}t| tr@| jjr@|tjkr@tj| j |dS tj
|
t | d||dd}|rdt |}|S )a
|
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 interpreted 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.
|
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. This is ignored when `m` is ``nomask``, in which
|
case ``nomask`` is always returned.
|
|
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])
|
>>> m = [1, 0, 1, 1]
|
>>> ma.make_mask(m)
|
array([ True, False, True, True])
|
>>> m = [1, 0, 2, -3]
|
>>> ma.make_mask(m)
|
array([ True, False, True, True])
|
|
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])
|
|
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.int64, np.int64]})
|
>>> arr = np.array(arr, dtype=dtype)
|
>>> arr
|
array([(1, 0), (0, 1), (1, 0), (1, 0)],
|
dtype=[('man', '<i8'), ('mouse', '<i8')])
|
>>> ma.make_mask(arr, dtype=dtype)
|
array([(True, False), (False, True), (True, False), (True, False)],
|
dtype=[('man', '|b1'), ('mouse', '|b1')])
|
|
r T)r< r r? ) r rs r r r r ró r r r¨ r
|
rM r )rê r< Úshrinkr r1 rà rà rÄ rr s G c C s. |dkrt j| td}nt j| t|d}|S )a&
|
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])
|
|
Defining a more complex dtype.
|
|
>>> dtype = np.dtype({'names':['foo', 'bar'],
|
... 'formats':[np.float32, np.int64]})
|
>>> dtype
|
dtype([('foo', '<f4'), ('bar', '<i8')])
|
>>> ma.make_mask_none((3,), dtype=dtype)
|
array([(False, False), (False, False), (False, False)],
|
dtype=[('foo', '|b1'), ('bar', '|b1')])
|
|
Nr )ró r½ r rs )Únewshaper r1 rà rà rÄ rt l s +c C sV | j j}|D ]D}| | }|j jd k r:t||| || q t ||| || ¡ q d S rý )r r Ú_recursive_mask_orrT rp )Úm1Úm2Únewmaskr r Zcurrent1rà rà rÄ r s r c C sä | t ks| dkr,t|dt}t||||dS |t ks<|dkrXt| dt}t| |||dS | |krlt| rl| S t| ddt|dd }}||krtd||f |jdk rÎt t | |¡j
|
|¡}t | || |S tt | |¡||dS )a
|
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])
|
|
Fr )r< r r Nz Incompatible dtypes '%s'<>'%s'©r< r )r r r rr re r' r ró rH Ú broadcastr¨ r rT rp )r r¡ r< r r Zdtype1Zdtype2r¢ rà rà rÄ ru ¨ s %
|
c sB dd } fdd t | ¡} || }t jdd |D tdS )a&
|
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])
|
>>> np.ma.flatten_mask(mask)
|
array([False, False, True])
|
|
>>> mask = np.array([(0, 0), (0, 1)], dtype=[('a', bool), ('b', bool)])
|
>>> np.ma.flatten_mask(mask)
|
array([False, False, False, True])
|
|
>>> mdtype = [('a', bool), ('b', [('ba', bool), ('bb', bool)])]
|
>>> mask = np.array([(0, (0, 0)), (0, (0, 1))], dtype=mdtype)
|
>>> np.ma.flatten_mask(mask)
|
array([False, False, False, False, False, True])
|
|
c s* j j}|dk r" fdd|D S S dS )zCFlatten the mask and returns a (maybe nested) sequence of booleans.Nc s g | ]}t | qS rà )rO rÿ ©rD rà rÄ rø s z3flatten_mask.<locals>._flatmask.<locals>.<listcomp>©r r )rD Zmnamesrà r¥ rÄ Ú _flatmask s z flatten_mask.<locals>._flatmaskc 3 sN z.| D ]$}t |dr$ |E dH q|V qW n tk
|
rH | V Y nX dS )z.Generates a flattened version of the sequence.Ú__iter__N)r rÕ )ÚsequenceÚelement©Ú _flatsequencerà rÄ r¬ s
|
z#flatten_mask.<locals>._flatsequencec S s g | ]}|qS rà rà ©rö Ú_rà rà rÄ rø s z flatten_mask.<locals>.<listcomp>r )ró r/ r
|
Úbool)rD r§ Z flattenedrà r« rÄ rO à s
|
|
c C s6 |t jkri nd|i}| tk r2| jf d|i|S tS )z:Check whether there are masked values along the given axisÚkeepdimsr )ró r r r )rD r r° rw rà rà rÄ Ú_check_mask_axis s r± c C s¨ t | dd}tj||dd}|j|j }}|rF||krFtd||f t|drft||j}t|}nt }|
|
|¡}t ||_ |s¤t|dr¤t |tkr¤|j
|
¡ |_|S )aé
|
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',
|
dtype='<U1')
|
|
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)
|
|
F©r Tr> zFInconsistent shape between the condition and the input (got %s and %s)rF )rr ró r
|
r¨ Ú
|
IndexErrorr ru rF r6 r rB r rD rX r )Ú conditionr0 r< ZcondZcshapeZashaper< r1 rà rà rÄ r
$ s d ÿ
|
|
|
|
c C s t t| || |dS )aì
|
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 )r
rZ ©rV Úvaluer< rà rà rÄ ry s c C s t t| || |dS )a
|
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 )r
r[ rµ rà rà rÄ rz ¸ s c C s t t| || |dS )aç
|
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 )r
ri rµ rà rà rÄ r} Ò s c C s t t| || |dS )aû
|
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 )r
rj rµ rà rà rÄ r~ ì s c C s t t| || |dS )aó
|
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 )r
r rµ rà rà rÄ r s c C s t t| || |d}||_|S )a¥
|
Mask an array where equal to a given value.
|
|
Return a MaskedArray, masked where the data in array `x` are
|
equal to `value`. The fill_value of the returned MaskedArray
|
is set to `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=2)
|
|
r )r
rJ r+ )rV r¶ r< Úoutputrà rà rÄ rx s c C s8 ||k r|| }}t | }||k||k@ }t|| |dS )a
|
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 ©rM r
©rV Zv1Zv2r< Zxfr´ rà rà rÄ r{ @ s
|
!
|
c C s8 ||k r|| }}t | }||k ||kB }t|| |dS )a
|
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¸ r¹ rà rà rÄ r h s
|
!
|
c C sV t | r t | j|¡}| j}nt t | ¡|¡}t}t|t ||d}t
|
| |||dS )a©
|
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')
|
>>> eat
|
masked_array(data=[--, 'ham'],
|
mask=[ True, False],
|
fill_value='green_eggs',
|
dtype=object)
|
>>> # plain ol` ham is boring
|
>>> fresh_food = np.array(['cheese', 'ham', 'pineapple'], dtype=object)
|
>>> eat = ma.masked_object(fresh_food, 'green_eggs')
|
>>> eat
|
masked_array(data=['cheese', 'ham', 'pineapple'],
|
mask=False,
|
fill_value='green_eggs',
|
dtype=object)
|
|
Note that `mask` is set to ``nomask`` if possible.
|
|
>>> eat
|
masked_array(data=['cheese', 'ham', 'pineapple'],
|
mask=False,
|
fill_value='green_eggs',
|
dtype=object)
|
|
r² ©rD r< r+ ) rd rT rJ r@ rF ró r/ r ru rr rw )rV r¶ r< r r´ rD rà rà rÄ r s :çñhãµøä>ç:0âyE>c C sZ t | |}t |jtj¡r.tj||||d}n t ||¡}t||||d}|rV| ¡ |S )aò
|
Mask using floating point equality.
|
|
Return a MaskedArray, masked where the data in array `x` are approximately
|
equal to `value`, determined using `isclose`. The default tolerances for
|
`masked_values` are the same as those for `isclose`.
|
|
For integer types, exact equality is used, in the same way as
|
`masked_equal`.
|
|
The fill_value is set to `value` and the mask is set to ``nomask`` if
|
possible.
|
|
Parameters
|
----------
|
x : array_like
|
Array to mask.
|
value : float
|
Masking value.
|
rtol, atol : float, optional
|
Tolerance parameters passed on to `isclose`
|
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, 2.1)
|
masked_array(data=[1. , 1.1, 2. , 1.1, 3. ],
|
mask=False,
|
fill_value=2.1)
|
|
Unlike `masked_equal`, `masked_values` can perform approximate equalities.
|
|
>>> ma.masked_values(x, 2.1, atol=1e-1)
|
masked_array(data=[1.0, 1.1, --, 1.1, 3.0],
|
mask=[False, False, True, False, False],
|
fill_value=2.1)
|
|
)ÚatolÚrtolrº )
|
rM ró Ú
|
issubdtyper ÚfloatingÚiscloserT rJ rw Ú shrink_mask) rV r¶ r¾ r½ r< r ZxnewrD Úretrà rà rÄ r Ô s =
|
c C sD t j| ddd} tt | ¡ | |d}|jtkr@t|j|j|_|S )aý
|
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=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)
|
|
FTr> r ) ró r
|
r
rE rF r rt r¨ r )r0 r< Úresrà rà rÄ r| s
|
|
c @ sF e Zd ZdZdd Zdd Zdd Zdd Zdd d Zd d Z e Z
|
dS )Ú_MaskedPrintOptionzN
|
Handle the string used to represent missing data in a masked array.
|
|
c C s || _ d| _dS )z9
|
Create the masked_print_option object.
|
|
TN)Ú_displayÚ_enabled)rN Údisplayrà rà rÄ rO J s z_MaskedPrintOption.__init__c C s | j S )zA
|
Display the string to print for masked values.
|
|
©rÆ rg rà rà rÄ rÈ R s z_MaskedPrintOption.displayc C s
|
|| _ dS )z=
|
Set the string to print for masked values.
|
|
NrÉ )rN rë rà rà rÄ Ú set_displayY s z _MaskedPrintOption.set_displayc C s | j S )z;
|
Is the use of the display value enabled?
|
|
©rÇ rg rà rà rÄ Úenabled` s z_MaskedPrintOption.enabledrÅ c C s
|
|| _ dS )z7
|
Set the enabling shrink to `shrink`.
|
|
NrË )rN r rà rà rÄ Úenableg s z_MaskedPrintOption.enablec C s
|
t | jS rý )r rÆ rg rà rà rÄ rh n s z_MaskedPrintOption.__str__N)rÅ ) rÀ rÁ r rÚ rO rÈ rÊ rÌ rÍ rh Ú__repr__rà rà rà rÄ rÅ D s
|
rÅ z--c C sL | j j}|dk r8|D ] }| | }|| }t||| qntj| ||d dS )zg
|
Puts printoptions in result where mask is True.
|
|
Private function allowing for recursion
|
|
Nrs )r r Ú_recursive_printoptionró rt )r1 rD Zprintoptr r ZcurdataZcurmaskrà rà rÄ rÏ w s rÏ z masked_%(name)s(data =
|
%(data)s,
|
%(nlen)s mask =
|
%(mask)s,
|
%(nlen)s fill_value = %(fill)s)
|
z¿ masked_%(name)s(data =
|
%(data)s,
|
%(nlen)s mask =
|
%(mask)s,
|
%(nlen)s fill_value = %(fill)s,
|
%(nlen)s dtype = %(dtype)s)
|
z masked_%(name)s(data = %(data)s,
|
%(nlen)s mask = %(mask)s,
|
%(nlen)s fill_value = %(fill)s)
|
z masked_%(name)s(data = %(data)s,
|
%(nlen)s mask = %(mask)s,
|
%(nlen)s fill_value = %(fill)s,
|
%(nlen)s dtype = %(dtype)s)
|
)Zlong_stdZlong_flxZ short_stdZ short_flxc C sX | j j}|D ]F}| | }|j jdk r:t||| || q tj||| || d q dS )z2
|
Recursively fill `a` with `fill_value`.
|
|
Nrs )r r Ú_recursive_filledró rt )r0 rD r+ r r Úcurrentrà rà rÄ rÐ « s rÐ c sº fdd t | ¡} | j}| ¡ } t| trrt fdd| jD ¡}| t¡}t fddt | D ¡|_
|
nt fdd| D ¡}t |dkr¶t |j}||d< t ||_|S ) a:
|
Flatten a structured array.
|
|
The data type of the output is chosen such that it can represent all of the
|
(nested) fields.
|
|
Parameters
|
----------
|
a : structured array
|
|
Returns
|
-------
|
output : masked array or ndarray
|
A flattened masked array if the input is a masked array, otherwise a
|
standard ndarray.
|
|
Examples
|
--------
|
>>> ndtype = [('a', int), ('b', float)]
|
>>> a = np.array([(1, 1), (2, 2)], dtype=ndtype)
|
>>> np.ma.flatten_structured_array(a)
|
array([[1., 1.],
|
[2., 2.]])
|
|
c 3 s2 t | D ]$}t|dr& |E dH q|V qdS )z;
|
Flattens a compound of nested iterables.
|
|
r¨ N)Úiterr )ÚiterableÚelm©Úflatten_sequencerà rÄ rÖ Ô s
|
z2flatten_structured_array.<locals>.flatten_sequencec s g | ]}t | ¡ qS rà ©r r! ©rö rx rÕ rà rÄ rø ã s z,flatten_structured_array.<locals>.<listcomp>c s g | ]}t | ¡ qS rà r× rØ rÕ rà rÄ rø å s ÿc s g | ]}t | ¡ qS rà r× rØ rÕ rà rÄ rø è s rÅ r )ró r. r¨ r r r r
|
r@ rB rY rF r rH r )r0 ÚinishapeÚoutr rà rÕ rÄ rP ¹ s
|
|
|
ÿ
|
c s@ fdd}t t dp$t t d}|dk r6|j|_ |_|S )a
|
Return a class method wrapper around a basic array method.
|
|
Creates a class method which returns a masked array, where the new
|
``_data`` array is the output of the corresponding basic 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.
|
|
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.
|
|
Returns
|
-------
|
method : instancemethod
|
Class method wrapper of the specified basic array method.
|
|
c s^ t | j ||}| t| ¡}| | ¡ | j}s@| |¡ n|tk rZt | |||_|S rý )r r@ rB r6 ru rF Ú __setmask__r )rN rv Úparamsr1 rD ©ÚfuncnameÚonmaskrà rÄ Úwrapped_method
|
s
|
z$_arraymethod.<locals>.wrapped_methodN)r r ró rÚ rÀ )rÞ rß rà Zmethdocrà rÝ rÄ Ú _arraymethodð s rá c @ s8 e Zd ZdZdd Zdd Zdd Zdd Zd
|
d Zd S ) ÚMaskedIteratora¿
|
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)
|
<class 'numpy.ma.core.MaskedIterator'>
|
>>> 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 s0 || _ |jj| _|jtkr"d | _n
|
|jj| _d S rý )r
r@ ÚflatÚdataiterrF r Úmaskiter)rN r
rà rà rÄ rO M
|
s
|
|
|
zMaskedIterator.__init__c C s | S rý rà rg rà rà rÄ r¨ V
|
s zMaskedIterator.__iter__c C sr | j |¡ t| j¡}| jd k rn| j |¡}t|trH|j|_||_ n&t|t
|
j rft ||| jj dS |rntS |S )N©rD Úhardmask)rä Ú __getitem__rB r6 r
rå r r r¨ rF ró r& r Ú _hardmaskrv )rN Úindxr1 rF rà rà rÄ rè Y
|
s
|
|
zMaskedIterator.__getitem__c C s* t || j|< | jd k r&t|| j|< d S rý )rW rä rå rY )rN Úindexr¶ rà rà rÄ Ú __setitem__h
|
s
|
zMaskedIterator.__setitem__c C sH t | j}| jdk rDt | j}t|tjr<t||| jjdS |rDt S |S )aT
|
Return the next value, or raise StopIteration.
|
|
Examples
|
--------
|
>>> x = np.ma.array([3, 2], mask=[0, 1])
|
>>> fl = x.flat
|
>>> next(fl)
|
3
|
>>> next(fl)
|
masked
|
>>> next(fl)
|
Traceback (most recent call last):
|
...
|
StopIteration
|
|
Nræ )
|
Únexträ rå r ró r& r r
ré rv )rN rx rê rà rà rÄ Ú__next__m
|
s
|
|
|
zMaskedIterator.__next__N) rÀ rÁ r rÚ rO r¨ rè rì rî rà rà rà rÄ râ
|
s / râ c sz e Zd ZdZdZeZdZeZ dZ
|
dZ dedddddddddf d d
|
Z d d Z d d ZdêddZdëddZdd Zejddddd Ze fddZej fddZe fd d Zej fd d Zdìd d ZeZed!d" Zejd#d" Zed$d% Z e jd&d% Z d'd( Z d)d* Z ed+d, Z d-d. Z ed/d0 Z!d1d2 Z"ed3d4 Z#d5d6 Z$ee$d7Z%ee$d7Z&ed8d9 Z'e'jd:d9 Z'ed;d< Z(e(jdíd=d<Z(e(j)Z*e(j+Z,dîd>d?Z-d@dA Z.dïdBdCZ/dDdE Z0dFdG Z1dHdI Z2dJdK Z3dLdM Z4dNdO Z5dPdQ Z6dRdS Z7dTdU Z8dVdW Z9dXdY Z:dZd[ Z;d\d] Z<d^d_ Z=d`da Z>dbdc Z?ddde Z@dfdg ZAdhdi ZBdjdk ZCdldm ZDdndo ZEdpdq ZFdrds ZGdtdu ZHdvdw ZIdxdy ZJdzd{ ZKd|d} ZLd~d ZMdd ZNdd ZOdd
ZPedd ZQeQj)ZRedd ZSeSj)ZTdejUfddZVdðddZWdd ZXdñddZYdòddZZdd Z[dd Z\ddejUfddZ]ddejUfddZ^dd Z_dó fd¡d¢ Z`ej`je`_dôd£d¤ZadddejUfd¥d¦Zbdõd§d¨ZcdddejUfd©dªZdedZedöd«d¬ZfdddejUf fdd® Zgd÷d¯d°ZhddddejUf fd±d² Ziejijei_ddddejUfd³d´Zjdødµd¶ZkejUddddfd·d¸ZldùejUd¹dºd»ZmdúejUd¹d¼d½Zndûd¿dÀZodddejUfdÁdÂZpdddejUfdÃdÄZqdüdÅdÆZr fdÇdÈZs fdÉdÊZtdýdËdÌZuevdÍZwevdÎZxevdÏZyevdÐZzevdÑZ{evdÒZ|edÓdÔ d7Z}evdÕZ~dþdÖd×ZdÿdØdÙZd dÚdÛZddÞdßZdàdá ZeZ fdâdãZ
fdädåZdædç ZddèdéZ ZS ( r az
|
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=False, subok=True,
|
ndmin=0, fill_value=None, keep_mask=True, hard_mask=None,
|
shrink=True, order=None)
|
|
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.
|
order : {'C', 'F', 'A'}, optional
|
Specify the order of the array. If order is 'C', then the array
|
will be in C-contiguous order (last-index varies the fastest).
|
If order is 'F', then the returned array will be in
|
Fortran-contiguous order (first-index varies the fastest).
|
If order is 'A' (default), then the returned array may be
|
in any order (either C-, Fortran-contiguous, or even discontiguous),
|
unless a copy is required, in which case it will be C-contiguous.
|
|
Examples
|
--------
|
|
The ``mask`` can be initialized with an array of boolean values
|
with the same shape as ``data``.
|
|
>>> data = np.arange(6).reshape((2, 3))
|
>>> np.ma.MaskedArray(data, mask=[[False, True, False],
|
... [False, False, True]])
|
masked_array(
|
data=[[0, --, 2],
|
[3, 4, --]],
|
mask=[[False, True, False],
|
[False, False, True]],
|
fill_value=999999)
|
|
Alternatively, the ``mask`` can be initialized to homogeneous boolean
|
array with the same shape as ``data`` by passing in a scalar
|
boolean value:
|
|
>>> np.ma.MaskedArray(data, mask=False)
|
masked_array(
|
data=[[0, 1, 2],
|
[3, 4, 5]],
|
mask=[[False, False, False],
|
[False, False, False]],
|
fill_value=999999)
|
|
>>> np.ma.MaskedArray(data, mask=True)
|
masked_array(
|
data=[[--, --, --],
|
[--, --, --]],
|
mask=[[ True, True, True],
|
[ True, True, True]],
|
fill_value=999999,
|
dtype=int64)
|
|
.. note::
|
The recommended practice for initializing ``mask`` with a scalar
|
boolean value is to use ``True``/``False`` rather than
|
``np.True_``/``np.False_``. The reason is :attr:`nomask`
|
is represented internally as ``np.False_``.
|
|
>>> np.False_ is np.ma.nomask
|
True
|
|
é Féd iÜ NTr c s2 t j|||| d|d t|dt } t|tr@|j jkr@d}t|| rj|rjt|tsjt t|¡ n t | ¡ t
|
|drt|ts|j _ t j |tkrn|sÊ|
|
r¶t _ nt j jd _ n t|ttfr8z t j fdd|D d}W n tk
|
r t}Y nX tkrj| ¡ rj| _ d _n2| _|rÚ j ¡ _ t|tk rÚ|j|j _nl|dkrtkrt j jd}nn|dkrºtkrºt j jd}nHzt j||d }W n2 tk
|
r t jfd
|
d|D d}Y nX |j jkrj j|j } }|d kr8t | j¡}n.|| krRt | j¡}nd }t || |f d} j tkr| _ | _nT|s| _ | _n> j j d k rÄfdd j | nt | j ¡ _ d _|d krðt|dd }|d k rt | j _!| d kr"t|dd _"n| _"| _# S )z¢
|
Create a new masked array from scratch.
|
|
Notes
|
-----
|
A masked array can also be created by taking a .view(MaskedArray).
|
|
T)r r< Úorderr? ÚndminÚ
|
_baseclassrF r c s g | ]}t tj| jd qS )r )rY ró r. r ©rö rê )r@ rà rÄ rø + s ÿz'MaskedArray.__new__.<locals>.<listcomp>Fr% c s g | ]}t |gt qS rà ©r r rô ©Úmdtyperà rÄ rø H s rÅ z?Mask and data not compatible: data size is %i, mask size is %i.Nc sD | j jD ]6}| | || }}|j jdk r6 || q||O }qdS )z'do a|=b on each field of a, recursivelyNr¦ )r0 rÜ r ÚafZbf)Ú _recursive_orrà rÄ rù ` s
|
z*MaskedArray.__new__.<locals>._recursive_orÚ _fill_valueré )$ró r
|
r r6 r r r¨ r8 r rB r rF rs r r r½ r rH r' r r Ú _sharedmaskr< rX r rÕ r« r£ r¢ r r rp r. rú ré ró )r< rC rD r r< r? rò r+ Ú keep_maskÚ hard_maskr rñ ró ZndÚnmÚmsgrà )r@ rù r÷ rÄ Ú__new__ø
|
s
|
ÿ
|
|
|
ÿþ
|
|
ÿ
|
|
|
|
|
|
|
zMaskedArray.__new__c C s¶ t |trt|}nt}i }| t|di ¡ | t|di ¡ t |ts\| t|di ¡ tt|ddt|ddt|ddt|d dt|d
|
|||d }| j |¡ | j |¡ dS ) z9
|
Copies some attributes of obj to self.
|
|
Ú_optinfoÚ _basedictÚ__dict__rú Nré Frû Ú_isfieldró )rú ré rû r ró r r )r r r6 Úupdater r r5 r )rN rÖ ró r Ú_dictrà rà rÄ ru | s&
|
|
|
|
|
|
|
ú zMaskedArray._update_fromc C sB | |¡ t|tr¬|jjdk r*t|}nt|}|tk r¢|jd d | jd d kr¢| j|jkrj|j}n
|
t | j}| j
|
j rd}n| j
|
j rd}nd}| ||¡}q°| ¡ }nt}|| _| jtk rz| j| j_W n2 tk
|
rê t| _Y n ttfk
|
r Y nX | jdk r"t| j| j| _n | jjdk r>td| j| _dS )z.
|
Finalizes the masked array.
|
|
NrC r ÚCÚFÚK)ru r r r r rY rX r Z__array_interface__rs ÚflagsÚ c_contiguousÚ f_contiguousÚastyperB rF r¨ r' rÕ rA rú r. )rN rÖ rF Z _mask_dtyperñ rà rà rÄ Ú__array_finalize__ s>
|
|
|
ÿ
|
|
|
z MaskedArray.__array_finalize__c C sN || kr|}n| t| ¡}| | ¡ |dk rJ|j ¡ |_|\}}}|d|j
}ttdd |D }t |d¡} | dk r t
|
j ddd t | | d}
|
W 5 Q R X |
|
¡ r zt| d } W n4 tk
|
rÜ t| } Y n tk
|
rô | j} Y nX t
|
j|| |
|
d |tkr|
|
}n||
|
B }|| k r>|jd kr>|r>tS ||_d
|
|_|S ) zr
|
Special hook for ufuncs.
|
|
Wraps the numpy array and sets the mask according to context.
|
|
Nc S s g | ] }t |qS rà ©rY )rö Úargrà rà rÄ rø s z.MaskedArray.__array_wrap__.<locals>.<listcomp>rQ rr TrÆ rs rà F)rB r6 ru rF r< Zninr ru rm r ró rS rM r rn rÕ r r+ rt r r¨ rv rû ) rN rÖ Úcontextr1 Úfuncrv Zout_iZ
|
input_argsrê rl rx r+ rà rà rÄ Ú__array_wrap__ó s:
|
|
|
|
|
|
zMaskedArray.__array_wrap__c C sÜ |dkr*|dkr t | ¡}qt | |¡}nf|dkrz,t|t rPt | |¡}d}n t | |¡}W q tk
|
r~ t | |¡}Y qX nt | ||¡}t|tk r¨|j ¡ |_t|dddk rØ|dkrÒ|dkrÊqØd|_n||_ |S )a3
|
|
Return a view of the MaskedArray data.
|
|
Parameters
|
----------
|
dtype : data-type or ndarray sub-class, optional
|
Data-type descriptor of the returned view, e.g., float32 or int16.
|
The default, None, results in the view having the same data-type
|
as `a`. As with ``ndarray.view``, dtype can also be specified as
|
an ndarray sub-class, which then specifies the type of the
|
returned object (this is equivalent to setting the ``type``
|
parameter).
|
type : Python type, optional
|
Type of the returned view, either ndarray or a subclass. The
|
default None results in type preservation.
|
fill_value : scalar, optional
|
The value to use for invalid entries (None by default).
|
If None, then this argument is inferred from the passed `dtype`, or
|
in its absence the original array, as discussed in the notes below.
|
|
See Also
|
--------
|
numpy.ndarray.view : Equivalent method on ndarray object.
|
|
Notes
|
-----
|
|
``a.view()`` is used two different ways:
|
|
``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view
|
of the array's memory with a different data-type. This can cause a
|
reinterpretation of the bytes of memory.
|
|
``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just
|
returns an instance of `ndarray_subclass` that looks at the same array
|
(same shape, dtype, etc.) This does not cause a reinterpretation of the
|
memory.
|
|
If `fill_value` is not specified, but `dtype` is specified (and is not
|
an ndarray sub-class), the `fill_value` of the MaskedArray will be
|
reset. If neither `fill_value` nor `dtype` are specified (or if
|
`dtype` is an ndarray sub-class), then the fill value is preserved.
|
Finally, if `fill_value` is specified, but `dtype` is not, the fill
|
value is set to the specified value.
|
|
For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
|
bytes per entry than the previous dtype (for example, converting a
|
regular array to a structured array), then the behavior of the view
|
cannot be predicted just from the superficial appearance of ``a`` (shown
|
by ``print(a)``). It also depends on exactly how ``a`` is stored in
|
memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus
|
defined as a slice or transpose, etc., the view may give different
|
results.
|
Nrú )
|
r rB r9 rÕ rX r rF r rú r+ )rN r r6 r+ r· rà rà rÄ rB + s, 8
|
zMaskedArray.viewc C s¤ | j | }| j}dd }dd }|tk r:|| }||}n(t}|| j |}|dkrb|t| | }|rÈt|tjrt||| jdS | j j
|
tj krºt|tj rº|t k rº|r´t|ddS |S n |rÂt S |S nØ| t
|
| ¡}| | ¡ t|r| jdk r|| j| |_t|jtj std |jjd
|
kr||j|jjd
|
k ¡ sbtjd |d |jd
|
d dd |jjd
|
d
jd
|
d|_d|_|tk r t||j |_d|_ |S )zi
|
x.__getitem__(y) <==> x[y]
|
|
Return the item described by i, as a masked array.
|
|
c S s t | tj S rý )r ró r r rà rà rÄ Ú
|
_is_scalar s z+MaskedArray.__getitem__.<locals>._is_scalarc S sH t |tjsdS | jjtjkr0| j|jk rDdS nt| jtjkrDdS dS )z
|
Return whether `elem` is a scalar result of indexing `arr`, or None
|
if undecidable without promoting nomask to a full mask
|
TFN)r ró r r r6 Úobject_rè )rÌ Úelemrà rà rÄ Ú_scalar_heuristic s z2MaskedArray.__getitem__.<locals>._scalar_heuristicNræ Tr¥ zInternal NumPy error.r z&Upon accessing multidimensional field zi, need to keep dimensionality of fill_value at 0. Discarding heterogeneous fill_value and setting all to r é rÈ rÅ ©r ) rC rF r rY r ró r& r ré r r6 r r rv r rB ru rK rú Ú RuntimeErrorr rã r rÊ rË r° r r¢ r¨ rû )rN rê ZdoutrF r r ZmoutZscalar_expectedrà rà rÄ rè
s\
|
|
|
ÿþ
|
|
|
ÿ
|
ú
|
|
zMaskedArray.__getitem__rQ )ZoverrG c C s | t krtd| j}| j}t|trZ|||< |tkrJt| j| j | _}t
|
|||< dS |j }|t kr²|tkrt| j| }| _|j dk r¦t dgt |j ||< nd||< dS t|d|}t
|
|}|j dk rì|tkrìt dgt |j }|tkr$|||< |tk rt| j| }| _|||< nà| jsbt|trPt|tsP|||j< n|||< |||< n¢t|dr|j tkr|t |¡ }|||< nr|j dk rªd}t|t|| |dd} | j| }
|
|
|
jd krætj|
|
|| d
|
n| tkrô|}
|
|
|
||< | ||< dS ) z
|
x.__setitem__(i, y) <==> x[i]=y
|
|
Set item described by index. If value is masked, masks those
|
locations.
|
|
z Cannot alter the masked element.NTr@ Fr z,Flexible 'hard' masks are not yet supported.r rÅ rs )rv r r@ rF r r r rt r¨ r rX r r r r ré rw rC r r rT ro ÚNotImplementedErrorru r« ró rt ) rN rê r¶ r@ rF Z_dtypeÚdvalZmvalr- ZmindxZdindxrà rà rÄ rì sb
|
|
|
|
|
ÿ
|
|
|
|
zMaskedArray.__setitem__c s t jS rý )rj r rg ro rà rÄ r M s zMaskedArray.dtypec sb t tt| j | |¡ | jtk r^| j t|t ¡| _z| j
|
| j_
|
W n t t fk
|
r\ Y nX d S rý ) rj r r6 r Ú__set__rF r rB rs r r¨ rA rÕ )rN r ro rà rÄ r Q s
|
c s t jS rý )rj r¨ rg ro rà rÄ r¨ ] s zMaskedArray.shapec s2 t tt| j | |¡ t| tk r.| j| j_d S rý )rj r r6 r¨ r rX r rF )rN r¨ ro rà rÄ r¨ a s c s | j }| j}|tkrd}|tkr>|tkr,dS t| j| }| _|jdkr| jrX||O }n&t|t t
|
t j t j frx||d< n||_nð|j t j|dd}|jsÔ|j jdkrÈt jt| ¡ gt d}n
|
| ¡}nHzt j|| d}W n2 tk
|
r t j fd d
|
|D d}Y nX | jrH|jD ]}|| || O < q*n(t|t t
|
t j t j frj||d< n||_|jr| j|_dS ) z
|
Set the mask.
|
|
TN.Fr rÜ r r% c s g | ]}t |gt qS rà rõ rô rö rà rÄ rø s z+MaskedArray.__setmask__.<locals>.<listcomp>)r rF rv r rt r¨ r ré r Úintr_ ró r Únumberrã r
|
r r r r! r r rÕ )rN rD r< ZidtypeZ current_maskÚnrà rö rÄ rÛ i sJ
|
|
|
ÿ ÿ
|
|
zMaskedArray.__setmask__c C s
|
| j ¡ S )z Current mask. )rF rB rg rà rà rÄ rD ° s zMaskedArray.maskc C s | |¡ d S rý )rÛ )rN r¶ rà rà rÄ rD º s c C s. | j t¡}|jjdkr |S tjt|ddS )aí
|
Get or set the mask of the array if it has no named fields. For
|
structured arrays, returns a ndarray of booleans where entries are
|
``True`` if **all** the fields are masked, ``False`` otherwise:
|
|
>>> x = np.ma.array([(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)],
|
... mask=[(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)],
|
... dtype=[('a', int), ('b', int)])
|
>>> x.recordmask
|
array([False, False, True, False, False])
|
NrÆ r )rF rB r r r ró r rP )rN rF rà rà rÄ Ú
|
recordmask¾ s zMaskedArray.recordmaskc C s t dd S )Nz*Coming soon: setting the mask per records!©r )rN rD rà rà rÄ r! Ñ s c C s
|
d| _ | S )a
|
Force the mask to hard, preventing unmasking by assignment.
|
|
Whether the mask of a masked array is hard or soft is determined by
|
its `~ma.MaskedArray.hardmask` property. `harden_mask` sets
|
`~ma.MaskedArray.hardmask` to ``True`` (and returns the modified
|
self).
|
|
See Also
|
--------
|
ma.MaskedArray.hardmask
|
ma.MaskedArray.soften_mask
|
|
T©ré rg rà rà rÄ r\ Õ s zMaskedArray.harden_maskc C s
|
d| _ | S )a¦
|
Force the mask to soft (default), allowing unmasking by assignment.
|
|
Whether the mask of a masked array is hard or soft is determined by
|
its `~ma.MaskedArray.hardmask` property. `soften_mask` sets
|
`~ma.MaskedArray.hardmask` to ``False`` (and returns the modified
|
self).
|
|
See Also
|
--------
|
ma.MaskedArray.hardmask
|
ma.MaskedArray.harden_mask
|
|
Fr# rg rà rà rÄ r¬ ç s zMaskedArray.soften_maskc C s | j S )aü
|
Specifies whether values can be unmasked through assignments.
|
|
By default, assigning definite values to masked array entries will
|
unmask them. When `hardmask` is ``True``, the mask will not change
|
through assignments.
|
|
See Also
|
--------
|
ma.MaskedArray.harden_mask
|
ma.MaskedArray.soften_mask
|
|
Examples
|
--------
|
>>> x = np.arange(10)
|
>>> m = np.ma.masked_array(x, x>5)
|
>>> assert not m.hardmask
|
|
Since `m` has a soft mask, assigning an element value unmasks that
|
element:
|
|
>>> m[8] = 42
|
>>> m
|
masked_array(data=[0, 1, 2, 3, 4, 5, --, --, 42, --],
|
mask=[False, False, False, False, False, False,
|
True, True, False, True],
|
fill_value=999999)
|
|
After hardening, the mask is not affected by assignments:
|
|
>>> hardened = np.ma.harden_mask(m)
|
>>> assert m.hardmask and hardened is m
|
>>> m[:] = 23
|
>>> m
|
masked_array(data=[23, 23, 23, 23, 23, 23, --, --, 23, --],
|
mask=[False, False, False, False, False, False,
|
True, True, False, True],
|
fill_value=999999)
|
|
r# rg rà rà rÄ rç ù s *zMaskedArray.hardmaskc C s | j r| j ¡ | _d| _ | S )aY
|
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
|
|
F)rû rF r< rg rà rà rÄ Ú unshare_mask% s zMaskedArray.unshare_maskc C s | j S )z' Share status of the mask (read-only). )rû rg rà rà rÄ Ú
|
sharedmask7 s zMaskedArray.sharedmaskc C s t | j| _| S )a
|
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]])
|
>>> x.shrink_mask()
|
masked_array(
|
data=[[1, 2],
|
[3, 4]],
|
mask=False,
|
fill_value=999999)
|
>>> x.mask
|
False
|
|
)r rF rg rà rà rÄ r < s zMaskedArray.shrink_maskc C s | j S )z+ Class of the underlying data (read-only). )ró rg rà rà rÄ Ú baseclass[ s zMaskedArray.baseclassc C s t | | j¡S )aª
|
Returns the underlying data, as a view of the masked array.
|
|
If the underlying data is a subclass of :class:`numpy.ndarray`, it is
|
returned as such.
|
|
>>> x = np.ma.array(np.matrix([[1, 2], [3, 4]]), mask=[[0, 1], [1, 0]])
|
>>> x.data
|
matrix([[1, 2],
|
[3, 4]])
|
|
The type of the data can be accessed through the :attr:`baseclass`
|
attribute.
|
)r rB ró rg rà rà rÄ Ú _get_data` s zMaskedArray._get_data)Úfgetc C s t | S )zF Return a flat iterator, or set a flattened version of self to value. )râ rg rà rà rÄ rã t s zMaskedArray.flatc C s | ¡ }||d d
< d S rý )r )rN r¶ Úyrà rà rÄ rã y s c C s4 | j dkrtd| j| _ t| j tr.| j d S | j S )a¥
|
The filling value of the masked array is a scalar. When setting, None
|
will set to a default based on the data type.
|
|
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.fill_value
|
-inf
|
>>> x.fill_value = np.pi
|
>>> x.fill_value
|
3.1415926535897931 # may vary
|
|
Reset to default:
|
|
>>> x.fill_value = None
|
>>> x.fill_value
|
1e+20
|
|
Nrà )rú r. r r r rg rà rà rÄ r+ ~ s
|
|
|
zMaskedArray.fill_valuec C sH t || j}|jdks&tjdtdd | j}|d kr<|| _n||d< d S )Nr zNon-scalar arrays for the fill value are deprecated. Use arrays with scalar values instead. The filled function still supports any array as `fill_value`.r rÈ rà )r. r r rÊ rË ÚDeprecationWarningrú )rN r¶ r rú rà rà rÄ r+ § s
|
üc C s | j }|tkr| jS |dkr$| j}n t|| j}| tkrBt |¡S |jj dk rj| j
|
d¡}t || j | n¬| ¡ sx| jS | j
|
d¡}ztj |||d W n| ttfk
|
rÖ t|td}| t¡}t |||f¡}Y n@ tk
|
r | jjrò n |r
|
tj|| jd}n| j}Y nX |S )a«
|
Return a copy of self, with masked values filled with a given value.
|
**However**, if there are no masked values to fill, self will be
|
returned instead as an ndarray.
|
|
Parameters
|
----------
|
fill_value : array_like, optional
|
The value to use for invalid entries. Can be scalar or non-scalar.
|
If non-scalar, the resulting ndarray must be broadcastable over
|
input array. Default is None, in which case, the `fill_value`
|
attribute of the array is used instead.
|
|
Returns
|
-------
|
filled_array : ndarray
|
A copy of ``self`` with invalid entries replaced by *fill_value*
|
(be it the function argument or the attribute of ``self``), or
|
``self`` itself as an ndarray if there are no invalid entries to
|
be replaced.
|
|
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])
|
>>> x.filled(fill_value=1000)
|
array([ 1, 2, 1000, 4, 1000])
|
>>> type(x.filled())
|
<class 'numpy.ndarray'>
|
|
Subclassing is preserved. This means that if, e.g., the data part of
|
the masked array is a recarray, `filled` returns a recarray:
|
|
>>> x = np.array([(-1, 2), (-3, 4)], dtype='i8,i8').view(np.recarray)
|
>>> m = np.ma.array(x, mask=[(True, False), (False, True)])
|
>>> m.filled()
|
rec.array([(999999, 2), ( -3, 999999)],
|
dtype=[('f0', '<i8'), ('f1', '<i8')])
|
Nr rs r )rF r r@ r+ r. r r ró r. r r< rÐ r rt rÕ rA Únarrayr( r r4 r³ r¨ r
|
)rN r+ rê r1 rx rà rà rÄ rM ¾ s6 -
|
|
zMaskedArray.filledc C s2 t | j¡}| jtk r.| t t | j¡¡¡}|S )aÛ
|
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())
|
<class 'numpy.ndarray'>
|
|
)r r r@ rF r r7 ró ro )rN rC rà rà rÄ r8 s
|
zMaskedArray.compressedc C sX | j | j }}t |¡}|j|||d t| ¡}| | ¡ |tk rT|j||d|_|S )a+
|
Return `a` where condition is ``True``.
|
|
If condition is a `~ma.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:`~ma.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)
|
>>> x
|
masked_array(
|
data=[[1, --, 3],
|
[--, 5, --],
|
[7, --, 9]],
|
mask=[[False, True, False],
|
[ True, False, True],
|
[False, True, False]],
|
fill_value=999999)
|
>>> 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Ú r ) r@ rF ró r/ r7 rB r6 ru r )rN r´ r rÚ r@ rF Z_newrà rà rÄ r7 ) s <
|
|
zMaskedArray.compressc C sô t ¡ rä| j}|tkr | j}qð| j}| jdkr4| jn| j}t| jD ]z}|j | |krD|d }t
|
j ||| f|d}t
|
j |d |d f|d}t
|
j ||| f|d}t
|
j |d |d f|d}qDt | jd}| |¡}t||t n | | j¡}|S )zq
|
Replace masked values with masked_print_option, casting all innermost
|
dtypes to object.
|
rÅ r r r rà )r rÌ rF r r@ r Ú _print_widthÚ_print_width_1dÚranger¨ ró rÐ r9 r r r rÏ rM r+ ) rN rD rÄ rC Z print_widthr ÚindrÌ Úrdtyperà rà rÄ Ú_insert_masked_printq s( ÿ
|
z MaskedArray._insert_masked_printc C s t | ¡ S rý )r r2 rg rà rà rÄ rh s zMaskedArray.__str__c s | j tjkrd}n| j j}tjj ¡ dkr| jdk}t|dt | t
|
| t
|
| j t
|
| j t
|
| j d}t| j j}d |r~dnd|rd nd
|
¡}t| | S d | d }tjj | j ¡ pÌt | j¡pÌ| jd k}dddg}|ræ| d¡ t dd | jdd
D ¡} d| rdi | |d < |dd
D ]2}
|
t t ||d t |
|
¡} d| |
|
< q*d}nfdd|D |d }i tj| ¡ d d d d d d< tj| j d d d d d d< t | j d< |rìtjj | j ¡d< d fd!d|D ¡} || d" S )#z1
|
Literal string representation.
|
|
r
|
éq rÅ ú )r ÚnlenrC rD rk r z{}_{}r ÚshortZflxr± Zmasked_ú(r rC rD r+ r c s s | ]}|d kV qdS )rÅ Nrà )rö Zdimrà rà rÄ r ¾ s z'MaskedArray.__repr__.<locals>.<genexpr>NrÆ r rÎ c s i | ]}|d qS )r4 rà rõ )Ú
|
min_indentrà rÄ Ú
|
<dictcomp>Í s z(MaskedArray.__repr__.<locals>.<dictcomp>Ú
|
z, zdata=ú,)Ú separatorÚprefixÚsuffixzmask=z,
|
c 3 s$ | ] }d | || ¡V qdS )z{}{}={}N)Úformatrõ )ÚindentsÚreprsrà rÄ r á s ÿú)) ró ró r rÀ ÚcoreZ
|
arrayprintZ_get_legacy_print_moder r5 r r rF r+ r r¯ r r? Ú_legacy_print_templatesZdtype_is_impliedr rD r« r! rI r¨ r Z array2stringr2 ÚreprZdtype_short_reprrÓ ) rN r Zis_longÚ
|
parametersZ is_structuredÚkeyr= Z dtype_neededÚkeysZ
|
is_one_rowr÷ r r1 rà )r@ r8 rA rÄ rÎ sv
|
|
ú
|
|
þ
|
ÿý
|
|
|
ü
|
|
ü
|
þzMaskedArray.__repr__c C sH t |t| rdS t|dd}|dkr<t|dd}| j|k S |d kS d S )NFZ__array_ufunc__Ú__array_priority__iÀ½ðÿ)r r6 r rI )rN ÚotherZ array_ufuncZother_priorityrà rà rÄ Ú_delegate_binopç s
|
zMaskedArray._delegate_binopc C sj t |}| j}t||dd}t|}|jjdk r|tjtjfkrDt S t
|
| |¡j }t
|
j | |dd}||_| |¡} |t
|
d|j¡k}n| j} || |}
|
t|
|
t
|
jtfr²|r®tS |
|
S |tk rü|tjtjfkrüt
|
|||||
|
¡}
|
|j |
|
j krüt
|
||
|
j ¡ ¡ }|
|
t| ¡}
|
|
|
| ¡ ||
|
_|
|
j dk rfzt |
|
j t
|
j} W n& t t fk
|
r^ t dt
|
j} Y nX | |
|
_ |
|
S )aù Compare self with other using operator.eq or operator.ne.
|
|
When either of the elements is masked, the result is masked as well,
|
but the underlying boolean data are still set, with self and other
|
considered equal if both are masked, and unequal otherwise.
|
|
For structured arrays, all fields are combined, with masked values
|
ignored. The result is masked if all fields were masked, with self
|
and other considered equal only if both were fully masked.
|
Tr N©r? rà ) rX rD ru rW r r ÚoperatorÚeqÚneÚNotImplementedró r¤ r¨ Z broadcast_torF rM r rC r r r¯ rv r r¼ r< rB r6 ru rú r. rÕ r' ) rN rJ ÚcompareZomaskZsmaskrD ÚodataZbroadcast_shapeZ
|
sbroadcastZsdataÚcheckrk rà rà rÄ Ú _comparisonõ s<
|
|
|
zMaskedArray._comparisonc C s | |tj¡S )aì Check whether other equals self elementwise.
|
|
When either of the elements is masked, the result is masked as well,
|
but the underlying boolean data are still set, with self and other
|
considered equal if both are masked, and unequal otherwise.
|
|
For structured arrays, all fields are combined, with masked values
|
ignored. The result is masked if all fields were masked, with self
|
and other considered equal only if both were fully masked.
|
)rT rM rN ©rN rJ rà rà rÄ Ú__eq__: s zMaskedArray.__eq__c C s | |tj¡S )aô Check whether other does not equal self elementwise.
|
|
When either of the elements is masked, the result is masked as well,
|
but the underlying boolean data are still set, with self and other
|
considered equal if both are masked, and unequal otherwise.
|
|
For structured arrays, all fields are combined, with masked values
|
ignored. The result is masked if all fields were masked, with self
|
and other considered equal only if both were fully masked.
|
)rT rM rO rU rà rà rÄ Ú__ne__G s zMaskedArray.__ne__c C s | |tj¡S rý )rT rM ÚlerU rà rà rÄ Ú__le__U s zMaskedArray.__le__c C s | |tj¡S rý )rT rM ÚltrU rà rà rÄ Ú__lt__X s zMaskedArray.__lt__c C s | |tj¡S rý )rT rM ÚgerU rà rà rÄ Ú__ge__[ s zMaskedArray.__ge__c C s | |tj¡S rý )rT rM ÚgtrU rà rà rÄ Ú__gt__^ s zMaskedArray.__gt__c C s | |¡rtS t| |S )zD
|
Add self to other, and return a new masked array.
|
|
)rK rP r rU rà rà rÄ Ú__add__a s
|
zMaskedArray.__add__c C s
|
t || S )zD
|
Add other to self, and return a new masked array.
|
|
)r rU rà rà rÄ Ú__radd__j s zMaskedArray.__radd__c C s | |¡rtS t| |S )zK
|
Subtract other from self, and return a new masked array.
|
|
)rK rP r² rU rà rà rÄ Ú__sub__s s
|
zMaskedArray.__sub__c C s
|
t || S )zK
|
Subtract self from other, and return a new masked array.
|
|
)r² rU rà rà rÄ Ú__rsub__| s zMaskedArray.__rsub__c C s | |¡rtS t| |S )z6Multiply self by other, and return a new masked array.)rK rP r rU rà rà rÄ Ú__mul__ s
|
zMaskedArray.__mul__c C s
|
t || S )zI
|
Multiply other by self, and return a new masked array.
|
|
)r rU rà rà rÄ Ú__rmul__ s zMaskedArray.__rmul__c C s | |¡rtS t| |S ©zI
|
Divide other into self, and return a new masked array.
|
|
)rK rP rG rU rà rà rÄ Ú__div__ s
|
zMaskedArray.__div__c C s | |¡rtS t| |S rf )rK rP rº rU rà rà rÄ Ú __truediv__ s
|
zMaskedArray.__truediv__c C s
|
t || S ©zI
|
Divide self into other, and return a new masked array.
|
|
)rº rU rà rà rÄ Ú __rtruediv__¤ s zMaskedArray.__rtruediv__c C s | |¡rtS t| |S rf )rK rP rR rU rà rà rÄ Ú __floordiv__« s
|
zMaskedArray.__floordiv__c C s
|
t || S ri )rR rU rà rà rÄ Ú __rfloordiv__´ s zMaskedArray.__rfloordiv__c C s | |¡rtS t| |S )zQ
|
Raise self to the power other, masking the potential NaNs/Infs
|
|
)rK rP r rU rà rà rÄ Ú__pow__» s
|
zMaskedArray.__pow__c C s
|
t || S )zQ
|
Raise other to the power self, masking the potential NaNs/Infs
|
|
)r rU rà rà rÄ Ú__rpow__Ä s zMaskedArray.__rpow__c C s t |}| jtkrB|tk rX| ¡ rXt| j| j| _| j|7 _n|tk rX| j|7 _t|}t | j|j
|
d¡|¡}| j |¡ | S )z.
|
Add other to self in-place.
|
|
r ) rX rF r r rt r¨ r rW ró r¼ r6 r@ Ú__iadd__©rN rJ rê Ú
|
other_datarà rà rÄ ro Ë s
|
zMaskedArray.__iadd__c C s t |}| jtkrB|tk rX| ¡ rXt| j| j| _| j|7 _n|tk rX| j|7 _t|}t | j|j
|
d¡|¡}| j |¡ | S )z5
|
Subtract other from self in-place.
|
|
r ) rX rF r r rt r¨ r rW ró r¼ r6 r@ Ú__isub__rp rà rà rÄ rr Ý s
|
zMaskedArray.__isub__c C s t |}| jtkrB|tk rX| ¡ rXt| j| j| _| j|7 _n|tk rX| j|7 _t|}t | j|j
|
d¡|¡}| j |¡ | S )z3
|
Multiply self by other in-place.
|
|
rÅ ) rX rF r r rt r¨ r rW ró r¼ r6 r@ Ú__imul__rp rà rà rÄ rs î s
|
zMaskedArray.__imul__c C s t |}t | j|¡}t|}t||}| ¡ rVttj \}}t
|
||j |¡|¡}| j |O _ t
|
| j |j d¡|¡}| j |¡ | S )z1
|
Divide self by other in-place.
|
|
rÅ )rW r] rW r@ rX ru r rn ró rG r¼ r r6 rF Ú__idiv__©rN rJ rq Zdom_maskÚ
|
other_maskÚnew_maskr® r$ rà rà rÄ rt ÿ s
|
|
ÿ zMaskedArray.__idiv__c C s t |}t | j|¡}t|}t||}| ¡ rVttj \}}t
|
||j |¡|¡}| j |O _ t
|
| j |j d¡|¡}| j |¡ | S )z7
|
Floor divide self by other in-place.
|
|
rÅ )rW r] rW r@ rX ru r rn ró rR r¼ r r6 rF Ú __ifloordiv__ru rà rà rÄ rx s
|
|
ÿ zMaskedArray.__ifloordiv__c C s t |}t | j|¡}t|}t||}| ¡ rVttj \}}t
|
||j |¡|¡}| j |O _ t
|
| j |j d¡|¡}| j |¡ | S )z6
|
True divide self by other in-place.
|
|
rÅ )rW r] rW r@ rX ru r rn ró rº r¼ r r6 rF Ú __itruediv__ru rà rà rÄ ry % s
|
|
ÿ zMaskedArray.__itruediv__c C s¸ t |}t | j|j d¡|¡}t|}tjddd | j |¡ W 5 Q R X t
|
t | j¡¡}| ¡ r| jt k r| j|O _n|| _tj| j| j|d t||}t| j|| _| S )z;
|
Raise self to the power other, in place.
|
|
rÅ rQ rr rs )rW ró r¼ rF r r6 rX rS r@ Ú__ipow__ro rE r r rt r+ ru )rN rJ rq rv rG rw rà rà rÄ rz 8 s
|
|
zMaskedArray.__ipow__c C s: | j dkrtdn| jr.tjddd tjS t| ¡ S )z$
|
Convert to float.
|
|
rÅ ú7Only length-1 arrays can be converted to Python scalarsz,Warning: converting a masked element to nan.r rÈ ) r« rÕ rF rÊ rË ró Únanr_ r! rg rà rà rÄ Ú __float__M s
|
|
zMaskedArray.__float__c C s. | j dkrtdn| jr"tdt| ¡ S )z"
|
Convert to int.
|
|
rÅ r{ z.Cannot convert masked element to a Python int.)r« rÕ rF r r r! rg rà rà rÄ Ú__int__Z s
|
|
|
zMaskedArray.__int__c C s" | j j t| ¡}| | j¡ |S )aº
|
The imaginary part of the masked array.
|
|
This property is a view on the imaginary part of this `MaskedArray`.
|
|
See Also
|
--------
|
real
|
|
Examples
|
--------
|
>>> x = np.ma.array([1+1.j, -2j, 3.45+1.6j], mask=[False, True, False])
|
>>> x.imag
|
masked_array(data=[1.0, --, 1.6],
|
mask=[False, True, False],
|
fill_value=1e+20)
|
|
)r@ ÚimagrB r6 rÛ rF ©rN r1 rà rà rÄ r f s zMaskedArray.imagc C s" | j j t| ¡}| | j¡ |S )a±
|
The real part of the masked array.
|
|
This property is a view on the real part of this `MaskedArray`.
|
|
See Also
|
--------
|
imag
|
|
Examples
|
--------
|
>>> x = np.ma.array([1+1.j, -2j, 3.45+1.6j], mask=[False, True, False])
|
>>> x.real
|
masked_array(data=[1.0, --, 3.45],
|
mask=[False, True, False],
|
fill_value=1e+20)
|
|
)r@ ÚrealrB r6 rÛ rF r rà rà rÄ r s zMaskedArray.realc sZ |t jkri nd|i}| j}t| jt jrT|tkrDt j| jt j d}|
|
t | j¡}|tkr2| jdkr|dkrt j || j ddS |dkr´| dd¡r®t j| jt j| j d S | jS t|| j d} D ]}|| j| 9 }qÈ| dd¡rt| j} D ] }d||< qøn fd
|
d t| jD }t j||t jdS | tkr@d S | jf |t jd |S )a
|
Count the non-masked elements of the array along the given axis.
|
|
Parameters
|
----------
|
axis : None or int or tuple of ints, optional
|
Axis or axes along which the count is performed.
|
The default, None, performs the count over all
|
the dimensions of the input array. `axis` may be negative, in
|
which case it counts from the last to the first axis.
|
|
.. versionadded:: 1.10.0
|
|
If this is a tuple of ints, the count is performed on multiple
|
axes, instead of a single axis or all the axes as before.
|
keepdims : bool, optional
|
If this is set to True, the axes which are reduced are left
|
in the result as dimensions with size one. With this option,
|
the result will broadcast correctly against the array.
|
|
Returns
|
-------
|
result : ndarray or scalar
|
An array with the same shape as the input array, with the specified
|
axis removed. If the array is a 0-d array, or if `axis` is None, a
|
scalar is returned.
|
|
See Also
|
--------
|
ma.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])
|
|
r° r rà ©Nr )r r rÅ NF)r rò c s g | ]\}}| kr|qS rà rà )rö r rx ©Úaxesrà rÄ rø ô s ÿz%MaskedArray.count.<locals>.<listcomp>r ©r r )ró r rF r rC Zmatrixr r½ r¨ r rB r6 Z AxisErrorr r r
|
r« Zintpr rH Ú enumerater rv r³ ) rN r r° rw rê ÚitemsZaxZout_dimsr0 rà r rÄ r@ s8 8
|
|
|
|
zMaskedArray.countr c C sn |dkr| j jjrdnd}tj| j |d t| ¡}| | ¡ | jt k rdtj| j|d
|
|j ¡|_nt |_|S )af
|
Returns a 1D version of self, as a view.
|
|
Parameters
|
----------
|
order : {'C', 'F', 'A', 'K'}, optional
|
The elements of `a` are read using this index order. 'C' means to
|
index the elements in C-like order, with the last axis index
|
changing fastest, back to the first axis index changing slowest.
|
'F' means to index the elements in Fortran-like index order, with
|
the first index changing fastest, and the last index changing
|
slowest. Note that the 'C' and 'F' options take no account of the
|
memory layout of the underlying array, and only refer to the order
|
of axis indexing. 'A' means to read the elements in Fortran-like
|
index order if `m` is Fortran *contiguous* in memory, C-like order
|
otherwise. 'K' means to read the elements in the order they occur
|
in memory, except for reversing the data when strides are negative.
|
By default, 'C' index order is used.
|
(Masked arrays currently use 'A' on the data when 'K' is passed.)
|
|
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)
|
>>> x
|
masked_array(
|
data=[[1, --, 3],
|
[--, 5, --],
|
[7, --, 9]],
|
mask=[[False, True, False],
|
[ True, False, True],
|
[False, True, False]],
|
fill_value=999999)
|
>>> x.ravel()
|
masked_array(data=[1, --, 3, --, 5, --, 7, --, 9],
|
mask=[False, True, False, True, False, True, False, True,
|
False],
|
fill_value=999999)
|
|
ZkKaAr r ©rñ ) r@ r
|
Úfncr r rB r6 ru rF r r¢ r¨ )rN rñ Úrrà rà rÄ r ÿ s 3
|
|
zMaskedArray.ravelc O sV |j | dd¡d | jj|| t| ¡}| | ¡ | j}|tk rR|j|||_|S )aÏ
|
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])
|
>>> x
|
masked_array(
|
data=[[--, 2],
|
[3, --]],
|
mask=[[ True, False],
|
[False, True]],
|
fill_value=999999)
|
>>> x = x.reshape((4,1))
|
>>> x
|
masked_array(
|
data=[[--],
|
[2],
|
[3],
|
[--]],
|
mask=[[ True],
|
[False],
|
[False],
|
[ True]],
|
fill_value=999999)
|
|
rñ r r ) r r r@ r¢ rB r6 ru rF r )rN rë rw r1 rD rà rà rÄ r¢ = s :
|
zMaskedArray.reshapec C s d}t |dS )av
|
.. 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.
|
|
zoA masked array does not own its data and therefore cannot be resized.
|
Use the numpy.ma.resize function instead.N)r' )rN r Zrefcheckrñ Úerrmsgrà rà rÄ r£ s zMaskedArray.resizeÚraisec C sÐ | j rT| jtk rT| j| }t|dd}t|ddd}| |j¡ || }|| }| jj|||d | jtkrt|tkrdS t | }t|tkr¦|j|d|d n|j||j|d t
|
|ddd}|| _dS )aD
|
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)
|
>>> x
|
masked_array(
|
data=[[1, --, 3],
|
[--, 5, --],
|
[7, --, 9]],
|
mask=[[False, True, False],
|
[ True, False, True],
|
[False, True, False]],
|
fill_value=999999)
|
>>> x.put([0,4,8],[10,20,30])
|
>>> x
|
masked_array(
|
data=[[10, --, 3],
|
[--, 20, --],
|
[7, --, 30]],
|
mask=[[False, True, False],
|
[ True, False, True],
|
[False, True, False]],
|
fill_value=999999)
|
|
>>> x.put(4,999)
|
>>> x
|
masked_array(
|
data=[[10, --, 3],
|
[--, 999, --],
|
[7, --, 30]],
|
mask=[[False, True, False],
|
[ True, False, True],
|
[False, True, False]],
|
fill_value=999999)
|
|
Fr Tr> ©ÚmodeNr£ ) ré rF r r+ r£ r¨ r@ r rX rY rr )rN r` Úvaluesr rD rê rà rà rÄ r s" =
|
|
|
zMaskedArray.putc C s, | j tkr| jjttfS | jj| j jjfS )a
|
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) # may vary
|
|
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, 3083169284) # may vary
|
|
)rF r ÚctypesrC Úidrg rà rà rÄ r_ æ s
|
zMaskedArray.idsc C s
|
| j d S )aý
|
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
|
WRITEBACKIFCOPY : False
|
|
Z
|
CONTIGUOUS)r
|
rg rà rà rÄ Ú iscontiguous s zMaskedArray.iscontiguousc C s® |t jkri nd|i}t| j|f|}|dkrp| d¡jf d|i| t| ¡}|jrd| |¡ n|rlt
|
S |S | d¡jf ||d| t |t rª|js |rª| |¡ |S )a
|
Returns True if all elements evaluate to True.
|
|
The output array is masked where all the values along the given axis
|
are masked: if the output would have been a scalar and that all the
|
values are masked, then the output is `masked`.
|
|
Refer to `numpy.all` for full documentation.
|
|
See Also
|
--------
|
numpy.ndarray.all : corresponding function for ndarrays
|
numpy.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
|
|
r° NTr r, ) ró r r± rF rM r rB r6 r rÛ rv r r ©rN r rÚ r° rw rD rx rà rà rÄ r s $
|
|
|
zMaskedArray.allc C s® |t jkri nd|i}t| j|f|}|dkrp| d¡jf d|i| t| ¡}|jrd| |¡ n|rlt
|
}|S | d¡jf ||d| t |t rª|js |rª| |¡ |S )aS
|
Returns True if any of the elements of `a` evaluate to True.
|
|
Masked values are considered as False during computation.
|
|
Refer to `numpy.any` for full documentation.
|
|
See Also
|
--------
|
numpy.ndarray.any : corresponding function for ndarrays
|
numpy.any : equivalent function
|
|
r° NFr r, ) ró r r± rF rM r rB r6 r rÛ rv r r r rà rà rÄ r C s $
|
|
|
zMaskedArray.anyc C s t | d¡dd ¡ S )aü
|
|
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.
|
numpy.ndarray.nonzero :
|
Equivalent ndarray method.
|
count_nonzero :
|
Counts the number of non-zero elements in the input array.
|
|
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=True)
|
>>> 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]))
|
|
r Fr )r+ rM r rg rà rà rÄ r a s `zMaskedArray.nonzerorÅ c sZ | j }|tkr,t j||||d}| |¡S | j|||d}| |¡ d¡jd|dS dS )z8
|
(this docstring should be overwritten)
|
)ÚoffsetÚaxis1Úaxis2rÚ )r r r r rÆ r, N)rF r rj r¸ r rE rM r³ ) rN r r r r rÚ rê r1 rè ro rà rÄ r¸ à s ÿ
|
zMaskedArray.tracec C s t | |||dS )a
|
a.dot(b, out=None)
|
|
Masked dot product of two arrays. Note that `out` and `strict` are
|
located in different positions than in `ma.dot`. In order to
|
maintain compatibility with the functional version, it is
|
recommended that the optional arguments be treated as keyword only.
|
At some point that may be mandatory.
|
|
.. versionadded:: 1.10.0
|
|
Parameters
|
----------
|
b : masked_array_like
|
Inputs array.
|
out : masked_array, optional
|
Output argument. This must have the exact kind that would be
|
returned if it was not used. In particular, it must have the
|
right type, must be C-contiguous, and its dtype must be the
|
dtype that would be returned for `ma.dot(a,b)`. This is a
|
performance feature. Therefore, if these conditions are not
|
met, an exception is raised, instead of attempting to be
|
flexible.
|
strict : bool, optional
|
Whether masked data are propagated (True) or set to 0 (False)
|
for the computation. Default is False. Propagating the mask
|
means that if a masked value appears in a row or column, the
|
whole row or column is considered masked.
|
|
.. versionadded:: 1.10.2
|
|
See Also
|
--------
|
numpy.ma.dot : equivalent function
|
|
)rÚ Ústrict)Údot)rN rÜ rÚ r rà rà rÄ r Ò s %zMaskedArray.dotc C sÖ |t jkri nd|i}| j}t||f|}|dkr| d¡j|fd|i|}t|dd} | rx| t| ¡}| |¡ n|rt
|
}|S | d¡j|f||d|}t |t rÒt |}
|
|
|
tkrÌt|j }
|
|_||
|
_|S )aW
|
Return the sum of the array elements over the given axis.
|
|
Masked elements are set to 0 internally.
|
|
Refer to `numpy.sum` for full documentation.
|
|
See Also
|
--------
|
numpy.ndarray.sum : corresponding function for ndarrays
|
numpy.sum : equivalent function
|
|
Examples
|
--------
|
>>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
|
>>> x
|
masked_array(
|
data=[[1, --, 3],
|
[--, 5, --],
|
[7, --, 9]],
|
mask=[[False, True, False],
|
[ True, False, True],
|
[False, True, False]],
|
fill_value=999999)
|
>>> x.sum()
|
25
|
>>> x.sum(axis=1)
|
masked_array(data=[4, 5, 16],
|
mask=[False, False, False],
|
fill_value=999999)
|
>>> x.sum(axis=0)
|
masked_array(data=[8, 5, 12],
|
mask=[False, False, False],
|
fill_value=999999)
|
>>> print(type(x.sum(axis=0, dtype=np.int64)[0]))
|
<class 'numpy.int64'>
|
|
r° Nr r r ©r rÚ )ró r rF r± rM r³ r rB r6 rÛ rv r r rX r rt r¨ rã © rN r r rÚ r° rw rF r¢ r1 ZrndimÚoutmaskrà rà rÄ r³ ù s& '
|
zMaskedArray.sumc C sV | d¡j|||d}|dk r8t|tr4| | j¡ |S | t| ¡}| | j¡ |S )a
|
Return the cumulative sum of the array elements over the given 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.
|
|
Refer to `numpy.cumsum` for full documentation.
|
|
Notes
|
-----
|
The mask is lost if `out` is not a valid :class:`ma.MaskedArray` !
|
|
Arithmetic is modular when using integer types, and no error is
|
raised on overflow.
|
|
See Also
|
--------
|
numpy.ndarray.cumsum : corresponding function for ndarrays
|
numpy.cumsum : equivalent function
|
|
Examples
|
--------
|
>>> marr = np.ma.array(np.arange(10), mask=[0,0,0,1,1,1,0,0,0,0])
|
>>> marr.cumsum()
|
masked_array(data=[0, 1, 3, --, --, --, 9, 16, 24, 33],
|
mask=[False, False, False, True, True, True, False, False,
|
False, False],
|
fill_value=999999)
|
|
r ©r r rÚ N) rM rB r r rÛ rD rB r6 rF ©rN r r rÚ r1 rà rà rÄ rB 7 s
|
zMaskedArray.cumsumc C sÖ |t jkri nd|i}| j}t||f|}|dkr| d¡j|fd|i|}t|dd} | rx| t| ¡}| |¡ n|rt
|
}|S | d¡j|f||d|}t |t rÒt |}
|
|
|
tkrÌt|j }
|
|_||
|
_|S )aÖ
|
Return the product of the array elements over the given axis.
|
|
Masked elements are set to 1 internally for computation.
|
|
Refer to `numpy.prod` for full documentation.
|
|
Notes
|
-----
|
Arithmetic is modular when using integer types, and no error is raised
|
on overflow.
|
|
See Also
|
--------
|
numpy.ndarray.prod : corresponding function for ndarrays
|
numpy.prod : equivalent function
|
r° NrÅ r r r r )ró r rF r± rM r r rB r6 rÛ rv r r rX r rt r¨ rã r rà rà rÄ r ` s&
|
zMaskedArray.prodc C sV | d¡j|||d}|dk r8t|tr4| | j¡ |S | t| ¡}| | j¡ |S )a
|
Return the cumulative product of the array elements over the given 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.
|
|
Refer to `numpy.cumprod` for full documentation.
|
|
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.
|
|
See Also
|
--------
|
numpy.ndarray.cumprod : corresponding function for ndarrays
|
numpy.cumprod : equivalent function
|
rÅ r N)rM rA r r rÛ rF rB r6 r rà rà rÄ rA s
|
zMaskedArray.cumprodc sB |t jkri nd|i}| jtkr>t jf ||d|d }n´d}|dkrt| jjt j
|
t j frlt d¡}n t| jjt j rt d¡}d}| jf ||d|}| jf d |i|} | jdkrÌ| d
|
krÌt}n&|ræ| j |d | ¡}n |d | }|dk r>||_t|tr:t|}
|
|
|
tkr0t|j }
|
|_t||
|
_|S |S ) a°
|
Returns the average of the array elements along given axis.
|
|
Masked entries are ignored, and result elements which are not
|
finite will be masked.
|
|
Refer to `numpy.mean` for full documentation.
|
|
See Also
|
--------
|
numpy.ndarray.mean : corresponding function for ndarrays
|
numpy.mean : Equivalent function
|
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
|
|
r° r
rà FNZf8Zf4Tr r r )ró r rF r rj r r9 r r6 ÚntypesÚintegerr ÚmuÚfloat16r³ r@ r¨ rv rã r r rX rt ) rN r r rÚ r° rw r1 Zis_float16_resultZdsumÚcntr ro rà rÄ r © s4
|
|
|
|
|
zMaskedArray.meanc C s* | ||¡}|s| | S | t|| S dS )a½
|
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 )rN r r rê rà rà rÄ r à s zMaskedArray.anomc s |t jkri nd|i}| jtkrdt jf ||||d|d }|dk r`t|tr\| t¡ |S |S | j f d|i|| }| | j
|
||dd } t | r¨t | ¡d } n| | 9 } t| j|f|| t| ¡}
|
|
|
jrüt| jj|f||d k|
|
_|
|
| ¡ n^t|
|
rZt}
|
|dk rZt|tr2d |_| d¡ n$|jjd
|
krNd } t| nt j |_|S |dk r|
|
|_t|tr| |
|
j ¡ |S |
|
S ) au
|
Returns the variance of the array elements along given axis.
|
|
Masked entries are ignored, and result elements which are not
|
finite will be masked.
|
|
Refer to `numpy.var` for full documentation.
|
|
See Also
|
--------
|
numpy.ndarray.var : corresponding function for ndarrays
|
numpy.var : Equivalent function
|
r° )r r rÚ Úddofrà Nr T©r° r r Úbiuú>Masked data information would be lost in one or more location.) ró r rF r rj r» r r rÛ r@ r r rT r rG r³ rB r6 r ru r ru rX rv rã r r r r| rD ) rN r r rÚ r£ r° rw rà r¢ ZdanomÚdvarr ro rà rÄ r» sL
|
ÿÿ
|
|
|
|
|
|
zMaskedArray.varc C s\ |t jkri nd|i}| j||||f|}|tk rX|dk rPt j|d|dd |S t|}|S )a>
|
Returns the standard deviation of the array elements along given axis.
|
|
Masked entries are ignored.
|
|
Refer to `numpy.std` for full documentation.
|
|
See Also
|
--------
|
numpy.ndarray.std : corresponding function for ndarrays
|
numpy.std : Equivalent function
|
r° Ng à?r ©rÚ r )ró r r» rv r r¯ )rN r r rÚ r£ r° rw r§ rà rà rÄ r± E s zMaskedArray.stdc C sh | j j||d t| ¡}|jdkr8| j|_| | ¡ n
|
| jrBt}|dkrN|S t|t rd|
|
| j¡ |S )a
|
Return each element rounded to the given number of decimals.
|
|
Refer to `numpy.around` for full documentation.
|
|
See Also
|
--------
|
numpy.ndarray.round : corresponding function for ndarrays
|
numpy.around : equivalent function
|
)ÚdecimalsrÚ r N) r@ r¥ rB r6 r rF ru rv r r rÛ )rN r© rÚ r1 rà rà rÄ r¥ ] s
|
|
zMaskedArray.roundc C sb |t jkrt| }|dkrH|r@t | jt j¡r6t j}qHt| }nt| }| |¡}|j
|
|||dS )a!
|
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. If None, the default, the flattened array
|
is used.
|
|
.. versionchanged:: 1.13.0
|
Previously, the default was documented to be -1, but that was
|
in error. At some future date, the default will change to -1, as
|
originally intended.
|
Until then, the axis should be given explicitly when
|
``arr.ndim > 1``, to avoid a FutureWarning.
|
kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
|
The sorting algorithm used.
|
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.
|
endwith : {True, False}, optional
|
Whether missing values (if any) should be treated as the largest values
|
(True) or the smallest values (False)
|
When the array contains unmasked values at the same extremes of the
|
datatype, the ordering of these values and the masked values is
|
undefined.
|
fill_value : scalar or None, optional
|
Value used internally for the masked values.
|
If ``fill_value`` is not None, it supersedes ``endwith``.
|
|
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
|
--------
|
ma.MaskedArray.sort : Describes sorting algorithms used.
|
lexsort : Indirect stable sort with multiple keys.
|
numpy.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])
|
|
N©r r rñ ) ró r rÍ r¿ r rÀ r| r r rM r, )rN r r rñ Úendwithr+ rM rà rà rÄ r, v s @
|
|
|
zMaskedArray.argsortr¤ c C sF |dkrt | }| |¡ t¡}|tjkr.dnt|}|j|||dS )a<
|
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 : scalar or None, 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 or 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(np.arange(4), mask=[1,1,0,0])
|
>>> x.shape = (2,2)
|
>>> x
|
masked_array(
|
data=[[--, --],
|
[2, 3]],
|
mask=[[ True, True],
|
[False, False]],
|
fill_value=999999)
|
>>> x.argmin(axis=0, fill_value=-1)
|
array([0, 0])
|
>>> x.argmin(axis=0, fill_value=9)
|
array([1, 1])
|
|
NF©rÚ r° )r rM rB r ró r r¯ r+ ©rN r r+ rÚ r° rx rà rà rÄ r+ Æ s
|
)zMaskedArray.argminc C sH |dkrt | j}| |¡ t¡}|tjkr0dnt|}|j|||dS )aÏ
|
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 : scalar or None, 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])
|
|
NFr¬ ) r r@ rM rB r ró r r¯ r* r rà rà rÄ r* õ s
|
!
|
zMaskedArray.argmaxrÆ c C sX | j tkr tj| |||d dS | tkr,dS | j|||||d}tj| ||d| d< dS )a
|
|
|
Sort the array, in-place
|
|
Parameters
|
----------
|
a : array_like
|
Array to be sorted.
|
axis : int, 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', 'stable'}, optional
|
The sorting algorithm used.
|
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 treated as the largest values
|
(True) or the smallest values (False)
|
When the array contains unmasked values sorting at the same extremes of the
|
datatype, the ordering of these values and the masked values is
|
undefined.
|
fill_value : scalar or None, optional
|
Value used internally for the masked values.
|
If ``fill_value`` is not None, it supersedes ``endwith``.
|
|
Returns
|
-------
|
sorted_array : ndarray
|
Array of the same type and shape as `a`.
|
|
See Also
|
--------
|
numpy.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
|
-----
|
See ``sort`` for notes on the different sorting algorithms.
|
|
Examples
|
--------
|
>>> a = np.ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])
|
>>> # Default
|
>>> a.sort()
|
>>> a
|
masked_array(data=[1, 3, 5, --, --],
|
mask=[False, False, False, True, True],
|
fill_value=999999)
|
|
>>> a = np.ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])
|
>>> # Put missing values in the front
|
>>> a.sort(endwith=False)
|
>>> a
|
masked_array(data=[--, --, 1, 3, 5],
|
mask=[ True, True, False, False, False],
|
fill_value=999999)
|
|
>>> a = np.ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])
|
>>> # fill_value takes over endwith
|
>>> a.sort(endwith=False, fill_value=3)
|
>>> a
|
masked_array(data=[1, --, --, 3, 5],
|
mask=[False, True, True, False, False],
|
fill_value=999999)
|
|
rª N)r r rñ r+ r« r .)rF r r r® rv r, ró Ztake_along_axis)rN r r rñ r« r+ Zsidxrà rà rÄ r® s G
|
|
ÿzMaskedArray.sortc C s |t jkri nd|i}| j}t||f|}|dkr:t| }|dkr| |¡jf ||d| t| ¡}|j r|
|
|¡ |j rt j ||j |d n|rt }|S | |¡jf ||d|}t|trìt|} | tkrät|j } |_|| _n,|jjdkrd}
|
t|
|
t j |t j|d |S )as
|
Return the minimum along a given axis.
|
|
Parameters
|
----------
|
axis : None or int or tuple of ints, optional
|
Axis along which to operate. By default, ``axis`` is None and the
|
flattened input is used.
|
.. versionadded:: 1.7.0
|
If this is a tuple of ints, the minimum is selected over multiple
|
axes, instead of a single axis or all the axes as before.
|
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 : scalar or None, optional
|
Value used to fill in the masked values.
|
If None, use the output of `minimum_fill_value`.
|
keepdims : bool, optional
|
If this is set to True, the axes which are reduced are left
|
in the result as dimensions with size one. With this option,
|
the result will broadcast correctly against the array.
|
|
Returns
|
-------
|
amin : array_like
|
New array holding the result.
|
If ``out`` was specified, ``out`` is returned.
|
|
See Also
|
--------
|
ma.minimum_fill_value
|
Returns the minimum filling value for a given datatype.
|
|
Examples
|
--------
|
>>> import numpy.ma as ma
|
>>> x = [[1., -2., 3.], [0.2, -0.7, 0.1]]
|
>>> mask = [[1, 1, 0], [0, 0, 1]]
|
>>> masked_x = ma.masked_array(x, mask)
|
>>> masked_x
|
masked_array(
|
data=[[--, --, 3.0],
|
[0.2, -0.7, --]],
|
mask=[[ True, True, False],
|
[False, False, True]],
|
fill_value=1e+20)
|
>>> ma.min(masked_x)
|
-0.7
|
>>> ma.min(masked_x, axis=-1)
|
masked_array(data=[3.0, -0.7],
|
mask=[False, False],
|
fill_value=1e+20)
|
>>> ma.min(masked_x, axis=0, keepdims=True)
|
masked_array(data=[[0.2, -0.7, 3.0]],
|
mask=[[False, False, False]],
|
fill_value=1e+20)
|
>>> mask = [[1, 1, 1,], [1, 1, 1]]
|
>>> masked_x = ma.masked_array(x, mask)
|
>>> ma.min(masked_x, axis=0)
|
masked_array(data=[--, --, --],
|
mask=[ True, True, True],
|
fill_value=1e+20,
|
dtype=float64)
|
r° Nr, rs r¥ r¦ )ró r rF r± r rM r rB r6 r rÛ rt r+ rv r r rX r rt r¨ rã r r r r| © rN r rÚ r+ r° rw rF r¢ r1 r r rà rà rÄ r o s@ A ÿÿÿ
|
|
zMaskedArray.minc C s |t jkri nd|i}| j}t||f|}|dkr:t| }|dkr| |¡jf ||d| t| ¡}|j r|
|
|¡ |j rt j ||j |d n|rt }|S | |¡jf ||d|}t|trìt|} | tkrät|j } |_|| _n,|jjdkrd}
|
t|
|
t j |t j|d |S )aÚ
|
Return the maximum along a given axis.
|
|
Parameters
|
----------
|
axis : None or int or tuple of ints, optional
|
Axis along which to operate. By default, ``axis`` is None and the
|
flattened input is used.
|
.. versionadded:: 1.7.0
|
If this is a tuple of ints, the maximum is selected over multiple
|
axes, instead of a single axis or all the axes as before.
|
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 : scalar or None, optional
|
Value used to fill in the masked values.
|
If None, use the output of maximum_fill_value().
|
keepdims : bool, optional
|
If this is set to True, the axes which are reduced are left
|
in the result as dimensions with size one. With this option,
|
the result will broadcast correctly against the array.
|
|
Returns
|
-------
|
amax : array_like
|
New array holding the result.
|
If ``out`` was specified, ``out`` is returned.
|
|
See Also
|
--------
|
ma.maximum_fill_value
|
Returns the maximum filling value for a given datatype.
|
|
Examples
|
--------
|
>>> import numpy.ma as ma
|
>>> x = [[-1., 2.5], [4., -2.], [3., 0.]]
|
>>> mask = [[0, 0], [1, 0], [1, 0]]
|
>>> masked_x = ma.masked_array(x, mask)
|
>>> masked_x
|
masked_array(
|
data=[[-1.0, 2.5],
|
[--, -2.0],
|
[--, 0.0]],
|
mask=[[False, False],
|
[ True, False],
|
[ True, False]],
|
fill_value=1e+20)
|
>>> ma.max(masked_x)
|
2.5
|
>>> ma.max(masked_x, axis=0)
|
masked_array(data=[-1.0, 2.5],
|
mask=[False, False],
|
fill_value=1e+20)
|
>>> ma.max(masked_x, axis=1, keepdims=True)
|
masked_array(
|
data=[[2.5],
|
[-2.0],
|
[0.0]],
|
mask=[[False],
|
[False],
|
[False]],
|
fill_value=1e+20)
|
>>> mask = [[1, 1], [1, 1], [1, 1]]
|
>>> masked_x = ma.masked_array(x, mask)
|
>>> ma.max(masked_x, axis=1)
|
masked_array(data=[--, --, --],
|
mask=[ True, True, True],
|
fill_value=1e+20,
|
dtype=float64)
|
r° Nr, rs r¥ r¦ )ró r rF r± r rM r rB r6 r rÛ rt r+ rv r r rX r rt r¨ rã r r r r| r® rà rà rÄ r Ò s@ H ÿÿÿ
|
|
zMaskedArray.maxc C sj |dkr0| j |||d}|| j|||d8 }|S | j ||||d|_| j|||d}tj|||dd |S )a´
|
|
Return (maximum - minimum) along the given dimension
|
(i.e. peak-to-peak value).
|
|
.. warning::
|
`ptp` preserves the data type of the array. This means the
|
return value for an input of signed integers with n bits
|
(e.g. `np.int8`, `np.int16`, etc) is also a signed integer
|
with n bits. In that case, peak-to-peak values greater than
|
``2**(n-1)-1`` will be returned as negative values. An example
|
with a work-around is shown below.
|
|
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 : scalar or None, optional
|
Value used to fill in the masked values.
|
keepdims : bool, optional
|
If this is set to True, the axes which are reduced are left
|
in the result as dimensions with size one. With this option,
|
the result will broadcast correctly against the array.
|
|
Returns
|
-------
|
ptp : ndarray.
|
A new array holding the result, unless ``out`` was
|
specified, in which case a reference to ``out`` is returned.
|
|
Examples
|
--------
|
>>> x = np.ma.MaskedArray([[4, 9, 2, 10],
|
... [6, 9, 7, 12]])
|
|
>>> x.ptp(axis=1)
|
masked_array(data=[8, 6],
|
mask=False,
|
fill_value=999999)
|
|
>>> x.ptp(axis=0)
|
masked_array(data=[2, 0, 5, 2],
|
mask=False,
|
fill_value=999999)
|
|
>>> x.ptp()
|
10
|
|
This example shows that a negative value can be returned when
|
the input is an array of signed integers.
|
|
>>> y = np.ma.MaskedArray([[1, 127],
|
... [0, 127],
|
... [-1, 127],
|
... [-2, 127]], dtype=np.int8)
|
>>> y.ptp(axis=1)
|
masked_array(data=[ 126, 127, -128, -127],
|
mask=False,
|
fill_value=999999,
|
dtype=int8)
|
|
A work-around is to use the `view()` method to view the result as
|
unsigned integers with the same bit width:
|
|
>>> y.ptp(axis=1).view(np.uint8)
|
masked_array(data=[126, 127, 128, 129],
|
mask=False,
|
fill_value=999999,
|
dtype=uint8)
|
N)r r+ r° )r rÚ r+ r° r r¨ )r r rã ró r² )rN r rÚ r+ r° r1 Z min_valuerà rà rÄ r = s Kÿ
|
ÿ
|
ÿÿzMaskedArray.ptpc s( t jd| jj ddd t j||S )Nz3Warning: 'partition' will ignore the 'mask' of the r r rÈ )rÊ rË rp rÀ rj Ú partition©rN rv rw ro rà rÄ r¯ s þzMaskedArray.partitionc s( t jd| jj ddd t j||S )Nz6Warning: 'argpartition' will ignore the 'mask' of the r r rÈ )rÊ rË rp rÀ rj Ú argpartitionr° ro rà rÄ r± s þzMaskedArray.argpartitionc
|
C sª | j | j }}t| }t|}|tk r0| d¡}|dkrT|j|||dd |¡}ntj|||||d t |t
|
r¢|tkr|} n|j|||d} | |O } | | ¡ |d S )z
|
r N)r r .)r r rÚ rà ) r@ rF r6 rX r rM rµ rB ró r r rÛ )
|
rN r` r rÚ r r@ rF r< Z maskindicesr rà rà rÄ rµ ¡ s
|
|
|
zMaskedArray.taker< rE Úflattenr¡ r° r´ c C s | ¡ S rý )r¹ rg rà rà rÄ Ú<lambda> ó zMaskedArray.<lambda>r¹ c C s´ | j }|tkr| j ¡ S |dk r.| |¡ ¡ S | jj}|rr| j dd |D ¡}|D ]}d|| || < qT| ¡ S |tkrdgS | j}t j
|
| j ¡ t d}d|| ¡ < ||_| ¡ S )aP
|
Return the data portion of the masked array as a hierarchical Python list.
|
|
Data items are converted to the nearest compatible Python type.
|
Masked values are converted to `fill_value`. If `fill_value` is None,
|
the corresponding entries in the output list will be ``None``.
|
|
Parameters
|
----------
|
fill_value : scalar, optional
|
The value to use for invalid entries. Default is None.
|
|
Returns
|
-------
|
result : list
|
The Python list representation of the masked array.
|
|
Examples
|
--------
|
>>> 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]]
|
|
Nc S s g | ] }|t fqS rà )r( r rà rà rÄ rø ê s z&MaskedArray.tolist.<locals>.<listcomp>r ) rF r r@ ÚtolistrM r r r r¨ ró r
|
r r( )rN r+ rF r r1 r rÙ rà rà rÄ rµ Å s$
|
zMaskedArray.tolistc C s t jdtdd | j||dS )z²
|
A compatibility alias for `tobytes`, with exactly the same behavior.
|
|
Despite its name, it returns `bytes` not `str`\ s.
|
|
.. deprecated:: 1.19.0
|
z0tostring() is deprecated. Use tobytes() instead.r rÈ r )rÊ rË r* Útobytes©rN r+ rñ rà rà rÄ Útostringø s þzMaskedArray.tostringc C s | |¡j|dS )a¸
|
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.
|
|
.. versionadded:: 1.9.0
|
|
Parameters
|
----------
|
fill_value : scalar, optional
|
Value used to fill in the masked values. Default 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
|
--------
|
numpy.ndarray.tobytes
|
tolist, tofile
|
|
Notes
|
-----
|
As for `ndarray.tobytes`, 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.tobytes()
|
b'\x01\x00\x00\x00\x00\x00\x00\x00?B\x0f\x00\x00\x00\x00\x00?B\x0f\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00'
|
|
r )rM r¶ r· rà rà rÄ r¶ s &zMaskedArray.tobytesrÎ ú%sc C s t ddS )zè
|
Save a masked array to a file in binary format.
|
|
.. warning::
|
This function is not implemented yet.
|
|
Raises
|
------
|
NotImplementedError
|
When `tofile` is called.
|
|
z)MaskedArray.tofile() not implemented yet.Nr" )rN ZfidÚsepr? rà rà rÄ Útofile/ s zMaskedArray.tofilec C s\ | j }| j}|dkr t| j|}| jj }tj| jd|fd|fgd}| j|d< | j|d< |S )a
|
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)
|
>>> x
|
masked_array(
|
data=[[1, --, 3],
|
[--, 5, --],
|
[7, --, 9]],
|
mask=[[False, True, False],
|
[ True, False, True],
|
[False, True, False]],
|
fill_value=999999)
|
>>> x.toflex()
|
array([[(1, False), (2, True), (3, False)],
|
[(4, True), (5, False), (6, True)],
|
[(7, False), (8, True), (9, False)]],
|
dtype=[('_data', '<i8'), ('_mask', '?')])
|
|
Nr@ rF )r¨ r )r rF rt r¨ ró r r@ )rN ZddtyperF r÷ Úrecordrà rà rÄ Útoflex> s - ÿ
|
|
zMaskedArray.toflexc s2 d| j j }t ¡ d }|t| |¡| jf S )zWReturn the internal state of the masked array, for pickling
|
purposes.
|
|
ZCFr )r
|
r rj Ú
|
__reduce__rY r¶ rú )rN ÚcfZ
|
data_statero rà rÄ Ú __getstate__{ s zMaskedArray.__getstate__c sH |\}}}}}}}t ||||f¡ | j |t|||f¡ || _dS )ak 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)rj Ú __setstate__rF rs r+ ) rN Ústater® ZshpÚtypZisfÚrawZmskZflvro rà rÄ rÁ s zMaskedArray.__setstate__c C s t | j| jddf| ¡ fS )z6Return a 3-tuple for pickling a MaskedArray.
|
|
)r rÜ )Ú_mareconstructrp ró rÀ rg rà rà rÄ r¾ s þzMaskedArray.__reduce__c C s` ddl m} tjt| | dd}|d kr,i }||t| < | j ¡ D ]\}}||||j|< qB|S )Nr )ÚdeepcopyTr )r< rÆ r r r6 r r r )rN ÚmemorÆ Úcopiedr÷ Úvrà rà rÄ Ú __deepcopy__ s zMaskedArray.__deepcopy__)N)NNN)F)N)N)NN)r )TF)r )r r rÅ NN)NF)NNN)NNN)NN)r N)NNN)NNN)rÆ NNTN)NNNF)NNr )N)Nr )Nr )rÎ r¹ )N)rÀ rÁ r rÚ rI r Z _defaultmaskZ_defaulthardmaskr ró r- r. r ru r r rB rè ró rS rì Úpropertyr Úsetterr¨ rÛ Z _set_maskrD r! r\ r¬ rç r$ r% r r& r' r@ rC rã r+ r( r2 Úfsetr§ rM r8 r7 r2 rh rÎ rK rT rV rW rY r[ r] r_ r` ra rb rc rd re rg rh rj rk rl rm rn ro rr rs rt rx ry rz r} r~ r Zget_imagr Zget_realr r@ r r¢ r£ r r_ r r r r r¸ r r³ rB r r rA r r r» r± r¥ r, r+ r* r® r r r r¯ r± rµ rá r< rE r² r¡ r° r´ ÚTr¹ rµ r¸ r¶ r» r½ Z torecordsrÀ rÁ r¾ rÊ r{ rà rà ro rÄ r
|
s\ d þ
|
]
|
8
|
Z
|
F
|
E
|
|
|
|
|
+
|
|
|
|
|
|
|
(
|
P
|
H TE
|
|
c
|
>B
|
|
U( b
|
|
'>
|
)(
|
7
|
%ÿ>
|
ÿ
|
|
ÿ
|
Pÿ /ÿ ' ÿ
|
Sck
|
X
|
|
3
|
( : c C s2 t |||¡}t t |t|¡}| j| |||dS )zbInternal function that builds a new MaskedArray from the
|
information stored in a pickle.
|
|
)rD r )r r rs )r
|
r& Z baseshapeÚbasetyper@ rF rà rà rÄ rÅ ¨ s rÅ c s| e Zd ZdZedddddfddZe fddZd d
|
Zd d Z fd dZ
|
e
|
Z dd Z dd Z dddZdd Z ZS )r zN
|
Fake a 'void' object to use for masked array with structured dtypes.
|
NFTc
|
C s t j||||d}| | ¡}||_|tk rt|t jr>||_nBzt |¡|_W n0 tk
|
r~ t |} t j|| dd |_Y nX |d k r||_
|
|S )N)r< r? r r rà ) ró r
|
rB ré r r r& rF rÕ rs r+ )
|
rN rC rD r r+ rç r< r? r@ r÷ rà rà rÄ r · s
|
z mvoid.__new__c s t jd S )Nrà )rj r@ rg ro rà rÄ r@ Ë s z mvoid._datac C sT | j }t|| tr6t| j| || | j| | jdS |tk rJ|| rJtS | j| S )z!
|
Get the index.
|
|
)rC rD r+ rý ) rF r r rw r@ rú ré r rv )rN rê rê rà rà rÄ rè Ð s ýzmvoid.__getitem__c C sB || j |< | jr,| j| t|ddO < nt|dd| j|< d S )NrF F)r@ ré rF r )rN rê r¶ rà rà rÄ rì æ s
|
zmvoid.__setitem__c sN | j }|tkrt| jS t| jjd}t j}| |¡}t|| j t t|S )Nrà )
|
rF r r r@ r r rj r rÏ r )rN rê r1 Zdata_arrrÄ ro rà rÄ rh í s
|
|
z mvoid.__str__c c sL | j | j }}|tkr"|E dH n&t||D ]\}}|r@tV q,|V q,dS )z Defines an iterator for mvoidN)r@ rF r r rv )rN r@ rF rx rê rà rà rÄ r¨ ú s zmvoid.__iter__c C s
|
| j ¡ S rý )r@ Ú__len__rg rà rà rÄ rÐ s z mvoid.__len__c C s t | |¡d S )aA
|
Return a copy with masked fields filled with a given value.
|
|
Parameters
|
----------
|
fill_value : array_like, optional
|
The value to use for invalid entries. Can be scalar or
|
non-scalar. If latter is the case, the filled array should
|
be broadcastable over input array. Default is None, in
|
which case the `fill_value` attribute is used instead.
|
|
Returns
|
-------
|
filled_void
|
A `np.void` object
|
|
See Also
|
--------
|
MaskedArray.filled
|
|
rà )r/ rM )rN r+ rà rà rÄ rM s z mvoid.filledc C sZ | j }|tkr| j ¡ S g }t| j| j D ]&\}}|rB| d¡ q*| | ¡ ¡ q*t|S )z¤
|
Transforms the mvoid object into a tuple.
|
|
Masked fields are replaced by None.
|
|
Returns
|
-------
|
returned_tuple
|
Tuple of fields
|
N)rF r r@ rµ r r! r! r )rN rF r1 rx rê rà rà rÄ rµ ! s
|
z mvoid.tolist)N)rÀ rÁ r rÚ r r rË r@ rè rì rh rÎ r¨ rÐ rM rµ r{ rà rà ro rÄ r ² s ÿ
|
|
c C s
|
t | tS )aú
|
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 ©rV rà rà rÄ rd > s 0c s® e Zd ZdZedd Zdd Z fddZd dd Zd d
|
d Z d d Z
|
dd Z dd Z dd Z dd Ze Z Z Z Z ZZ[dd Zdd Zdd Z fd d Z ZS ) r8 Nc C s | j d k ot| j | kS rý )Ú_MaskedConstant__singletonr6 )r< rà rà rÄ Z__has_singletony s z MaskedConstant.__has_singletonc C sF | ¡ s@t d¡}t d¡}d|j_d|j_t||d | ¡| _| jS )Nr TFr¥ )Ú _MaskedConstant__has_singletonró r
|
r
|
Z writeabler rB rÒ )r< rC rD rà rà rÄ r s
|
|
zMaskedConstant.__new__c s6 | ¡ st |¡S | | jkr nt| _t | |¡ d S rý )rÓ rj r rÒ r rp )rN rÖ ro rà rÄ r s
|
z!MaskedConstant.__array_finalize__c C s | t¡ ||¡S rý )rB r Ú__array_prepare__©rN rÖ r rà rà rÄ rÔ s z MaskedConstant.__array_prepare__c C s | t¡ ||¡S rý )rB r r rÕ rà rà rÄ r ¢ s z MaskedConstant.__array_wrap__c C s
|
t tjS rý )r r rÆ rg rà rà rÄ rh ¥ s zMaskedConstant.__str__c C s | t jkrdS t | ¡S d S )Nrv )r8 rÒ r( rÎ rg rà rà rÄ rÎ ¨ s
|
zMaskedConstant.__repr__c C sD zt | |¡W S tk
|
r> tjdtdd t | d¡ Y S X d S )NzjFormat strings passed to MaskedConstant are ignored, but in future may error or produce different behaviorr rÈ rÎ )r( Ú
|
__format__rÕ rÊ rË Ú FutureWarning)rN Ú format_specrà rà rÄ rÖ ¯ s ýzMaskedConstant.__format__c C s
|
| j dfS )z.Override of MaskedArray's __reduce__.
|
rà ro rg rà rà rÄ r¾ ¾ s zMaskedConstant.__reduce__c C s | S rý rà rU rà rà rÄ Ú__iop__Å s zMaskedConstant.__iop__c O s | S )z: Copy is a no-op on the maskedconstant, as it is a scalar rà r° rà rà rÄ r< Ð s zMaskedConstant.copyc C s | S rý rà rg rà rà rÄ Ú__copy__Ö s zMaskedConstant.__copy__c C s | S rý rà )rN rÇ rà rà rÄ rÊ Ù s zMaskedConstant.__deepcopy__c sD | ¡ st ||¡S | | jkr2td| dnt ||¡S d S )Nzattributes of z are not writeable)rÓ rj Ú __setattr__rÒ rA )rN Úattrr¶ ro rà rÄ rÛ Ü s
|
|
ÿzMaskedConstant.__setattr__)N)N)rÀ rÁ r rÒ Ú classmethodrÓ r r rÔ r rh rÎ rÖ r¾ rÙ ro rr rs rx ry rz r< rÚ rÊ rÛ r{ rà rà ro rÄ r8 u s6
|
|
|
úÿþýr8 c C s t | |||| ||||
|
||d S )z~
|
Shortcut to MaskedArray.
|
|
The options are in a different order for convenience and backwards
|
compatibility.
|
|
)
|
rD r r< r? rü rý r+ rò r rñ )r ) rC r r< rñ rD r+ rü rý r r? rò rà rà rÄ r
|
í s
|
|
ýc C s$ t | }|tkrdS | ¡ r dS dS )a
|
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=0)
|
>>> 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=42)
|
>>> 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
|
|
FT)rX r r )rV rê rà rà rÄ rf þ s -c s> e Zd ZdZ fddZdd ZejfddZdd Z Z
|
S )
|
Ú_extrema_operationz
|
Generic class for maximum/minimum functions.
|
|
.. note::
|
This is the base class for `_maximum_operation` and
|
`_minimum_operation`.
|
|
c s t |¡ || _|| _d S rý )rj rO rQ Úfill_value_func)rN rf rQ r+ ro rà rÄ rO A s z_extrema_operation.__init__c C s t | ||¡||S )r\ )r¼ rQ rM rà rà rÄ rW F s z_extrema_operation.__call__c C sÞ t |ddd}t|}|tjkrP|jdkrPtjd| j d| j dtdd d
|
}|tjk rft |d }nt }|t
|
kr| j j |f|}nT| | |¡¡ t|¡}| j j |f|}tjj |f|}t|d rÒ||_n|rÚt}|S ) z#Reduce target along the given axis.FTr> rÅ z!In the future the default for ma.z:.reduce will be axis=0, not the current None, to match np.z;.reduce. Explicitly pass 0 or None to silence this warning.r rÈ Nr rF )r+ rX ró r r rÊ rË rÀ r¿ r5 r rÞ r rM rß rB r6 rT rn r rF rv )rN r r rê rw r rà rà rÄ r K s4 ü
|
ÿÿ
|
z_extrema_operation.reducec C sv t |}t |}|tkr&|tkr&t}n t|}t|}t ||¡}| j t|t|¡}t|tsl| t¡}||_
|
|S )z<Return the function applied to the outer product of a and b.) rX r rY rp r rÞ rM r r rB rF )rN r0 rÜ r
r rê r1 rà rà rÄ r k s
|
|
z_extrema_operation.outer) rÀ rÁ r rÚ rO rW ró r r r r{ rà rà ro rÄ rÞ 8 s
|
rÞ c C sj |t jkri nd|i}z| jf |||d|W S ttfk
|
rd t| jf |||d| Y S X d S ©Nr° ©r r+ rÚ )ró r r rA rÕ r. ©rÖ r rÚ r+ r° rw rà rà rÄ r { s ÿÿc C sj |t jkri nd|i}z| jf |||d|W S ttfk
|
rd t| jf |||d| Y S X d S rà )ró r r rA rÕ r. râ rà rà rÄ r s ÿÿc C sj |t jkri nd|i}z| j|f||d|W S ttfk
|
rd t| jf |||d| Y S X d S )Nr° )rÚ r+ rá )ró r r rA rÕ r. râ rà rà rÄ r s ÿÿc @ s* e Zd ZdZd
|
ddZdd Zdd Zd S ) Ú _frommethodz
|
Define functions from existing MaskedArray methods.
|
|
Parameters
|
----------
|
methodname : str
|
Name of the method to transform.
|
|
Fc C s || _ | ¡ | _|| _d S rý )rÀ ÚgetdocrÚ Úreversed)rN Ú
|
methodnamerå rà rà rÄ rO ° s
|
z_frommethod.__init__c C sN t t| jdpt t| jd}| jt| }|dk rJd|t |ddf }|S dS )ú<Return the doc of the function (from the doc of the method).Nz %s
|
%srÚ )r r rÀ ró rØ )rN ÚmethÚ signatureÚdocrà rà rÄ rä µ s ÿ
|
ÿz_frommethod.getdocc O s` | j r t|}|d | }|d< t|}| j}tt||d }|d krPtt|}||f||S r )rå rH r. rÀ r r6 ró )rN r0 rv rÜ ZmarrÚ method_nameÚmethodrà rà rÄ rW ¿ s
|
z_frommethod.__call__N)F)rÀ rÁ r rÚ rO rä rW rà rà rà rÄ rã ¥ s
|
|
|
rã )rå r r c C s t | } | j||||dS )z
|
)r rÚ r )rw rµ )r0 r` r rÚ r rà rà rÄ rµ ë s c C sú |dk rt dt| }t|}t||}t| }t|}t| trNt| }nt}tjddd" t ||t
|
||¡¡ |¡} W 5 Q R X | | ¡ t t | t¡¡¡}
|
|tk rÈ| jsºtS t ||
|
¡| _|
|
¡ rö| jsÚtS | jtkrê|
|
| _| j| j|
|
< | S )aÌ
|
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.
|
|
Examples
|
--------
|
>>> import numpy.ma as ma
|
>>> x = [11.2, -3.973, 0.801, -1.41]
|
>>> mask = [0, 0, 0, 1]
|
>>> masked_x = ma.masked_array(x, mask)
|
>>> masked_x
|
masked_array(data=[11.2, -3.973, 0.801, --],
|
mask=[False, False, False, True],
|
fill_value=1e+20)
|
>>> ma.power(masked_x, 2)
|
masked_array(data=[125.43999999999998, 15.784728999999999,
|
0.6416010000000001, --],
|
mask=[False, False, False, True],
|
fill_value=1e+20)
|
>>> y = [-0.5, 2, 0, 17]
|
>>> masked_y = ma.masked_array(y, mask)
|
>>> masked_y
|
masked_array(data=[-0.5, 2.0, 0.0, --],
|
mask=[False, False, False, True],
|
fill_value=1e+20)
|
>>> ma.power(masked_x, masked_y)
|
masked_array(data=[0.29880715233359845, 15.784728999999999, 1.0, --],
|
mask=[False, False, False, True],
|
fill_value=1e+20)
|
|
Nz 3-argument power not supported.rQ rr )r rX ru rW r r r6 ró rS r¼ rT r rB ru ro rE r r r rv rp rF r r+ r@ ) r0 rÜ Úthirdr
r rê ÚfaÚfbrÏ r1 rG rà rà rÄ r ò s2 +
|
|
|
&
|
|
c C sN t | ¡} |t jkr t| }t| tr:| j|||||dS | j|||dS dS )z)Function version of the eponymous method.©r r rñ r« r+ rª N)ró r. r rÍ r r r, ©r0 r r rñ r« r+ rà rà rÄ r, B s
|
|
|
|
ÿrÆ c C sX t j| ddd} |dkr$| ¡ } d}t| trD| j|||||d n| j|||d | S )a
|
Return a sorted copy of the masked array.
|
|
Equivalent to creating a copy of the array
|
and applying the MaskedArray ``sort()`` method.
|
|
Refer to ``MaskedArray.sort`` for the full documentation
|
|
See Also
|
--------
|
MaskedArray.sort : equivalent method
|
Tr> Nr rð rª )ró r
|
r² r r r® rñ rà rà rÄ r® Q s
|
|
ÿc C s t | ¡ S )a
|
Return all the non-masked data as a 1-D array.
|
|
This function is equivalent to calling the "compressed" method of a
|
`ma.MaskedArray`, see `ma.MaskedArray.compressed` for details.
|
|
See Also
|
--------
|
ma.MaskedArray.compressed : Equivalent method.
|
|
)r. r8 rÑ rà rà rÄ r8 k s c C sv t dd | D |¡}t| }| |¡}| D ]}t|tk r, qFq,|S t dd | D |¡}| |j¡}t||_ |S )aI
|
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)
|
|
c S s g | ] }t |qS rà )rW r7 rà rà rÄ rø £ s z concatenate.<locals>.<listcomp>c S s g | ] }t |qS rà r r7 rà rà rÄ rø s )
|
ró r9 r= rB rX r r¢ r¨ r rF )r: r rx r; rC rV Údmrà rà rÄ r9 z s )
|
|
c C s2 t | |¡ t¡}t| tk r.t | j|¡|_|S )a
|
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ó rD rB r rX r rF )rÉ r÷ r· rà rà rÄ rD ¶ s c C sJ t | }|tkr(t t| |¡}t|S t t| d|¡}t||dS dS )zÄ
|
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
|
|
r r¥ N)rX r rT rh rM rw ©r0 r rê rx rà rà rÄ rh È s c C sJ t | }|tkr(t t| |¡}t|S t t| d|¡}t||dS dS )zÇ
|
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
|
|
r r¥ N)rX r rT r¤ rM rw ró rà rà rÄ r¤ Ý s c C sD z| j |||dW S tk
|
r> t| ddj |||d Y S X dS )zÈ
|
Set storage-indexed locations to corresponding values.
|
|
This function is equivalent to `MaskedArray.put`, see that method
|
for details.
|
|
See Also
|
--------
|
MaskedArray.put
|
|
r Fr N)r rA r+ )r0 r` r r rà rà rÄ r ò s c C sÔ t | ts| t¡} t|t| }}t| tkrd|tk r¾d| _t| j| j | _
|
t j | j
|
||d nZ| j r|tk r¾| j
|
¡ }t j |||d | j|O _n"|tkr¬t|}t j | j
|
||d t j | j||d dS )aQ
|
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`.
|
|
Trs N)r r rB rW rX r rû rt r¨ r rF ró rt ré r< rD rY r@ )r0 rD r ZvaldataZvalmaskrê rà rà rÄ r s$
|
|
|
c C s> z | |¡W S tk
|
r8 t| dd |¡ t¡ Y S X dS )a
|
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)
|
Fr N)r¹ rA r+ rB r )r0 r rà rà rÄ r¹ , s r c C sJ z| j ||dW S tk
|
rD t| ddj ||d}| t¡ Y S X dS )zË
|
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 Fr N)r¢ rA r+ rB r )r0 Ú new_shaperñ Z_tmprà rà rÄ r¢ R s
|
c C sB t | }|tk r t ||¡}t | |¡ t| ¡}|jr>||_|S )a
|
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))
|
masked_array(
|
data=[[1, 2, 3],
|
[4, 1, 2],
|
[3, 4, 1]],
|
mask=False,
|
fill_value=999999)
|
>>> 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)
|
|
)rX r ró r£ rB r= r rF )rV rô rê r1 rà rà rÄ r£ e s 7 c C s t t| ¡S )z5
|
maskedarray version of the numpy function.
|
|
)ró r rW r rà rà rÄ r ¥ s c C s t t| ¡S ©ú*maskedarray version of the numpy function.)ró r¨ rW r rà rà rÄ r¨ ¯ s c C s t t| |¡S rõ )ró r« rW )rÖ r rà rà rÄ r« µ s c C s |t k|t kf d¡}|dkr&td|dkr6t| S t| d}t|}t|}t| }t|}t|} |tkr|tk rtj d|j
|
d}tj d| j
|
d}n0|tkrÊ|tk rÊtj d|j
|
d}tj d|j
|
d} t |||¡}
|
t ||| ¡} t |tj d| j
|
d| ¡} t | } t|
|
| dS ) a¡
|
Return a masked array with elements from `x` or `y`, depending on condition.
|
|
.. note::
|
When only `condition` is provided, this function is identical to
|
`nonzero`. The rest of this documentation covers only the case where
|
all three arguments are provided.
|
|
Parameters
|
----------
|
condition : array_like, bool
|
Where True, yield `x`, otherwise yield `y`.
|
x, y : array_like, optional
|
Values from which to choose. `x`, `y` and `condition` need to be
|
broadcastable to some shape.
|
|
Returns
|
-------
|
out : MaskedArray
|
An masked array with `masked` elements where the condition is masked,
|
elements from `x` where `condition` is True, and elements from `y`
|
elsewhere.
|
|
See Also
|
--------
|
numpy.where : Equivalent function in the top-level NumPy module.
|
nonzero : The function that is called when x and y are omitted
|
|
Examples
|
--------
|
>>> x = np.ma.array(np.arange(9.).reshape(3, 3), mask=[[0, 1, 0],
|
... [1, 0, 1],
|
... [0, 1, 0]])
|
>>> x
|
masked_array(
|
data=[[0.0, --, 2.0],
|
[--, 4.0, --],
|
[6.0, --, 8.0]],
|
mask=[[False, True, False],
|
[ True, False, True],
|
[False, True, False]],
|
fill_value=1e+20)
|
>>> np.ma.where(x > 5, x, -3.1416)
|
masked_array(
|
data=[[-3.1416, --, -3.1416],
|
[--, -3.1416, --],
|
[6.0, --, 8.0]],
|
mask=[[False, True, False],
|
[ True, False, True],
|
[False, True, False]],
|
fill_value=1e+20)
|
|
TrÅ z)Must provide both 'x' and 'y' or neither.r Frà r r¥ )r r@ r' r rM rW rY rv ró r½ r r r¼ r rw ) r´ rV r) Úmissingr¿ ZxdZydÚcmZxmZymrC rD rà rà rÄ r¼ À s, 8
|
c s¬ dd dd t | d}fdd|D } fdd|D }tj|||d }tt|t| d
|
d d }tj||||d t¡}|dk rt|tr| |¡ |S | |¡ |S )aH
|
Use an index array to construct a new array from a list of choices.
|
|
Given an array of integers and a list of n choice arrays, this method
|
will create a new array that merges each of the choice arrays. Where a
|
value in `index` is i, the new array will have the value that choices[i]
|
contains in the same place.
|
|
Parameters
|
----------
|
indices : 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 kr dS t| S )z,Returns the filled array, or True if masked.T)rv rM rÑ rà rà rÄ ÚfmaskH s zchoose.<locals>.fmaskc S s | t kr dS t| S )z:Returns the mask, True if ``masked``, False if ``nomask``.T)rv rX rÑ rà rà rÄ ÚnmaskN s zchoose.<locals>.nmaskr c s g | ] } |qS rà rà ©rö rV )rú rà rÄ rø V s zchoose.<locals>.<listcomp>c s g | ] } |qS rà rà rû )rù rà rÄ rø W s r FTr£ )r rÚ N)
|
rM ró r4 rr ru rX rB r r rÛ ) r` ÚchoicesrÚ r rÝ ÚmasksrC Z
|
outputmaskrx rà )rù rú rÄ r4 s" -
|
ÿ
|
|
|
c C sD |dkrt | ||¡S t t| ||¡ t|dr<t| |_|S dS )aµ
|
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!
|
|
Examples
|
--------
|
>>> import numpy.ma as ma
|
>>> x = [11.2, -3.973, 0.801, -1.41]
|
>>> mask = [0, 0, 0, 1]
|
>>> masked_x = ma.masked_array(x, mask)
|
>>> masked_x
|
masked_array(data=[11.2, -3.973, 0.801, --],
|
mask=[False, False, False, True],
|
fill_value=1e+20)
|
>>> ma.round_(masked_x)
|
masked_array(data=[11.0, -4.0, 1.0, --],
|
mask=[False, False, False, True],
|
fill_value=1e+20)
|
>>> ma.round(masked_x, decimals=1)
|
masked_array(data=[11.2, -4.0, 0.8, --],
|
mask=[False, False, False, True],
|
fill_value=1e+20)
|
>>> ma.round_(masked_x, decimals=-1)
|
masked_array(data=[10.0, -0.0, 0.0, --],
|
mask=[False, False, False, True],
|
fill_value=1e+20)
|
NrF )ró r¦ rW r rX rF )r0 r© rÚ rà rà rÄ r¦ f s .
|
|
c C s t | dd} | jdkr tdt| }|tks6| ¡ s:| S | ¡ }| j ¡ | _|sdt | t
|
|d ¡< |dkrt | dd
t
|
|d ¡f< | S ) aÞ
|
Mask rows and/or columns of a 2D array that contain masked values.
|
|
Mask whole rows and/or columns of a 2D array that contain
|
masked values. The masking behavior is selected using the
|
`axis` parameter.
|
|
- If `axis` is None, rows *and* columns are masked.
|
- If `axis` is 0, only rows are masked.
|
- If `axis` is 1 or -1, only columns are masked.
|
|
Parameters
|
----------
|
a : array_like, MaskedArray
|
The array to mask. If not a MaskedArray instance (or if no array
|
elements are masked). The result is a MaskedArray with `mask` set
|
to `nomask` (False). Must be a 2D array.
|
axis : int, optional
|
Axis along which to perform the operation. If None, applies to a
|
flattened version of the array.
|
|
Returns
|
-------
|
a : MaskedArray
|
A modified version of the input array, masked depending on the value
|
of the `axis` parameter.
|
|
Raises
|
------
|
NotImplementedError
|
If input array `a` is not 2D.
|
|
See Also
|
--------
|
mask_rows : Mask rows of a 2D array that contain masked values.
|
mask_cols : Mask cols of a 2D array that contain masked values.
|
masked_where : Mask where a condition is met.
|
|
Notes
|
-----
|
The input array's mask is modified by this function.
|
|
Examples
|
--------
|
>>> import numpy.ma as ma
|
>>> a = np.zeros((3, 3), dtype=int)
|
>>> a[1, 1] = 1
|
>>> a
|
array([[0, 0, 0],
|
[0, 1, 0],
|
[0, 0, 0]])
|
>>> a = ma.masked_equal(a, 1)
|
>>> a
|
masked_array(
|
data=[[0, 0, 0],
|
[0, --, 0],
|
[0, 0, 0]],
|
mask=[[False, False, False],
|
[False, True, False],
|
[False, False, False]],
|
fill_value=1)
|
>>> ma.mask_rowcols(a)
|
masked_array(
|
data=[[0, --, 0],
|
[--, --, --],
|
[0, --, 0]],
|
mask=[[False, True, False],
|
[ True, True, True],
|
[False, True, False]],
|
fill_value=1)
|
|
FrL r z&mask_rowcols works for 2D arrays only.r )NrÅ rÆ NrÅ ) r
|
r r rX r r r rF r< rv ró Úunique)r0 r rê Z maskedvalrà rà rÄ Ú mask_rowcols s I
|
rÿ c C s |r,| j dkr,|j dkr,t| d} t|d}t| }t| }|dkr t t| dt|d¡}t ||¡ }|j dkrt |¡}| t| |¡}| |¡ |S t t| dt|d|j
|
¡}|j j |j krÚt |j t¡|_t |||j¡ t |j|j¡ |S dS )a
|
Return the dot product of two arrays.
|
|
This function is the equivalent of `numpy.dot` that takes masked values
|
into account. Note that `strict` and `out` are in different position
|
than in the method version. In order to maintain compatibility with the
|
corresponding method, it is recommended that the optional arguments be
|
treated as keyword only. At some point that may be mandatory.
|
|
.. note::
|
Works only with 2-D arrays at the moment.
|
|
|
Parameters
|
----------
|
a, b : masked_array_like
|
Inputs arrays.
|
strict : bool, optional
|
Whether masked data are propagated (True) or set to 0 (False) for
|
the computation. Default is False. Propagating the mask means that
|
if a masked value appears in a row or column, the whole row or
|
column is considered masked.
|
out : masked_array, optional
|
Output argument. This must have the exact kind that would be returned
|
if it was not used. In particular, it must have the right type, must be
|
C-contiguous, and its dtype must be the dtype that would be returned
|
for `dot(a,b)`. This is a performance feature. Therefore, if these
|
conditions are not met, an exception is raised, instead of attempting
|
to be flexible.
|
|
.. versionadded:: 1.10.2
|
|
See Also
|
--------
|
numpy.dot : Equivalent function for ndarrays.
|
|
Examples
|
--------
|
>>> a = np.ma.array([[1, 2, 3], [4, 5, 6]], mask=[[1, 0, 0], [0, 0, 0]])
|
>>> b = np.ma.array([[1, 2], [3, 4], [5, 6]], mask=[[1, 0], [0, 0], [0, 0]])
|
>>> np.ma.dot(a, b)
|
masked_array(
|
data=[[21, 26],
|
[45, 64]],
|
mask=[[False, False],
|
[False, False]],
|
fill_value=999999)
|
>>> np.ma.dot(a, b, strict=True)
|
masked_array(
|
data=[[--, --],
|
[--, 64]],
|
mask=[[ True, True],
|
[ True, False]],
|
fill_value=999999)
|
|
r r rÅ N)r rÿ rY ró r rM r/ rB r= rÛ r@ rD r¨ rH r rF ro ) r0 rÜ r rÚ ÚamZbmrx rê r rà rà rÄ r ü s& ;
|
|
|
|
|
|
|
r c C sF t | d}t |d}|jdkr$d|_|jdkr4d|_t ||¡ t¡S )zÛ
|
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. The first argument is not conjugated.
|
|
r r )rM r r¨ ró ra rB r )r0 rÜ rî rï rà rà rÄ ra N s
|
|
|
|
z Masked values are replaced by 0.c C s t | d ¡ }t |d ¡ }t ||¡}t| }t|}|tkrP|tkrPt|S t| }t|}tdt d| d| ¡ dd}t||dS )rö r rÅ Fr r¥ ) rM r ró r rX r rw rY rr )r0 rÜ rî rï rx r
r rê rà rà rÄ r b s c C s |r`| t |tjt |¡td|d| tjt |¡tdt ||dB }| t|t||d}n2| t | t | }| t|dt|d|d}t||dS )z:
|
Helper function for ma.correlate and ma.convolve
|
r r r r¥ )rY ró r r¨ r¯ rW rM rw )rÞ r0 rÉ r Úpropagate_maskrD rC rà rà rÄ Ú_convolve_or_correlatet s ÿÿr Úvalidc C s t tj| |||S )aä
|
Cross-correlation of two 1-dimensional sequences.
|
|
Parameters
|
----------
|
a, v : array_like
|
Input sequences.
|
mode : {'valid', 'same', 'full'}, optional
|
Refer to the `np.convolve` docstring. Note that the default
|
is 'valid', unlike `convolve`, which uses 'full'.
|
propagate_mask : bool
|
If True, then a result element is masked if any masked element contributes towards it.
|
If False, then a result element is only masked if no non-masked element
|
contribute towards it
|
|
Returns
|
-------
|
out : MaskedArray
|
Discrete cross-correlation of `a` and `v`.
|
|
See Also
|
--------
|
numpy.correlate : Equivalent function in the top-level NumPy module.
|
)r ró r= ©r0 rÉ r r rà rà rÄ r= s r c C s t tj| |||S )aÊ
|
Returns the discrete, linear convolution of two one-dimensional sequences.
|
|
Parameters
|
----------
|
a, v : array_like
|
Input sequences.
|
mode : {'valid', 'same', 'full'}, optional
|
Refer to the `np.convolve` docstring.
|
propagate_mask : bool
|
If True, then if any masked element is included in the sum for a result
|
element, then the result is masked.
|
If False, then the result element is only masked if no non-masked cells
|
contribute towards it
|
|
Returns
|
-------
|
out : MaskedArray
|
Discrete, linear convolution of `a` and `v`.
|
|
See Also
|
--------
|
numpy.convolve : Equivalent function in the top-level NumPy module.
|
)r ró r; r rà rà rÄ r; £ s c C s t t| t|}|tkr>t| }t|}t ||¡}| ¡ S |r|t| }t|}t ||¡}t||dd}| d¡ d¡S dS dS )a
|
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 = np.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 = np.array([1e10, 1e-7, -42.0])
|
>>> b
|
array([ 1.00000000e+10, 1.00000000e-07, -4.20000000e+01])
|
>>> np.ma.allequal(a, b, fill_value=False)
|
False
|
>>> np.ma.allequal(a, b)
|
True
|
|
F)rD r< TN) ru rX r rW rT rJ r r
|
rM )r0 rÜ r+ rê rV r) rx rò rà rà rÄ r ¿ s * c C s, t | dd}t |dd}|jjdkrHt |d¡}|j|krHt ||dd}tt|t|}t t |d|d¡ d¡} t | tt |¡dk¡sdS t
|
| ¡sÊtt t || ||t | |}
|
t |
|
¡S t t|| || k|¡sêdS || }|| }tt t || ||t | |}
|
t |
|
¡S )aL
|
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.
|
|
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 = np.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 = np.ma.array([1e10, 1e-8, -42.0], mask=[0, 0, 1])
|
>>> np.ma.allclose(a, b)
|
False
|
|
>>> a = np.ma.array([1e10, 1e-8, 42.0], mask=[0, 0, 1])
|
>>> b = np.ma.array([1.00001e10, 1e-9, -42.0], mask=[0, 0, 1])
|
>>> np.ma.allclose(a, b)
|
True
|
>>> np.ma.allclose(a, b, masked_equal=False)
|
False
|
|
Masked values are not compared directly.
|
|
>>> a = np.ma.array([1e10, 1e-8, 42.0], mask=[0, 0, 1])
|
>>> b = np.ma.array([1.00001e10, 1e-9, 42.0], mask=[0, 0, 1])
|
>>> np.ma.allclose(a, b)
|
True
|
>>> np.ma.allclose(a, b, masked_equal=False)
|
False
|
|
Fr rê r )r r< )r< rD ) rw r r ró Z result_typeru rX ÚisinfrM r r rj r ) r0 rÜ rx r¾ r½ rV r) r rê Zxinfrx rà rà rÄ r ù s. H
|
|
ÿ
|
|
|
ÿc C s |pd}t | |ddd|dS )aí
|
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))
|
<class 'numpy.ma.core.MaskedArray'>
|
|
r FT)r r< rü r? rñ ©rw )r0 r rñ rà rà rÄ r/ e s
|
,
|
ÿc C s2 t | tr |dks || jkr | S t| |ddddS )ae
|
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))
|
<class 'numpy.ma.core.MaskedArray'>
|
|
NFT)r r< rü r? )r r r rw )r0 r rà rà rÄ r. s , rÎ c C s t dd S )Nz1fromfile() not yet implemented for a MaskedArray.r" )Úfiler r@ rº rà rà rÄ ÚfromfileÌ s ÿr c C s t | d | d dS )aÕ
|
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', '<i8'), ('_mask', '?')])
|
>>> 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', '<i4'), ('_mask', '|b1'), ('field3', '<f4')]
|
>>> rec2 = np.zeros((2, 2), dtype=dt)
|
>>> rec2
|
array([[(0, False, 0.), (0, False, 0.)],
|
[(0, False, 0.), (0, False, 0.)]],
|
dtype=[('_data', '<i4'), ('_mask', '?'), ('field3', '<f4')])
|
>>> y = np.ma.fromflex(rec2)
|
>>> y
|
masked_array(
|
data=[[0, 0],
|
[0, 0]],
|
mask=[[False, False],
|
[False, False]],
|
fill_value=999999,
|
dtype=int32)
|
|
r@ rF r¥ r )Zfxarrayrà rà rÄ rU Ñ s =c @ s6 e Zd ZdZdZd ddZdd Zdd Zd d
|
ZdS ) Ú _convert2maz
|
Convert functions from numpy to numpy.ma.
|
|
Parameters
|
----------
|
_methodname : string
|
Name of the method to transform.
|
|
Nc C s( t t|| _| ||¡| _|p i | _d S rý )r ró Ú_funcrä rÚ Ú_extras)rN rÞ Únp_retÚ np_ma_retrÜ rà rà rÄ rO s z_convert2ma.__init__c C sJ t | jdd}t| j}|rF| |||¡}|r>d| jj|f }|| }|S )rç rÚ Nz%s%s
|
)r r
|
rØ Ú_replace_return_typerÀ )rN r r rê r× rà rà rÄ rä # s
|
z_convert2ma.getdocc C sD ||kr8t d| d| d| d| jj d| jj d | ||¡S )a
|
Replace documentation of ``np`` function's return type.
|
|
Replaces it with the proper type for the ``np.ma`` function.
|
|
Parameters
|
----------
|
doc : str
|
The documentation of the ``np`` method.
|
np_ret : str
|
The return type string of the ``np`` method that we want to
|
replace. (e.g. "out : ndarray")
|
np_ma_ret : str
|
The return type string of the ``np.ma`` method.
|
(e.g. "out : MaskedArray")
|
zFailed to replace `z` with `z-`. The documentation string for return type, z(, is not found in the docstring for `np.z `. Fix the docstring for `np.z0` or update the expected string for return type.)r r
|
rÀ Úreplace)rN rê r r rà rà rÄ r / s
|
*ÿz _convert2ma._replace_return_typec O st | j }t| |¡}|D ]}| |¡||< q| jj|| t¡}d|krV| dd ¡|_ d|krpt
|
| dd¡|_ |S )Nr+ rç rý F) r ÚsetÚ intersectionÚpopr
|
rW rB r r r+ r¯ ré )rN rv rÜ r Z common_paramsÚpr1 rà rà rÄ rW K s z_convert2ma.__call__)N)rÀ rÁ r rÚ rO rä r rW rà rà rà rÄ r s
|
r )r+ rç zarange : ndarrayzarange : MaskedArray)rÜ r r zclipped_array : ndarrayzclipped_array : MaskedArrayzdiff : ndarrayzdiff : MaskedArrayz out : ndarrayzout : MaskedArray)r r zout: MaskedArrayzfromfunction : anyzfromfunction: MaskedArrayz'grid : one ndarray or tuple of ndarraysz/grid : one MaskedArray or tuple of MaskedArrayszsqueezed : ndarrayzsqueezed : MaskedArrayc C s t | |g|S )a Append values to the end of an array.
|
|
.. versionadded:: 1.9.0
|
|
Parameters
|
----------
|
a : array_like
|
Values are appended to a copy of this array.
|
b : array_like
|
These values are appended to a copy of `a`. It must be of the
|
correct shape (the same shape as `a`, excluding `axis`). If `axis`
|
is not specified, `b` can be any shape and will be flattened
|
before use.
|
axis : int, optional
|
The axis along which `v` are appended. If `axis` is not given,
|
both `a` and `b` are flattened before use.
|
|
Returns
|
-------
|
append : MaskedArray
|
A copy of `a` with `b` appended to `axis`. Note that `append`
|
does not occur in-place: a new array is allocated and filled. If
|
`axis` is None, the result is a flattened array.
|
|
See Also
|
--------
|
numpy.append : Equivalent function in the top-level NumPy module.
|
|
Examples
|
--------
|
>>> import numpy.ma as ma
|
>>> a = ma.masked_values([1, 2, 3], 2)
|
>>> b = ma.masked_values([[4, 5, 6], [7, 8, 9]], 7)
|
>>> ma.append(a, b)
|
masked_array(data=[1, --, 3, 4, 5, 6, --, 8, 9],
|
mask=[False, True, False, False, False, False, True, False,
|
False],
|
fill_value=999999)
|
)r9 )r0 rÜ r rà rà rÄ r! ¬ s ()N)T)N)FT)T)T)T)T)T)T)T)T)T)TT)r» r¼ TT)T)T)NNr )N)rÆ NNTN)r )r )r )N)r )N)Nr )r N)N)FN)r T)r T)T)Tr» r¼ )NN)N)N( rÚ rI rÑ rM rÊ ÚtextwraprÏ Ú functoolsr Únumpyró Znumpy.core.umathrC rT Znumpy.core.numerictypesZ numerictypesr Z
|
numpy.corer r r r r r r r r
|
r+ Znumpy.lib.function_baser Z numpy.compatr r r r r r Znumpy.core.numericr Ú__all__r r r× r¿ rÍ rÔ rØ r r r r rÉ Z
|
datetime64Z timedelta64ZhalfZsingleÚdoubleZ
|
longdoubleZcsingleZcdoubleZ clongdoubleZfloat_types_listZ_minvalsr r Z_maxvalsr rþ r rC r r r r r. r§ r2 r6 rM r= rW Úget_datarN rK rm rn rL rY r] r` rd re ri r| r rK r: r© r> r' r& rª r? r· r r rL r rQ r3 r¦ r- ro r¯ rk rm rl r¶ r% r# r$ r) r r² r r( rJ r rj r[ ri rZ rn r rp r rq r0 r1 r2 r] rG rº rR r rS r r r rs rX Zget_maskrY re r rr rt r ru rO r± r
ry rz r} r~ r rx r{ r r r r| rÅ r rÏ r5 ÚdedentrD rÐ rP rá râ r rÅ r rd rg rc r8 rv r rw rf rÞ r r r rã r r r r r7 rA rB r< rE r\ r_ r r r r r r r r¡ r r¬ r± r³ r´ r¸ r» r@ rµ r r+ r* r, r® r8 r9 rD rh r¤ r r r¹ r¢ r£ r r¨ r« r¼ r4 r¥ rÿ r ra rb r r r r= r; r r r/ r. r_ r rU r r" r5 rF rH rI rT rV r^ r` r r r° r½ r¾ r! rà rà rà rÄ Ú<module> s¨ ß$ ø ÿ
|
733 ,A 9 3:
|
|
J L
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ÿ
|
ÿ
|
ÿ
|
ÿ
|
ÿ
|
ÿ
|
ÿ
|
ÿ
|
ÿ
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ÿ ÿ ÿ
|
!
|
;
|
5
|
D
|
Y2
|
8
|
8 z ((DH(0
|
|
|
|
|
ë"
|
7-l ;
|
|
3t
|
þ
|
:C
|
|
|
|
|
)
|
M
|
|
<
|
|
|
'&
|
@
|
|
|
|
|
[K5\R
|
ÿ
|
ÿ :l16 @Jü
|
ü
|
ü
|
ü
|
ý
|
ý
|
ý
|
ü
|
ü
|
ü
|
ý
|
ü
|
ü
|
ý
|
|
