Ë
|
Kñúh@ ã ót d Z g d¢ZddlZddlZddlZddlmZ ddlmZ ddl m
|
Z
|
ddl m Z ddl mZmZ d d
|
lmZ d d lmZmZmZmZmZmZmZmZmZmZm Z m Z m Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z& d Z'dNd Z(e)fdZ*d Z+ G d d« Z, G d de,« Z- G d de,« Z. G d de,« Z/ G d de,« Z0 e0d« Z1 e0d« Z2 e0d « Z3 e.d « xZ4Z5 e.d « Z6 e.d « Z7 e.d « Z8 e.d!« Z9 e-d"« Z: e-d#« Z;d$ Z<d% Z=ejz j e=_ d& Z>e>j Rej| j dej| j j d'« j « d(z e>_ dOej d)d*ZBdPd+ZCdOd,ZDdNd-ZEdNd.ZFd/ ZGd0 ZHdNd1ZIej fd2ZJej fd3ZKdQd4ZLdRd5ZMdSd6ZNdSd7ZOdRd8ZPdRd9ZQd: ZRdSd;ZSdTd=ZTdUd>ZUdd<ej d<ej fd?ZV G d@ dAe « ZW G dB dCeW« ZX eX« ZYdVdDZZdE Z[dNdFZ\dG Z]dNdHZ^dI Z_dJ Z`dK ZadNdLZb ejÆ ejÄ j ebj « eb_ dWdMZd ejÆ ejÈ j edj « ed_ y)Xz
|
Masked arrays add-ons.
|
|
A collection of utilities for `numpy.ma`.
|
|
:author: Pierre Gerard-Marchant
|
:contact: pierregm_at_uga_dot_edu
|
|
).Úapply_along_axisÚapply_over_axesÚ
|
atleast_1dÚ
|
atleast_2dÚ
|
atleast_3dÚaverageÚ clump_maskedÚclump_unmaskedÚ column_stackÚ compress_colsÚ compress_ndÚcompress_rowcolsÚ compress_rowsÚ count_maskedÚcorrcoefÚcovÚdiagflatÚdotÚdstackÚediff1dÚflatnotmasked_contiguousÚflatnotmasked_edgesÚhsplitÚhstackÚisinÚin1dÚ intersect1dÚ mask_colsÚ mask_rowcolsÚ mask_rowsÚ
|
masked_allÚmasked_all_likeÚmedianÚmr_Ú ndenumerateÚnotmasked_contiguousÚnotmasked_edgesÚpolyfitÚ row_stackÚ setdiff1dÚsetxor1dÚstackÚuniqueÚunion1dÚvanderÚvstacké N)Úarray)Úndarray)Ú_ureduce)ÚAxisConcatenator)Únormalize_axis_indexÚnormalize_axis_tupleé )Úcore)ÚMAErrorÚ MaskedArrayÚaddr1 ÚasarrayÚ concatenateÚcountr ÚfilledÚget_masked_subclassÚgetdataÚgetmaskÚ getmaskarrayÚmake_mask_descrÚmask_orÚmaskedÚ masked_arrayÚnomaskÚonesÚsortÚzerosc ó8 t | t t t f« S )z6
|
Is seq a sequence (ndarray, list or tuple)?
|
|
)Ú
|
isinstancer2 ÚtupleÚlist)Úseqs úBH:\Change_password\venv_build\Lib\site-packages\numpy/ma/extras.pyÚ
|
issequencerR : s ô
|
cG¤U¬DÐ1Ó 2Ð2ó c ó: t | « }|j |« S )aÄ
|
Count the number of masked elements along the given axis.
|
|
Parameters
|
----------
|
arr : array_like
|
An array with (possibly) masked elements.
|
axis : int, optional
|
Axis along which to count. If None (default), a flattened
|
version of the array is used.
|
|
Returns
|
-------
|
count : int, ndarray
|
The total number of masked elements (axis=None) or the number
|
of masked elements along each slice of the given axis.
|
|
See Also
|
--------
|
MaskedArray.count : Count non-masked elements.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> a = np.arange(9).reshape((3,3))
|
>>> a = np.ma.array(a)
|
>>> a[1, 0] = np.ma.masked
|
>>> a[1, 2] = np.ma.masked
|
>>> a[2, 1] = np.ma.masked
|
>>> a
|
masked_array(
|
data=[[0, 1, 2],
|
[--, 4, --],
|
[6, --, 8]],
|
mask=[[False, False, False],
|
[ True, False, True],
|
[False, True, False]],
|
fill_value=999999)
|
>>> np.ma.count_masked(a)
|
3
|
|
When the `axis` keyword is used an array is returned.
|
|
>>> np.ma.count_masked(a, axis=0)
|
array([1, 1, 1])
|
>>> np.ma.count_masked(a, axis=1)
|
array([0, 2, 1])
|
|
)rC Úsum)ÚarrÚaxisÚms rQ r r B s ôd SÓAØ 55;ÐrS c ó t t j | |« t j | t |« « ¬« }|S )aÛ
|
Empty masked array with all elements masked.
|
|
Return an empty masked array of the given shape and dtype, where all the
|
data are masked.
|
|
Parameters
|
----------
|
shape : int or tuple of ints
|
Shape of the required MaskedArray, e.g., ``(2, 3)`` or ``2``.
|
dtype : dtype, optional
|
Data type of the output.
|
|
Returns
|
-------
|
a : MaskedArray
|
A masked array with all data masked.
|
|
See Also
|
--------
|
masked_all_like : Empty masked array modelled on an existing array.
|
|
Notes
|
-----
|
Unlike other masked array creation functions (e.g. `numpy.ma.zeros`,
|
`numpy.ma.ones`, `numpy.ma.full`), `masked_all` does not initialize the
|
values of the array, and may therefore be marginally faster. However,
|
the values stored in the newly allocated array are arbitrary. For
|
reproducible behavior, be sure to set each element of the array before
|
reading.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> np.ma.masked_all((3, 3))
|
masked_array(
|
data=[[--, --, --],
|
[--, --, --],
|
[--, --, --]],
|
mask=[[ True, True, True],
|
[ True, True, True],
|
[ True, True, True]],
|
fill_value=1e+20,
|
dtype=float64)
|
|
The `dtype` parameter defines the underlying data type.
|
|
>>> a = np.ma.masked_all((3, 3))
|
>>> a.dtype
|
dtype('float64')
|
>>> a = np.ma.masked_all((3, 3), dtype=np.int32)
|
>>> a.dtype
|
dtype('int32')
|
|
©Úmask)rG ÚnpÚemptyrI rD )ÚshapeÚdtypeÚas rQ r r x s5 ôp RXXe UÓ+Ü '' %¬ ¸Ó)?Ó@ô BAà HrS c óÈ t j | « j t « }t j |j
|
t |j « ¬« |_ |S )aG
|
Empty masked array with the properties of an existing array.
|
|
Return an empty masked array of the same shape and dtype as
|
the array `arr`, where all the data are masked.
|
|
Parameters
|
----------
|
arr : ndarray
|
An array describing the shape and dtype of the required MaskedArray.
|
|
Returns
|
-------
|
a : MaskedArray
|
A masked array with all data masked.
|
|
Raises
|
------
|
AttributeError
|
If `arr` doesn't have a shape attribute (i.e. not an ndarray)
|
|
See Also
|
--------
|
masked_all : Empty masked array with all elements masked.
|
|
Notes
|
-----
|
Unlike other masked array creation functions (e.g. `numpy.ma.zeros_like`,
|
`numpy.ma.ones_like`, `numpy.ma.full_like`), `masked_all_like` does not
|
initialize the values of the array, and may therefore be marginally
|
faster. However, the values stored in the newly allocated array are
|
arbitrary. For reproducible behavior, be sure to set each element of the
|
array before reading.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> arr = np.zeros((2, 3), dtype=np.float32)
|
>>> arr
|
array([[0., 0., 0.],
|
[0., 0., 0.]], dtype=float32)
|
>>> np.ma.masked_all_like(arr)
|
masked_array(
|
data=[[--, --, --],
|
[--, --, --]],
|
mask=[[ True, True, True],
|
[ True, True, True]],
|
fill_value=np.float64(1e+20),
|
dtype=float32)
|
|
The dtype of the masked array matches the dtype of `arr`.
|
|
>>> arr.dtype
|
dtype('float32')
|
>>> np.ma.masked_all_like(arr).dtype
|
dtype('float32')
|
|
©r_ ) r\ Ú
|
empty_likeÚviewr: rI r^ rD r_ Ú_mask)rV r` s rQ r! r! µ sB ôv cÓ× Ñ ¤ Ó,AÜggagg¤_°Q·W±WÓ%=Ô>AGØ HrS c ó" e Zd ZdZd Zd Zd Zy)Ú_fromnxfunctionaV
|
Defines a wrapper to adapt NumPy functions to masked arrays.
|
|
|
An instance of `_fromnxfunction` can be called with the same parameters
|
as the wrapped NumPy function. The docstring of `newfunc` is adapted from
|
the wrapped function as well, see `getdoc`.
|
|
This class should not be used directly. Instead, one of its extensions that
|
provides support for a specific type of input should be used.
|
|
Parameters
|
----------
|
funcname : str
|
The name of the function to be adapted. The function should be
|
in the NumPy namespace (i.e. ``np.funcname``).
|
|
c óJ || _ || _ | j « | _ y ©N)Ú__name__Ú __qualname__ÚgetdocÚ__doc__)ÚselfÚfuncnames rQ Ú__init__z_fromnxfunction.__init__ s Ø Ø $ÔØ{{} rS c óà t t | j d« }t |dd« }|rDt j |« }t j
|
|d« }|r| j |z dz }||z S y)aK
|
Retrieve the docstring and signature from the function.
|
|
The ``__doc__`` attribute of the function is used as the docstring for
|
the new masked array version of the function. A note on application
|
of the function to the mask is appended.
|
|
Parameters
|
----------
|
None
|
|
Nrm z@The function is applied to both the _data and the _mask, if any.z
|
|
)Úgetattrr\ rj ÚmaÚget_object_signatureÚdoc_note)rn ÚnpfuncÚdocÚsigs rQ rl z_fromnxfunction.getdoc so ô T]]¨DÓ1Üfi¨Ó.Ù Ü×)Ñ)¨&Ó1CÜ++cð $<ó =CáØmm cÑ)¨FÑ2Ø9Ð ØrS c ó y ri © )rn ÚargsÚparamss rQ Ú__call__z_fromnxfunction.__call__) s Ø rS N)rj Ú
|
__module__rk rm rp rl r} rz rS rQ rg rg ø s ñò&%ò
|
ó0 rS rg c ó e Zd ZdZd Zy)Ú_fromnxfunction_singlez²
|
A version of `_fromnxfunction` that is called with a single array
|
argument followed by auxiliary args that are passed verbatim for
|
both the data and mask calls.
|
c óP t t | j « }t |t « r< ||j « g|¢i |¤} |t |« g|¢i |¤}t ||¬« S |t j |« g|¢i |¤} |t |« g|¢i |¤}t ||¬« S )NrZ ) rr r\ rj rM r2 Ú __array__rC rG r< ©rn Úxr{ r| ÚfuncÚ_dÚ_ms rQ r} z _fromnxfunction_single.__call__3 s Ür4==Ó)Ü aÔ !ÙakkmÐ5 dÒ5¨fÑ5BÙl 1oÐ7¨Ò7°Ñ7BÜ ¨Ô,Ð ,ábjj mÐ5 dÒ5¨fÑ5BÙl 1oÐ7¨Ò7°Ñ7BÜ ¨Ô,Ð ,rS N©rj r~ rk rm r} rz rS rQ r r - s ñó
|
-rS r c ó e Zd ZdZd Zy)Ú_fromnxfunction_seqz¶
|
A version of `_fromnxfunction` that is called with a single sequence
|
of arrays followed by auxiliary args that are passed verbatim for
|
both the data and mask calls.
|
c óÀ t t | j « } |t d |D « « g|¢i |¤} |t d |D « « g|¢i |¤}t ||¬« S )Nc 3 óF K | ] }t j |« y wri )r\ r< ©Ú.0r` s rQ ú <genexpr>z/_fromnxfunction_seq.__call__.<locals>.<genexpr>G s è ø Ò1¨!
|
|
1 Ñ1ùs !c 3 ó2 K | ] }t |« y wri )rC r s rQ r z/_fromnxfunction_seq.__call__.<locals>.<genexpr>H s è ø Ò3¨A QÑ3ùs rZ )rr r\ rj rN rG r s rQ r} z _fromnxfunction_seq.__call__E s] Ür4==Ó)Ù %Ñ1¨qÔ1Ó1Ð C°DÒ C¸FÑ CÙ %Ñ3°Ô3Ó3Ð E°dÒ E¸fÑ EÜB RÔ(Ð(rS Nr rz rS rQ r r ? s ñó
|
)rS r c ó e Zd ZdZd Zy)Ú_fromnxfunction_argsa
|
A version of `_fromnxfunction` that is called with multiple array
|
arguments. The first non-array-like input marks the beginning of the
|
arguments that are passed verbatim for both the data and mask calls.
|
Array arguments are processed independently and the results are
|
returned in a list. If only one array is found, the return value is
|
just the processed array instead of a list.
|
c óÞ t t | j « }g }t |« }t |« dkD rKt |d « r=|j |j d« « t |« dkD rt |d « r=g }|D ]R } |t j |« g|¢i |¤} |t |« g|¢i |¤}|j t ||¬« « T t |« dk( r|d S |S )Nr0 rZ r7 ) rr r\ rj rO ÚlenrR ÚappendÚpopr< rC rG ) rn r{ r| r
ÚarraysÚresr r r s rQ r} z _fromnxfunction_args.__call__U sÙ Ür4==Ó)ØÜDzÜ$i!m¤
|
¨4°©7Ô 3Ø MM$(( 1+Ô &ô $i!m¤
|
¨4°©7Õ 3àØò 2AÙbjj mÐ5 dÒ5¨fÑ5BÙl 1oÐ7¨Ò7°Ñ7BØ JJ| B¨RÔ0Õ 1ð 2ô v;!Ò Øq6MØ
|
rS Nr rz rS rQ r r L s ñó rS r c ó e Zd ZdZd Zy)Ú_fromnxfunction_allargsa
|
A version of `_fromnxfunction` that is called with multiple array
|
arguments. Similar to `_fromnxfunction_args` except that all args
|
are converted to arrays even if they are not so already. This makes
|
it possible to process scalars as 1-D arrays. Only keyword arguments
|
are passed through verbatim for the data and mask calls. Arrays
|
arguments are processed independently and the results are returned
|
in a list. If only one arg is present, the return value is just the
|
processed array instead of a list.
|
c ó t t | j « }g }|D ]L } |t j |« fi |¤} |t |« fi |¤}|j t ||¬« « N t |« dk( r|d S |S )NrZ r7 r0 )rr r\ rj r< rC r rG r )rn r{ r| r
r r r r s rQ r} z _fromnxfunction_allargs.__call__p s~ Ür4==Ó)ØØò 2AÙbjj mÑ. vÑ.BÙl 1oÑ0¨Ñ0BØ JJ| B¨RÔ0Õ 1ð 2ô t9>Øq6MØ
|
rS Nr rz rS rQ r r e s ñ ó rS r r r r r/ r r
|
r r+ r r c ó¢ d}|t | « k7 r>t | | d« r| | | ||dz t | | d« r|dz }|t | « k7 r>| S )z Flatten a sequence in place.r0 Ú__iter__r7 )r Úhasattr)rP Úks rQ Úflatten_inplacer s` à AØ C=Üc!fjÔ)Ø VC1q5Nô c!fjÕ)à Qð C=ð JrS c ó^ t |dd¬« }|j }t ||« }dg|dz
|
z }t j |d« }t t |« « }|j |« t dd« ||< t j |j « j |« } |j ||« | |t |j « « g|¢i |¤}
|
t j |
|
« } | s t! |
|
« g } | r0| j% t j |
|
« j& « t | t( « } |
|
| t |« < t j* | « }d}||k r¨|dxx dz cc< d}|| | | k\ r6|d|z
|
kD r.||dz
|
xx dz cc< d||< |dz }|| | | k\ r |d|z
|
kD r.|j ||« | |t |j « « g|¢i |¤}
|
|
|
| t |« < | j% t |
|
« j& « |dz }||k rÅnát |
|
dd¬« }
|
|j- « }t dd« g|
|
j z ||< |j ||« t j* | « }| }t |j « } |
|
j | |< | j% t |
|
« j& « t/ | « } t | t( « } |
|
| t t/ |j « « « < d}||k rî|dxx dz cc< d}|| || k\ r6|d|z
|
kD r.||dz
|
xx dz cc< d||< |dz }|| || k\ r |d|z
|
kD r.|j ||« |j ||« | |t |j « « g|¢i |¤}
|
|
|
| t t/ |j « « « < | j% t |
|
« j& « |dz }||k rît j& t j | « j1 « « }t3 |d « st j | |¬
|
« }|S t | |¬
|
« }t5 j6 |« |_ |S # t" $ r d} Y ¨w xY w) z0
|
(This docstring should be overwritten)
|
FT)ÚcopyÚsubokr0 r7 ÚONéÿÿÿÿre rb ) r1 Úndimr5 r\ rK rO ÚrangeÚremoveÚslicer< r^ ÚtakeÚputrN ÚtolistÚisscalarr Ú TypeErrorr r_ ÚobjectÚprodr¢ r Úmaxr rs Údefault_fill_valueÚ
|
fill_value)Úfunc1drW rV r{ ÚkwargsÚndÚindÚiÚindlistÚoutshaper ÚasscalarÚdtypesÚoutarrÚNtotr ÚnÚjÚ holdshapeÚ
|
max_dtypesÚresults rQ r r s; ô % tÔ
|
,CØ BÜ bÓ )DØ #a.CÜ
|
SÓAÜ59oGØ NN4ÔÜD$Ó AdGÜzz#))Ó$×)Ñ)¨'Ó2HØEE'3ÔÙ
|
U188:Ó&Ñ'Ð
|
9¨$Ò
|
9°&Ñ
|
9Cä{{3Ó HÙ ð Ü Hð FÚØ bjj o×+Ñ+Ô,Üx¤Ó(Ø uSzÑÜwwxÓ Ø Ø$hà GqLGØAØq6X a[Ò(¨q°A¸±Fª|ØAE
|
a
|
ØAØQð q6X a[Ò(¨q°A¸±F«|ð EE'3Ô ÙU 1§8¡8£:Ó .Ñ/ÐA°$ÒA¸&ÑACØ!$F5:Ñ Ø MM' #,×,Ñ,Ô -Ø FAð $hô Ce¨4Ô0Ø FFHÜ$ Ó%Ð&¨¯©Ñ1$Ø gsÔÜwwxÓ Ø Ü ?Ø Ø gcl×(Ñ(Ô)Ü" 8Ó,Üx¤Ó(Ø58u_ Q§X¡X£ZÓ0Ó1Ñ2Ø Ø$hà GqLGØAØq6Y q\Ò)°°Q¸±V² ØAE
|
a
|
ØAØQð q6Y q\Ò)°°Q¸±V³ ð EE'3Ô Ø EE'3Ô ÙU 1§8¡8£:Ó .Ñ/ÐA°$ÒA¸&ÑACØ9<F5 ¨¯©«Ó4Ó5Ñ 6Ø MM' #,×,Ñ,Ô -Ø FAð $hô "** VÓ,×0Ñ0Ó2Ó3JÜ 3Ô ÜF¨*Ô5ð Mô zÔ2Ü × 1Ñ 1°&Ó 9ÔØ Møôw ò ØHð ús Ã8 R Ò R,Ò+R,c óN t |« }|j }t |« j dk( r|f}|D ]m }|dk r||z }||f} | | }|j |j k( r|}2t j ||« }|j |j k( r|}dt d« |S )z.
|
(This docstring will be overwritten)
|
r0 z7function is not returning an array of the correct shape)r< r¦ r1 rs Ú expand_dimsÚ
|
ValueError)r
r` ÚaxesÚvalÚNrW r{ r s rQ r r í s³ ô !*CØ AÜ T{×Ñ1Ò ØwØò 9Ø !8Øt8DØT{ÙDkØ 88sxxÒ ØCä.. dÓ+CØxx388Ò#Øä ð "8ó 9ð 9ð 9ð JrS ÚNotesa
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> a = np.ma.arange(24).reshape(2,3,4)
|
>>> a[:,0,1] = np.ma.masked
|
>>> a[:,1,:] = np.ma.masked
|
>>> a
|
masked_array(
|
data=[[[0, --, 2, 3],
|
[--, --, --, --],
|
[8, 9, 10, 11]],
|
[[12, --, 14, 15],
|
[--, --, --, --],
|
[20, 21, 22, 23]]],
|
mask=[[[False, True, False, False],
|
[ True, True, True, True],
|
[False, False, False, False]],
|
[[False, True, False, False],
|
[ True, True, True, True],
|
[False, False, False, False]]],
|
fill_value=999999)
|
>>> np.ma.apply_over_axes(np.ma.sum, a, [0,2])
|
masked_array(
|
data=[[[46],
|
[--],
|
[124]]],
|
mask=[[[False],
|
[ True],
|
[False]]],
|
fill_value=999999)
|
|
Tuple axis arguments to ufuncs are equivalent:
|
|
>>> np.ma.sum(a, axis=(0,2)).reshape((1,-1,1))
|
masked_array(
|
data=[[[46],
|
[--],
|
[124]]],
|
mask=[[[False],
|
[ True],
|
[False]]],
|
fill_value=999999)
|
)Úkeepdimsc ó> t « t « }t j d¬« |t j
|
u ri }nd|i}|? j fi |¤}|j j j « « }nÃt |« } t j j t j t j f« r,t j j | j d« }
|
n*t j j | j « }
|
j | j k7 r t d« | j t! fdD « « k7 r t# d« | j% t j& « « } | j) t! fdt+ j « D « « « } |t, ur/| j. z } | xj. j. z c_ | j0 d |
|
d |¤} t j2 | |
|
¬
|
« j0 fi |¤|z }|rK|j |j k7 r.t j4 ||j « j7 « }||fS |S ) aK
|
Return the weighted average of array over the given axis.
|
|
Parameters
|
----------
|
a : array_like
|
Data to be averaged.
|
Masked entries are not taken into account in the computation.
|
axis : None or int or tuple of ints, optional
|
Axis or axes along which to average `a`. The default,
|
`axis=None`, will average over all of the elements of the input array.
|
If axis is a tuple of ints, averaging is performed on all of the axes
|
specified in the tuple instead of a single axis or all the axes as
|
before.
|
weights : array_like, optional
|
An array of weights associated with the values in `a`. Each value in
|
`a` contributes to the average according to its associated weight.
|
The array of weights must be the same shape as `a` if no axis is
|
specified, otherwise the weights must have dimensions and shape
|
consistent with `a` along the specified axis.
|
If `weights=None`, then all data in `a` are assumed to have a
|
weight equal to one.
|
The calculation is::
|
|
avg = sum(a * weights) / sum(weights)
|
|
where the sum is over all included elements.
|
The only constraint on the values of `weights` is that `sum(weights)`
|
must not be 0.
|
returned : bool, optional
|
Flag indicating whether a tuple ``(result, sum of weights)``
|
should be returned as output (True), or just the result (False).
|
Default is False.
|
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 original `a`.
|
*Note:* `keepdims` will not work with instances of `numpy.matrix`
|
or other classes whose methods do not support `keepdims`.
|
|
.. versionadded:: 1.23.0
|
|
Returns
|
-------
|
average, [sum_of_weights] : (tuple of) scalar or MaskedArray
|
The average along the specified axis. When returned is `True`,
|
return a tuple with the average as the first element and the sum
|
of the weights as the second element. The return type is `np.float64`
|
if `a` is of integer type and floats smaller than `float64`, or the
|
input data-type, otherwise. If returned, `sum_of_weights` is always
|
`float64`.
|
|
Raises
|
------
|
ZeroDivisionError
|
When all weights along axis are zero. See `numpy.ma.average` for a
|
version robust to this type of error.
|
TypeError
|
When `weights` does not have the same shape as `a`, and `axis=None`.
|
ValueError
|
When `weights` does not have dimensions and shape consistent with `a`
|
along specified `axis`.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> a = np.ma.array([1., 2., 3., 4.], mask=[False, False, True, True])
|
>>> np.ma.average(a, weights=[3, 1, 0, 0])
|
1.25
|
|
>>> x = np.ma.arange(6.).reshape(3, 2)
|
>>> x
|
masked_array(
|
data=[[0., 1.],
|
[2., 3.],
|
[4., 5.]],
|
mask=False,
|
fill_value=1e+20)
|
>>> data = np.arange(8).reshape((2, 2, 2))
|
>>> data
|
array([[[0, 1],
|
[2, 3]],
|
[[4, 5],
|
[6, 7]]])
|
>>> np.ma.average(data, axis=(0, 1), weights=[[1./4, 3./4], [1., 1./2]])
|
masked_array(data=[3.4, 4.4],
|
mask=[False, False],
|
fill_value=1e+20)
|
>>> np.ma.average(data, axis=0, weights=[[1./4, 3./4], [1., 1./2]])
|
Traceback (most recent call last):
|
...
|
ValueError: Shape of weights must be consistent
|
with shape of a along specified axis.
|
|
>>> avg, sumweights = np.ma.average(x, axis=0, weights=[1, 2, 3],
|
... returned=True)
|
>>> avg
|
masked_array(data=[2.6666666666666665, 3.6666666666666665],
|
mask=[False, False],
|
fill_value=1e+20)
|
|
With ``keepdims=True``, the following result has shape (3, 1).
|
|
>>> np.ma.average(x, axis=1, keepdims=True)
|
masked_array(
|
data=[[0.5],
|
[2.5],
|
[4.5]],
|
mask=False,
|
fill_value=1e+20)
|
rW )ÚargnamerË Úf8z;Axis must be specified when shapes of a and weights differ.c 3 ó< K | ] }j | y wri )r^ )r Úaxr` s rQ r zaverage.<locals>.<genexpr>Æ s øè ø Ò!=°" !§'¡'¨"¥+Ñ!=ùs zIShape of weights must be consistent with shape of a along specified axis.c 3 ó4 K | ] \ }}|v r|nd yw)r7 Nrz )r rÐ ÚsrW s rQ r zaverage.<locals>.<genexpr>Í s* øè ø ò $EÙ(-¨¨Að +-°©*¡Q¸!Ó%;ñ $Eùs )rW r_ rb rz ) r< rB r6 r¦ r\ Ú_NoValueÚmeanr_ Útyper> Ú
|
issubclassÚintegerÚboolÚ result_typer^ r® rN rÆ Ú transposeÚargsortÚreshapeÚ enumeraterH r[ rU ÚmultiplyÚ broadcast_tor¢ ) r` rW ÚweightsÚreturnedrË rX Ú keepdims_kwÚavgÚsclÚwgtÚ result_dtypes `` rQ r r 8 s2 ù ôb
|
AÜ
|
Aà ÐÜ# D¨!¯&©&¸&ÔAà2;;Ñ à à! 8Ð, àØaffTÑ)[Ñ)ØiinnQWW T]Ó+ägÓ ä aggll¤R§Z¡Z´·±Ð$9Ô :Ü >>¨!¯'©'°3·9±9¸dÓCLä >>¨!¯'©'°3·9±9Ó=Lð 77ciiÒ Ø|Ü ð ó ð ð yyEÓ!=¸Ô!=Ó =Ò=Ü ð7ó8ð 8ð
|
--¤§
|
¡
|
¨4Ó 0Ó1CØ++eó $EÜ1:¸1¿7¹7Ó1Cô$Eó Eó FCð F?Ø!&&/CØ HHÑ HàcggÐC4 |ÑC°{ÑCð2bkk!SØ ,ô.ß.1©c°$ñGØ:EñGØILñMñ Ø 99 Ò !Ü// # s§y¡yÓ1×6Ñ6Ó8CØCxà
|
rS c óþ t | d« s]t j t | d¬« ||||¬« }t |t j
|
« r d|j k r t |d¬« S |S t | t ||||¬« S ) a7
|
Compute the median along the specified axis.
|
|
Returns the median of the array elements.
|
|
Parameters
|
----------
|
a : array_like
|
Input array or object that can be converted to an array.
|
axis : int, optional
|
Axis along which the medians are computed. The default (None) is
|
to compute the median along a flattened version of the array.
|
out : ndarray, optional
|
Alternative output array in which to place the result. It must
|
have the same shape and buffer length as the expected output
|
but the type will be cast if necessary.
|
overwrite_input : bool, optional
|
If True, then allow use of memory of input array (a) for
|
calculations. The input array will be modified by the call to
|
median. This will save memory when you do not need to preserve
|
the contents of the input array. Treat the input as undefined,
|
but it will probably be fully or partially sorted. Default is
|
False. Note that, if `overwrite_input` is True, and the input
|
is not already an `ndarray`, an error will be raised.
|
keepdims : bool, optional
|
If this is set to True, the axes which are reduced are left
|
in the result as dimensions with size one. With this option,
|
the result will broadcast correctly against the input array.
|
|
Returns
|
-------
|
median : ndarray
|
A new array holding the result is returned unless out is
|
specified, in which case a reference to out is returned.
|
Return data-type is `float64` for integers and floats smaller than
|
`float64`, or the input data-type, otherwise.
|
|
See Also
|
--------
|
mean
|
|
Notes
|
-----
|
Given a vector ``V`` with ``N`` non masked values, the median of ``V``
|
is the middle value of a sorted copy of ``V`` (``Vs``) - i.e.
|
``Vs[(N-1)/2]``, when ``N`` is odd, or ``{Vs[N/2 - 1] + Vs[N/2]}/2``
|
when ``N`` is even.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> x = np.ma.array(np.arange(8), mask=[0]*4 + [1]*4)
|
>>> np.ma.median(x)
|
1.5
|
|
>>> x = np.ma.array(np.arange(10).reshape(2, 5), mask=[0]*6 + [1]*4)
|
>>> np.ma.median(x)
|
2.5
|
>>> np.ma.median(x, axis=-1, overwrite_input=True)
|
masked_array(data=[2.0, 5.0],
|
mask=[False, False],
|
fill_value=1e+20)
|
|
r[ T©r£ )rW ÚoutÚoverwrite_inputrË r7 F©r¢ )r
rË rW ré rê )
|
r r\ r" rA rM r2 r¦ rG r3 Ú_median)r` rW ré rê rË rX s rQ r" r" à sv ôB 1fÔ Ü IIga tÔ,°4Ø ¨Ø 'ô )ô aÔ $¨¨a¯f©fªÜ ¨Ô.Ð .àHä AG¨h¸TÀsØ$3ô 5ð 5rS c ó& t j | j t j « rt j }nd }|r;#| j « j |¬« n$| j |¬« | nt | |¬« dnt j « j dk( rXt d « gj z }t dd« |< t |« }t j j | |¬« S j dk( r-t t « d« \ }}||z dz
|
|dz }t j j t j « rhj dkD rY|j# |¬« } |st j$ | dd |¬
|
« } t j& j( j+ | « } n|j |¬« } t j j- | « r>t j. j0 « s t j j3 « S | S t d ¬ « }
|
|
|
dz } |
|
dz dk( }t j4 || | dz
|
« } t j6 | | g¬ « } t j8 | ¬ « }fd} ||« t j j t j « r|t j j# ||¬« } t j$ | j: dd| j: ¬
|
« t j& j( j+ | « } | S t j j ||¬« } | S )N)r³ )rW r³ r0 )rW ré r7 é )ré g @Úsafe)Úcastingré T©rW rË ©rW c ó t j j | « rlt j j d¬« | j z }t j j « | j |< d| j |< y y )NTrñ F)r\ rs Ú is_maskedÚallr[ Úminimum_fill_valueÚdata)rÒ ÚrepÚasortedrW s rQ Úreplace_maskedz _median.<locals>.replace_maskedk se ø ô
|
55??1Ô ÜFF7<<¨d¸TÔBÐBÀaÇfÁfÑLCÜ %%×2Ñ2°7Ó;AFF3KØ AFF3Kð rS Úunsafe) r\ Ú
|
issubdtyper_ ÚinexactÚinfÚravelrJ r5 r¦ r^ r© rN rs rÔ Údivmodr> ÚsizerU Ú true_divideÚlibÚ _utils_implÚ_median_nancheckrô rõ r[ rö Úwherer= Útake_along_axisr÷ )r` rW ré rê r³ ÚindexerÚidxÚoddÚmidrÒ ÚcountsÚhÚlÚlhÚlow_highrú rù s ` @rQ rì rì . sÎ ù ô
|
}}QWWbjjÔ)ÜVV
|
à
|
ÙØ <ØggiGØ LL JLÕ /à FF¨FÔ 4ØGäqt°
|
Ô;à |Øä# D¨'¯,©,Ó7à}}TÑaÒ ô ;- '§,¡,Ñ.Ü a Ü.Üuuzz' 'Ñ*°¸3zÓ?Ð?à||qÓÜ% .¨!Ó,SØcCi !m C¨!¡GÐ,Ü == ¬¯
|
©
|
Ô 3¸¿ ¹ ÀqÒ8HàCÓ AÙÜNN 1 b°&¸cÔBÜ×"Ñ"×3Ñ3°G¸QÀÓEAàSÓ!Aô
|
55??1Ô ¤b§f¡f¨W¯\©\Ô&:Ü55×+Ñ+¨GÓ4Ð 4Øä 7 °Ô 5FØ! Að 1*/CÜ
|
aQÓ Aä A TÔ *Bô ×!Ñ! '¨2°DÔ9Hõ ñ 8Ô ä }}W]]¤B§J¡JÔ/ä EEIIh T¨sIÓ 3Ü
|
qvvr¨8¸¿¹Õ@ä FF× Ñ × /Ñ /°¸¸DÓ Að Hô EEJJx d°JÓ 4à HrS c
|
ó t | « } t | « }| t t | j « « }nt || j « }|t u s|j « s | j S |j « r t g « S | j }|D ]i }t t t |« « t t |dz | j « « z « }|t d« f|z |j |¬« fz }k |S )a= Suppress slices from multiple dimensions which contain masked values.
|
|
Parameters
|
----------
|
x : array_like, MaskedArray
|
The array to operate on. If not a MaskedArray instance (or if no array
|
elements are masked), `x` is interpreted as a MaskedArray with `mask`
|
set to `nomask`.
|
axis : tuple of ints or int, optional
|
Which dimensions to suppress slices from can be configured with this
|
parameter.
|
- If axis is a tuple of ints, those are the axes to suppress slices from.
|
- If axis is an int, then that is the only axis to suppress slices from.
|
- If axis is None, all axis are selected.
|
|
Returns
|
-------
|
compress_array : ndarray
|
The compressed array.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> arr = [[1, 2], [3, 4]]
|
>>> mask = [[0, 1], [0, 0]]
|
>>> x = np.ma.array(arr, mask=mask)
|
>>> np.ma.compress_nd(x, axis=0)
|
array([[3, 4]])
|
>>> np.ma.compress_nd(x, axis=1)
|
array([[1],
|
[3]])
|
>>> np.ma.compress_nd(x)
|
array([[3]])
|
|
Nr7 rò ) r< rB rN r§ r¦ r6 rH ÚanyÚ_datarõ ÚnxarrayrO r© )r rW rX r÷ rÐ rÇ s rQ r r sâ ôH
|
AÜ
|
Aà |ÜU166]Ó#ä# D¨!¯&©&Ó1ð F{!%%'ØwwàuuwÜr{Ðà 77DØò @ÜT% )_¤t¬E°"°q±&¸!¿&¹&Ó,AÓ'BÑBÓCØU4[N RÑ'¨A¯E©E°t¨EÓ,<Ð+<Ð*>Ñ>Ñ?ð@ð KrS c ób t | « j dk7 r t d« t | |¬« S )a¾
|
Suppress the rows and/or columns of a 2-D array that contain
|
masked values.
|
|
The suppression behavior is selected with the `axis` parameter.
|
|
- If axis is None, both rows and columns are suppressed.
|
- If axis is 0, only rows are suppressed.
|
- If axis is 1 or -1, only columns are suppressed.
|
|
Parameters
|
----------
|
x : array_like, MaskedArray
|
The array to operate on. If not a MaskedArray instance (or if no array
|
elements are masked), `x` is interpreted as a MaskedArray with
|
`mask` set to `nomask`. Must be a 2D array.
|
axis : int, optional
|
Axis along which to perform the operation. Default is None.
|
|
Returns
|
-------
|
compressed_array : ndarray
|
The compressed array.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> x = np.ma.array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0],
|
... [1, 0, 0],
|
... [0, 0, 0]])
|
>>> x
|
masked_array(
|
data=[[--, 1, 2],
|
[--, 4, 5],
|
[6, 7, 8]],
|
mask=[[ True, False, False],
|
[ True, False, False],
|
[False, False, False]],
|
fill_value=999999)
|
|
>>> np.ma.compress_rowcols(x)
|
array([[7, 8]])
|
>>> np.ma.compress_rowcols(x, 0)
|
array([[6, 7, 8]])
|
>>> np.ma.compress_rowcols(x, 1)
|
array([[1, 2],
|
[4, 5],
|
[7, 8]])
|
|
rî z*compress_rowcols works for 2D arrays only.rò )r< r¦ ÚNotImplementedErrorr )r rW s rQ r r ½ s. ôf qz!ÒÜ!Ð"NÓOÐOÜ qtÔ $Ð$rS c ód t | « } | j dk7 r t d« t | d« S )ay
|
Suppress whole rows of a 2-D array that contain masked values.
|
|
This is equivalent to ``np.ma.compress_rowcols(a, 0)``, see
|
`compress_rowcols` for details.
|
|
Parameters
|
----------
|
x : array_like, MaskedArray
|
The array to operate on. If not a MaskedArray instance (or if no array
|
elements are masked), `x` is interpreted as a MaskedArray with
|
`mask` set to `nomask`. Must be a 2D array.
|
|
Returns
|
-------
|
compressed_array : ndarray
|
The compressed array.
|
|
See Also
|
--------
|
compress_rowcols
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> a = np.ma.array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0],
|
... [1, 0, 0],
|
... [0, 0, 0]])
|
>>> np.ma.compress_rows(a)
|
array([[6, 7, 8]])
|
|
rî z'compress_rows works for 2D arrays only.r0 ©r< r¦ r r ©r` s rQ r r õ s2 ôB
|
AØvv{Ü!Ð"KÓLÐLÜ AqÓ !Ð!rS c ód t | « } | j dk7 r t d« t | d« S )a
|
Suppress whole columns of a 2-D array that contain masked values.
|
|
This is equivalent to ``np.ma.compress_rowcols(a, 1)``, see
|
`compress_rowcols` for details.
|
|
Parameters
|
----------
|
x : array_like, MaskedArray
|
The array to operate on. If not a MaskedArray instance (or if no array
|
elements are masked), `x` is interpreted as a MaskedArray with
|
`mask` set to `nomask`. Must be a 2D array.
|
|
Returns
|
-------
|
compressed_array : ndarray
|
The compressed array.
|
|
See Also
|
--------
|
compress_rowcols
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> a = np.ma.array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0],
|
... [1, 0, 0],
|
... [0, 0, 0]])
|
>>> np.ma.compress_cols(a)
|
array([[1, 2],
|
[4, 5],
|
[7, 8]])
|
|
rî z'compress_cols works for 2D arrays only.r7 r r s rQ r r s2 ôF
|
AØvv{Ü!Ð"KÓLÐLÜ AqÓ !Ð!rS c ó t | d¬« } | j dk7 r t d« t | « }|t u s|j « s| S |j « }| j j « | _ |s t | t j |d « < |dv r#t | dd
t j |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 as np
|
>>> a = np.zeros((3, 3), dtype=int)
|
>>> a[1, 1] = 1
|
>>> a
|
array([[0, 0, 0],
|
[0, 1, 0],
|
[0, 0, 0]])
|
>>> a = np.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)
|
>>> np.ma.mask_rowcols(a)
|
masked_array(
|
data=[[0, --, 0],
|
[--, --, --],
|
[0, --, 0]],
|
mask=[[False, True, False],
|
[ True, True, True],
|
[False, True, False]],
|
fill_value=1)
|
|
Frè rî z&mask_rowcols works for 2D arrays only.r0 )Nr7 r¥ Nr7 ) r1 r¦ r rB rH r Únonzerore r¢ rF r\ r, )r` rW rX Ú maskedvals rQ r r E s¤ ôR auÔ AØvv{Ü!Ð"JÓKÐKÜ
|
AàF{!%%'ØØ IØggllnAGÙ Ü%+"))IaLÓ
|
!Ñ"Ø }Ñ Ü(.!RYYy |Ó $Ð
|
$Ñ%Ø HrS c óv |t j ur t j dt d¬« t | d« S )aÍ
|
Mask rows of a 2D array that contain masked values.
|
|
This function is a shortcut to ``mask_rowcols`` with `axis` equal to 0.
|
|
See Also
|
--------
|
mask_rowcols : Mask rows and/or columns of a 2D array.
|
masked_where : Mask where a condition is met.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> a = np.zeros((3, 3), dtype=int)
|
>>> a[1, 1] = 1
|
>>> a
|
array([[0, 0, 0],
|
[0, 1, 0],
|
[0, 0, 0]])
|
>>> a = np.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)
|
|
>>> np.ma.mask_rows(a)
|
masked_array(
|
data=[[0, 0, 0],
|
[--, --, --],
|
[0, 0, 0]],
|
mask=[[False, False, False],
|
[ True, True, True],
|
[False, False, False]],
|
fill_value=1)
|
|
úTThe axis argument has always been ignored, in future passing it will raise TypeErrorrî ©Ú
|
stacklevelr0 ©r\ rÓ ÚwarningsÚwarnÚDeprecationWarningr ©r` rW s rQ r r s9 ðT 2;;Ñ ô ð #Ü$6À1õ Fô 1Ó Ð rS c óv |t j ur t j dt d¬« t | d« S )aÏ
|
Mask columns of a 2D array that contain masked values.
|
|
This function is a shortcut to ``mask_rowcols`` with `axis` equal to 1.
|
|
See Also
|
--------
|
mask_rowcols : Mask rows and/or columns of a 2D array.
|
masked_where : Mask where a condition is met.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> a = np.zeros((3, 3), dtype=int)
|
>>> a[1, 1] = 1
|
>>> a
|
array([[0, 0, 0],
|
[0, 1, 0],
|
[0, 0, 0]])
|
>>> a = np.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)
|
>>> np.ma.mask_cols(a)
|
masked_array(
|
data=[[0, --, 0],
|
[0, --, 0],
|
[0, --, 0]],
|
mask=[[False, True, False],
|
[False, True, False],
|
[False, True, False]],
|
fill_value=1)
|
|
r rî r r7 r" r& s rQ r r Ñ s9 ðR 2;;Ñ ô ð #Ü$6À1õ Fô 1Ó Ð rS c óà t j | « j } | dd | dd z
|
}|g}||j d|« ||j |« t |« dk7 r t |« }|S )a
|
Compute the differences between consecutive elements of an array.
|
|
This function is the equivalent of `numpy.ediff1d` that takes masked
|
values into account, see `numpy.ediff1d` for details.
|
|
See Also
|
--------
|
numpy.ediff1d : Equivalent function for ndarrays.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> arr = np.ma.array([1, 2, 4, 7, 0])
|
>>> np.ma.ediff1d(arr)
|
masked_array(data=[ 1, 2, 3, -7],
|
mask=False,
|
fill_value=999999)
|
|
r7 Nr¥ r0 )rs Ú
|
asanyarrayÚflatÚinsertr r r )rV Úto_endÚto_beginÚedr s rQ r r sw ô* --Ó
|
×
|
!Ñ
|
!CØ QR3s8Ñ BØTFàÐØ aÔ"Ø ÐØ fÔ ä
|
6{aÒô F^à IrS c óæ t j | ||¬« }t |t « r3t |« }|d j t « |d< t |« }|S |j t « }|S )a:
|
Finds the unique elements of an array.
|
|
Masked values are considered the same element (masked). The output array
|
is always a masked array. See `numpy.unique` for more details.
|
|
See Also
|
--------
|
numpy.unique : Equivalent function for ndarrays.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> a = [1, 2, 1000, 2, 3]
|
>>> mask = [0, 0, 1, 0, 0]
|
>>> masked_a = np.ma.masked_array(a, mask)
|
>>> masked_a
|
masked_array(data=[1, 2, --, 2, 3],
|
mask=[False, False, True, False, False],
|
fill_value=999999)
|
>>> np.ma.unique(masked_a)
|
masked_array(data=[1, 2, 3, --],
|
mask=[False, False, False, True],
|
fill_value=999999)
|
>>> np.ma.unique(masked_a, return_index=True)
|
(masked_array(data=[1, 2, 3, --],
|
mask=[False, False, False, True],
|
fill_value=999999), array([0, 1, 4, 2]))
|
>>> np.ma.unique(masked_a, return_inverse=True)
|
(masked_array(data=[1, 2, 3, --],
|
mask=[False, False, False, True],
|
fill_value=999999), array([0, 1, 3, 1, 2]))
|
>>> np.ma.unique(masked_a, return_index=True, return_inverse=True)
|
(masked_array(data=[1, 2, 3, --],
|
mask=[False, False, False, True],
|
fill_value=999999), array([0, 1, 4, 2]), array([0, 1, 3, 1, 2]))
|
)Ú return_indexÚreturn_inverser0 )r\ r, rM rN rO rd r: )Úar1r0 r1 Úoutputs rQ r, r, - sk ôL YYsØ$0Ø&4ô6Fô &%Ô Üf Ø1INN¤;Ó/q Üv ð Mð [Ó)Ø MrS c óÊ |rt j | |f« }n)t j t | « t |« f« }|j « |dd |dd |dd k( S )aY
|
Returns the unique elements common to both arrays.
|
|
Masked values are considered equal one to the other.
|
The output is always a masked array.
|
|
See `numpy.intersect1d` for more details.
|
|
See Also
|
--------
|
numpy.intersect1d : Equivalent function for ndarrays.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> x = np.ma.array([1, 3, 3, 3], mask=[0, 0, 0, 1])
|
>>> y = np.ma.array([3, 1, 1, 1], mask=[0, 0, 0, 1])
|
>>> np.ma.intersect1d(x, y)
|
masked_array(data=[1, 3, --],
|
mask=[False, False, True],
|
fill_value=999999)
|
|
Nr¥ r7 )rs r= r, rJ )r2 Úar2Ú assume_uniqueÚauxs rQ r r _ sa ñ0 Ünnc 3ZÓ(ô nnf Sk¬6°#«;Ð 7Ó8ØHHJØ s8CGs 3 BxÑ'Ñ (Ð(rS c ó, |st | « } t |« }t j | |fd¬« }|j dk( r|S |j « |j « }t j dg|dd |dd k7 dgf« }|dd |dd k( }|| S )aî
|
Set exclusive-or of 1-D arrays with unique elements.
|
|
The output is always a masked array. See `numpy.setxor1d` for more details.
|
|
See Also
|
--------
|
numpy.setxor1d : Equivalent function for ndarrays.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> ar1 = np.ma.array([1, 2, 3, 2, 4])
|
>>> ar2 = np.ma.array([2, 3, 5, 7, 5])
|
>>> np.ma.setxor1d(ar1, ar2)
|
masked_array(data=[1, 4, 5, 7],
|
mask=False,
|
fill_value=999999)
|
|
Nrò r0 Tr7 r¥ )r, rs r= r rJ r? )r2 r5 r6 r7 ÚauxfÚflagÚflag2s rQ r* r* s ñ* ÜSkÜSkä
|
..#s¨$Ô
|
/CØ
|
xx1}Ø
|
ØHHJØ ::<Dä >>D6 D¨¨ H°°S°b° Ñ$9¸T¸FÐCÓ DDà !"XcrÑ "EØ u:ÐrS c óT |st | d¬« \ } }t |« }t j | |f« }|j d¬« }|| }|r |dd |dd k7 }n |dd |dd k( }t j ||gf« } |j d¬« dt | « }
|
|r| |
|
S | |
|
S )a
|
Test whether each element of an array is also present in a second
|
array.
|
|
The output is always a masked array. See `numpy.in1d` for more details.
|
|
We recommend using :func:`isin` instead of `in1d` for new code.
|
|
See Also
|
--------
|
isin : Version of this function that preserves the shape of ar1.
|
numpy.in1d : Equivalent function for ndarrays.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> ar1 = np.ma.array([0, 1, 2, 5, 0])
|
>>> ar2 = [0, 2]
|
>>> np.ma.in1d(ar1, ar2)
|
masked_array(data=[ True, False, True, False, True],
|
mask=False,
|
fill_value=True)
|
|
T)r1 Ú mergesort)Úkindr7 Nr¥ )r, rs r= rÛ r ) r2 r5 r6 ÚinvertÚrev_idxÚarÚorderÚsarÚbool_arr: Úindxs rQ r r ¥ sÈ ñ2 Ü c°$Ô7 WÜSkä c
|
Ó #Bð JJKJÓ (EØ
|
U)CÙ Øqr7c # 2hÑ&àqr7c # 2hÑ&Ü >>7 V HÐ-Ó .DØ ==k=Ó *¨9¬C°«HÐ 5DáØDzÐàDz'Ñ"Ð"rS c ó| t j | « } t | |||¬« j | j « S )aw
|
Calculates `element in test_elements`, broadcasting over
|
`element` only.
|
|
The output is always a masked array of the same shape as `element`.
|
See `numpy.isin` for more details.
|
|
See Also
|
--------
|
in1d : Flattened version of this function.
|
numpy.isin : Equivalent function for ndarrays.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> element = np.ma.array([1, 2, 3, 4, 5, 6])
|
>>> test_elements = [0, 2]
|
>>> np.ma.isin(element, test_elements)
|
masked_array(data=[False, True, False, False, False, False],
|
mask=False,
|
fill_value=True)
|
|
©r6 r? )rs r< r rÜ r^ )ÚelementÚ test_elementsr6 r? s rQ r r Õ s6 ô0 jjÓ!GÜ °mØ ô ß &w w§}¡}Ó 5ð6rS c óF t t j | |fd¬« « S )aÃ
|
Union of two arrays.
|
|
The output is always a masked array. See `numpy.union1d` for more details.
|
|
See Also
|
--------
|
numpy.union1d : Equivalent function for ndarrays.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> ar1 = np.ma.array([1, 2, 3, 4])
|
>>> ar2 = np.ma.array([3, 4, 5, 6])
|
>>> np.ma.union1d(ar1, ar2)
|
masked_array(data=[1, 2, 3, 4, 5, 6],
|
mask=False,
|
fill_value=999999)
|
|
Nrò )r, rs r= )r2 r5 s rQ r- r- ò s ô* ".. # s °$Ô7Ó 8Ð8rS c ó |r$t j | « j « } nt | « } t |« }| t | |dd¬« S )aÚ
|
Set difference of 1D arrays with unique elements.
|
|
The output is always a masked array. See `numpy.setdiff1d` for more
|
details.
|
|
See Also
|
--------
|
numpy.setdiff1d : Equivalent function for ndarrays.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> x = np.ma.array([1, 2, 3, 4], mask=[0, 1, 0, 1])
|
>>> np.ma.setdiff1d(x, [1, 2])
|
masked_array(data=[3, --],
|
mask=[False, True],
|
fill_value=999999)
|
|
TrG )rs r< rÿ r, r )r2 r5 r6 s rQ r) r)
|
sE ñ* Üjjo×#Ñ#Ó%äSkÜSkØ tC¨D¸Ô>Ñ ?Ð?rS Tc óî t j | ddt ¬« } t j | « }|s|j « r t d« | j d dk( rd}t t |« « }d|z
|
}|rt d« df}n dt d« f}|k| j d dkD s| j d dkD rt j }nt j }t j |« j |« }nSt |d dt ¬
|
« }t j |« } |s| j « r t d« |j « s| j « rW|j | j k( r>t j || « }
|
|
|
t ur |
|
x}x| _ x|_ } d | _ d |_ t j& | |f|« } | j d dkD s| j d dkD rt j }nt j }t j t j& || f|« « j |« }| | j) |¬ « | z } | ||fS ) z_
|
Private function for the computation of covariance and correlation
|
coefficients.
|
|
rî T)Úndminr¢ r_ zCannot process masked data.r0 r7 Ni F)r¢ rM r_ rò )rs r1 ÚfloatrC r rÆ r^ ÚintrØ r© r\ Úfloat64Úfloat32Ú logical_notÚastypeÚ
|
logical_orrH re Ú _sharedmaskr= rÔ ) r ÚyÚrowvarÚ allow_maskedÚxmaskrW ÚtupÚ xnm_dtypeÚxnotmaskÚymaskÚ common_masks rQ Ú
|
_covhelperr_ , s ô ! $¬eÔ4AÜ OOAÓ Eá EIIKÜÐ6Ó7Ð7àwwqzQØä f Ó FØ v:DÙ ÜT{DÐ!àU4[Ð!àyð 771:Ò 1§7¡7¨1¡:°Ò#7Ü
|
|
Iä
|
|
IÜ>> %Ó(×/Ñ/° Ó:ä !% q´Ô 6Ü Ó"Ù § ¡ ¤ Ü Ð :Ó;Ð ;Ø 99;%))+Øww!''Ò!ä mm¨E°5Ó 9 Ø ¤fÑ,Ø8CÐCEÐCAGÐC a¤g°Ø$)AMØ$)AMÜ NNAq6 4Ó (ð 771:Ò 1§7¡7¨1¡:°Ò#7Ü
|
|
Iä
|
|
IÜ>>¤"§.¡.°%¸° ÀÓ"FÓG×NÑNØ ó
|
ð VÓ SÑ !Ñ!AØ xÐ Ð rS c óÎ ||t |« k7 r t d« ||rd}nd}t | |||« \ } }}|sËt j |j
|
|« |z
|
}t j |dt ¬« }t j dd¬« 5 t j t | j
|
d« t | j « d« « |z } ddd« t j |¬« j « }
|
|
|
S t j ||j
|
« |z
|
}t j |dt ¬« }t j dd¬« 5 t j t | d« t | j
|
j « d« « |z } ddd« t j |¬« j « }
|
|
|
S # 1 sw Y ûxY w# 1 sw Y <xY w) aA
|
|
Estimate the covariance matrix.
|
|
Except for the handling of missing data this function does the same as
|
`numpy.cov`. For more details and examples, see `numpy.cov`.
|
|
By default, masked values are recognized as such. If `x` and `y` have the
|
same shape, a common mask is allocated: if ``x[i,j]`` is masked, then
|
``y[i,j]`` will also be masked.
|
Setting `allow_masked` to False will raise an exception if values are
|
missing in either of the input arrays.
|
|
Parameters
|
----------
|
x : array_like
|
A 1-D or 2-D array containing multiple variables and observations.
|
Each row of `x` represents a variable, and each column a single
|
observation of all those variables. Also see `rowvar` below.
|
y : array_like, optional
|
An additional set of variables and observations. `y` has the same
|
shape as `x`.
|
rowvar : bool, optional
|
If `rowvar` is True (default), then each row represents a
|
variable, with observations in the columns. Otherwise, the relationship
|
is transposed: each column represents a variable, while the rows
|
contain observations.
|
bias : bool, optional
|
Default normalization (False) is by ``(N-1)``, where ``N`` is the
|
number of observations given (unbiased estimate). If `bias` is True,
|
then normalization is by ``N``. This keyword can be overridden by
|
the keyword ``ddof`` in numpy versions >= 1.5.
|
allow_masked : bool, optional
|
If True, masked values are propagated pair-wise: if a value is masked
|
in `x`, the corresponding value is masked in `y`.
|
If False, raises a `ValueError` exception when some values are missing.
|
ddof : {None, int}, optional
|
If not ``None`` normalization is by ``(N - ddof)``, where ``N`` is
|
the number of observations; this overrides the value implied by
|
``bias``. The default value is ``None``.
|
|
Raises
|
------
|
ValueError
|
Raised if some values are missing and `allow_masked` is False.
|
|
See Also
|
--------
|
numpy.cov
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> x = np.ma.array([[0, 1], [1, 1]], mask=[0, 1, 0, 1])
|
>>> y = np.ma.array([[1, 0], [0, 1]], mask=[0, 0, 1, 1])
|
>>> np.ma.cov(x, y)
|
masked_array(
|
data=[[--, --, --, --],
|
[--, --, --, --],
|
[--, --, --, --],
|
[--, --, --, --]],
|
mask=[[ True, True, True, True],
|
[ True, True, True, True],
|
[ True, True, True, True],
|
[ True, True, True, True]],
|
fill_value=1e+20,
|
dtype=float64)
|
|
Nzddof must be an integerr0 r7 rb Úignore)ÚdivideÚinvalidrZ )rO rÆ r_ r\ r ÚTÚ
|
less_equalrØ Úerrstater? Úconjrs r1 Úsqueeze) r rV rW ÚbiasrX Úddofr\ Úfactr[ r÷ rà s rQ r r g s ðL ÐD¤C¨£IÒ -ÜÐ2Ó3Ð3à |Ù ØDàDä & q¨!¨V°\Ó BÑQ&Ù Üvvhjj (Ó+¨dÑ2Ü}}T 1¬DÔ1Ü [[ °(Ô ;ñ FÜ66& §¡ a.¬&°·±³¸1Ó*=Ó>ÀÑED÷ Fä$ TÔ*×2Ñ2Ó4ð Mô vvh §
|
¡
|
Ó+¨dÑ2Ü}}T 1¬DÔ1Ü [[ °(Ô ;ñ FÜ66& A,¬¨q¯s©s¯x©x«z¸1Ó(=Ó>ÀÑED÷ Fä$ TÔ*×2Ñ2Ó4Ø M÷ Fð Fú÷ Fð Fús ÂAGÅAGÇGÇG$c ó d}|t j us|t j ur t j |t d¬« t | |||¬« } t j t j |« « }|t j j ||« z }|S # t $ r t j « cY S w xY w)ai
|
Return Pearson product-moment correlation coefficients.
|
|
Except for the handling of missing data this function does the same as
|
`numpy.corrcoef`. For more details and examples, see `numpy.corrcoef`.
|
|
Parameters
|
----------
|
x : array_like
|
A 1-D or 2-D array containing multiple variables and observations.
|
Each row of `x` represents a variable, and each column a single
|
observation of all those variables. Also see `rowvar` below.
|
y : array_like, optional
|
An additional set of variables and observations. `y` has the same
|
shape as `x`.
|
rowvar : bool, optional
|
If `rowvar` is True (default), then each row represents a
|
variable, with observations in the columns. Otherwise, the relationship
|
is transposed: each column represents a variable, while the rows
|
contain observations.
|
bias : _NoValue, optional
|
Has no effect, do not use.
|
|
.. deprecated:: 1.10.0
|
allow_masked : bool, optional
|
If True, masked values are propagated pair-wise: if a value is masked
|
in `x`, the corresponding value is masked in `y`.
|
If False, raises an exception. Because `bias` is deprecated, this
|
argument needs to be treated as keyword only to avoid a warning.
|
ddof : _NoValue, optional
|
Has no effect, do not use.
|
|
.. deprecated:: 1.10.0
|
|
See Also
|
--------
|
numpy.corrcoef : Equivalent function in top-level NumPy module.
|
cov : Estimate the covariance matrix.
|
|
Notes
|
-----
|
This function accepts but discards arguments `bias` and `ddof`. This is
|
for backwards compatibility with previous versions of this function. These
|
arguments had no effect on the return values of the function and can be
|
safely ignored in this and previous versions of numpy.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> x = np.ma.array([[0, 1], [1, 1]], mask=[0, 1, 0, 1])
|
>>> np.ma.corrcoef(x)
|
masked_array(
|
data=[[--, --],
|
[--, --]],
|
mask=[[ True, True],
|
[ True, True]],
|
fill_value=1e+20,
|
dtype=float64)
|
|
z/bias and ddof have no effect and are deprecatedrî r )rX ) r\ rÓ r# r$ r% r rs ÚsqrtÚdiagonalrÆ ÚMaskedConstantrÞ Úouter) r rV rW ri rX rj ÚmsgÚcorrÚstds rQ r r Æ s ð| <CØ 2;;Ñ $¬b¯k©kÑ"9ä cÔ-¸!Õ<ä q!V¨,Ô 7Dð#Üggbkk $Ó'Ó(ð BKK× Ñ c 3Ó 'Ñ'DØ Køô ò #Ü× Ñ Ó"Ò"ð#ús Á(B  C Â?C c óJ e Zd ZdZdZ ee« Ze fd« Z fdZ xZ
|
S )ÚMAxisConcatenatorz
|
Translate slice objects to concatenation along an axis.
|
|
For documentation on usage, see `mr_class`.
|
|
See Also
|
--------
|
mr_class
|
|
rz c óh t | |j d¬« }t ||j ¬« S )NFrë rZ )ÚsuperÚmakematr÷ r1 r[ )ÚclsrV r÷ Ú __class__s rQ rx zMAxisConcatenator.makemat% s, ø ô wsxx¨eÓ4ÜT §¡Ô)Ð)rS c óX t |t « r t d« t | |« S )Nz Unavailable for masked array.)rM Ústrr9 rw Ú __getitem__)rn Úkeyrz s rQ r} z MAxisConcatenator.__getitem__. s) ø ä c3Ô ÜÐ9Ó:Ð :äwÑ" 3Ó'Ð'rS ) rj r~ rk rm Ú __slots__Ú staticmethodr= Ú classmethodrx r} Ú __classcell__)rz s @rQ ru ru s5 ø ñ ð Iá {Ó+Kàó*ó ð*÷(ð (rS ru c ó e Zd ZdZdZd Zy)Úmr_classa~
|
Translate slice objects to concatenation along the first axis.
|
|
This is the masked array version of `r_`.
|
|
See Also
|
--------
|
r_
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> np.ma.mr_[np.ma.array([1,2,3]), 0, 0, np.ma.array([4,5,6])]
|
masked_array(data=[1, 2, 3, ..., 4, 5, 6],
|
mask=False,
|
fill_value=999999)
|
|
rz c ó0 t j | d« y )Nr0 )ru rp )rn s rQ rp zmr_class.__init__K s Ü×"Ñ" 4¨Õ+rS N)rj r~ rk rm r rp rz rS rQ r r 6 s ñð$ Ió,rS r c # ó® K t t j | « t | « j « D ] \ }}|s| |r|d t
|
f yw)a¿
|
Multidimensional index iterator.
|
|
Return an iterator yielding pairs of array coordinates and values,
|
skipping elements that are masked. With `compressed=False`,
|
`ma.masked` is yielded as the value of masked elements. This
|
behavior differs from that of `numpy.ndenumerate`, which yields the
|
value of the underlying data array.
|
|
Notes
|
-----
|
.. versionadded:: 1.23.0
|
|
Parameters
|
----------
|
a : array_like
|
An array with (possibly) masked elements.
|
compressed : bool, optional
|
If True (default), masked elements are skipped.
|
|
See Also
|
--------
|
numpy.ndenumerate : Equivalent function ignoring any mask.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> a = np.ma.arange(9).reshape((3, 3))
|
>>> a[1, 0] = np.ma.masked
|
>>> a[1, 2] = np.ma.masked
|
>>> a[2, 1] = np.ma.masked
|
>>> a
|
masked_array(
|
data=[[0, 1, 2],
|
[--, 4, --],
|
[6, --, 8]],
|
mask=[[False, False, False],
|
[ True, False, True],
|
[False, True, False]],
|
fill_value=999999)
|
>>> for index, x in np.ma.ndenumerate(a):
|
... print(index, x)
|
(0, 0) 0
|
(0, 1) 1
|
(0, 2) 2
|
(1, 1) 4
|
(2, 0) 6
|
(2, 2) 8
|
|
>>> for index, x in np.ma.ndenumerate(a, compressed=False):
|
... print(index, x)
|
(0, 0) 0
|
(0, 1) 1
|
(0, 2) 2
|
(1, 0) --
|
(1, 1) 4
|
(1, 2) --
|
(2, 0) 6
|
(2, 1) --
|
(2, 2) 8
|
r0 N)Úzipr\ r$ rC r* rF )r` Ú
|
compressedÚitr[ s rQ r$ r$ V sO è ø ô| qÓ)¬<¸«?×+?Ñ+?Ó@ò DÙØHÚØQ%-Ó ñ ùs AAÁAc óò t | « }|t u st j |« s$t j d| j
|
dz
|
g« S t j | « }t |« dkD r|ddg S y)aÐ
|
Find the indices of the first and last unmasked values.
|
|
Expects a 1-D `MaskedArray`, returns None if all values are masked.
|
|
Parameters
|
----------
|
a : array_like
|
Input 1-D `MaskedArray`
|
|
Returns
|
-------
|
edges : ndarray or None
|
The indices of first and last non-masked value in the array.
|
Returns None if all values are masked.
|
|
See Also
|
--------
|
flatnotmasked_contiguous, notmasked_contiguous, notmasked_edges
|
clump_masked, clump_unmasked
|
|
Notes
|
-----
|
Only accepts 1-D arrays.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> a = np.ma.arange(10)
|
>>> np.ma.flatnotmasked_edges(a)
|
array([0, 9])
|
|
>>> mask = (a < 3) | (a > 8) | (a == 5)
|
>>> a[mask] = np.ma.masked
|
>>> np.array(a[~a.mask])
|
array([3, 4, 6, 7, 8])
|
|
>>> np.ma.flatnotmasked_edges(a)
|
array([3, 8])
|
|
>>> a[:] = np.ma.masked
|
>>> print(np.ma.flatnotmasked_edges(a))
|
None
|
|
r0 r7 r¥ N)rB rH r\ r r1 r Ú flatnonzeror )r` rX Úunmaskeds rQ r r sh ô\
|
AØF{"&& )ÜxxAFF QJÓ(Ð(Ü~~qbÓ!HÜ
|
8}qÒØBÑ Ð àrS c ó t | « } | j dk( r t | « S t | « }t t j | j « t j |g| j z « ¬« t fdt | j « D « « t fdt | j « D « « gS )az
|
Find the indices of the first and last unmasked values along an axis.
|
|
If all values are masked, return None. Otherwise, return a list
|
of two tuples, corresponding to the indices of the first and last
|
unmasked values respectively.
|
|
Parameters
|
----------
|
a : array_like
|
The input array.
|
axis : int, optional
|
Axis along which to perform the operation.
|
If None (default), applies to a flattened version of the array.
|
|
Returns
|
-------
|
edges : ndarray or list
|
An array of start and end indexes if there are any masked data in
|
the array. If there are no masked data in the array, `edges` is a
|
list of the first and last index.
|
|
See Also
|
--------
|
flatnotmasked_contiguous, flatnotmasked_edges, notmasked_contiguous
|
clump_masked, clump_unmasked
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> a = np.arange(9).reshape((3, 3))
|
>>> m = np.zeros_like(a)
|
>>> m[1:, 1:] = 1
|
|
>>> am = np.ma.array(a, mask=m)
|
>>> np.array(am[~am.mask])
|
array([0, 1, 2, 3, 6])
|
|
>>> np.ma.notmasked_edges(am)
|
array([0, 6])
|
|
r7 rZ c 3 ób K | ]& }| j « j « ( y wri )Úminr ©r r¸ rW r s rQ r z"notmasked_edges.<locals>.<genexpr> ó' øè ø ÒG°A#a&**TÓ"×-Ñ-×/ÑGùó ,/c 3 ób K | ]& }| j « j « ( y wri )r± r r s rQ r z"notmasked_edges.<locals>.<genexpr> r r )
|
r< r¦ r rC r1 r\ Úindicesr^ rN r§ )r` rW rX r s ` @rQ r& r& Ó s ù ôV
|
AØ |qvv {Ü" 1Ó%Ð%ÜQAÜ
|
|
|
177Ó#¬"¯*©*°a°S¸1¿6¹6±\Ó*BÔ
|
CCÜ ÔG¼¸q¿v¹v» ÔGÓ GÜ ÔG¼¸q¿v¹v» ÔGÓ Gð Kð KrS c ó* t | « }|t u rt d| j « gS d}g }t j
|
|j « « D ]> \ }}t t |« « }|s |j t |||z « « ||z }@ |S )an
|
Find contiguous unmasked data in a masked array.
|
|
Parameters
|
----------
|
a : array_like
|
The input array.
|
|
Returns
|
-------
|
slice_list : list
|
A sorted sequence of `slice` objects (start index, end index).
|
|
See Also
|
--------
|
flatnotmasked_edges, notmasked_contiguous, notmasked_edges
|
clump_masked, clump_unmasked
|
|
Notes
|
-----
|
Only accepts 2-D arrays at most.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> a = np.ma.arange(10)
|
>>> np.ma.flatnotmasked_contiguous(a)
|
[slice(0, 10, None)]
|
|
>>> mask = (a < 3) | (a > 8) | (a == 5)
|
>>> a[mask] = np.ma.masked
|
>>> np.array(a[~a.mask])
|
array([3, 4, 6, 7, 8])
|
|
>>> np.ma.flatnotmasked_contiguous(a)
|
[slice(3, 5, None), slice(6, 9, None)]
|
>>> a[:] = np.ma.masked
|
>>> np.ma.flatnotmasked_contiguous(a)
|
[]
|
|
r0 )
|
rB rH r© r Ú itertoolsÚgroupbyrÿ r rO r )r` rX r¸ rà r Úgr¿ s rQ r r s ôT
|
AØF{ÜaÓ Ð!Ð!Ø AØ FÜ×#Ñ# A§G¡G£IÓ.ò AÜ QLÙØ MM% 1 q¡5/Ô *Ø Qð ð
|
MrS c óB t | « } | j }|dkD r t d« ||dk( r t | « S g }|dz dz }ddg}t dd« ||< t | j | « D ]- }|||< |j t | t |« « « / |S )aÎ
|
Find contiguous unmasked data in a masked array along the given axis.
|
|
Parameters
|
----------
|
a : array_like
|
The input array.
|
axis : int, optional
|
Axis along which to perform the operation.
|
If None (default), applies to a flattened version of the array, and this
|
is the same as `flatnotmasked_contiguous`.
|
|
Returns
|
-------
|
endpoints : list
|
A list of slices (start and end indexes) of unmasked indexes
|
in the array.
|
|
If the input is 2d and axis is specified, the result is a list of lists.
|
|
See Also
|
--------
|
flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges
|
clump_masked, clump_unmasked
|
|
Notes
|
-----
|
Only accepts 2-D arrays at most.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> a = np.arange(12).reshape((3, 4))
|
>>> mask = np.zeros_like(a)
|
>>> mask[1:, :-1] = 1; mask[0, 1] = 1; mask[-1, 0] = 0
|
>>> ma = np.ma.array(a, mask=mask)
|
>>> ma
|
masked_array(
|
data=[[0, --, 2, 3],
|
[--, --, --, 7],
|
[8, --, --, 11]],
|
mask=[[False, True, False, False],
|
[ True, True, True, False],
|
[False, True, True, False]],
|
fill_value=999999)
|
>>> np.array(ma[~ma.mask])
|
array([ 0, 2, 3, 7, 8, 11])
|
|
>>> np.ma.notmasked_contiguous(ma)
|
[slice(0, 1, None), slice(2, 4, None), slice(7, 9, None), slice(11, 12, None)]
|
|
>>> np.ma.notmasked_contiguous(ma, axis=0)
|
[[slice(0, 1, None), slice(2, 3, None)], [], [slice(0, 1, None)], [slice(0, 3, None)]]
|
|
>>> np.ma.notmasked_contiguous(ma, axis=1)
|
[[slice(0, 1, None), slice(2, 4, None)], [slice(3, 4, None)], [slice(0, 1, None), slice(3, 4, None)]]
|
|
rî z&Currently limited to at most 2D array.Nr7 r0 ) r< r¦ r r r© r§ r^ r rN )r` rW r¶ rà Úotherr r¸ s rQ r% r% > s± ôv
|
AØ
|
BØ AvÜ!Ð"JÓKÐKØ |rQwÜ'¨Ó*Ð*à Fà AXNEØ a&CÜdDÓ!CIä 1775>Ó "ò ?ØE
|
Ø Ô.¨q´°s³©}Ó=Õ>ð?ð MrS c
|
óF | j dkD r| j « } | dd | dd z j « }|d dz }| d rdt |« dk( rt d| j
|
« gS t d|d « g}|j d t |ddd
|ddd
« D « « nDt |« dk( rg S t |ddd
|ddd
« D cg c] \ }}t ||« }}}| d r(|j t |d | j
|
« « |S c c}}w )zv
|
Finds the clumps (groups of data with the same values) for a 1D bool array.
|
|
Returns a series of slices.
|
r7 Nr¥ r0 c 3 ó: K | ] \ }}t ||« y wri )r© )r ÚleftÚrights rQ r z_ezclump.<locals>.<genexpr> s% è ø ò BÙ!dEô e×$ñ Bùs rî ) r¦ rÿ r r r© r Úextendr r )r[ r Úrr r s rQ Ú_ezclumpr¡ s. ð yy1}Øzz|Ø 8d3BiÑ ×
|
(Ñ
|
(Ó
|
*CØ
|
a&1*Cà AwÜ s8q=Ü!TYYÓ'Ð(Ð (ä 1c!fÓ Ð Ø ñ BÜ%(¨¨Q¨r°!¨V©°c¸!¸$¸Q¸$±iÓ%@ôBõ Cô s8q=ØIä36°s¸5¸B¸q¸5±zÀ3ÀqÀtÈ!ÀtÁ9Ó3M× N¡K D¨%U4Õ Ð NÑ Nà BxØ s2w § ¡ Ó*Ô+Ø Hùó Os ÃD c óz t | dt « }|t u rt d| j « gS t | « S )aá
|
Return list of slices corresponding to the unmasked clumps of a 1-D array.
|
(A "clump" is defined as a contiguous region of the array).
|
|
Parameters
|
----------
|
a : ndarray
|
A one-dimensional masked array.
|
|
Returns
|
-------
|
slices : list of slice
|
The list of slices, one for each continuous region of unmasked
|
elements in `a`.
|
|
See Also
|
--------
|
flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges
|
notmasked_contiguous, clump_masked
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> a = np.ma.masked_array(np.arange(10))
|
>>> a[[0, 1, 2, 6, 8, 9]] = np.ma.masked
|
>>> np.ma.clump_unmasked(a)
|
[slice(3, 6, None), slice(7, 8, None)]
|
|
re r0 )rr rH r© r r¡ ©r` r[ s rQ r r © s9 ô< 1gvÓ &DØ v~ÜaÓ Ð!Ð!Ü TE?ÐrS c óV t j | « }|t u rg S t |« S )aô
|
Returns a list of slices corresponding to the masked clumps of a 1-D array.
|
(A "clump" is defined as a contiguous region of the array).
|
|
Parameters
|
----------
|
a : ndarray
|
A one-dimensional masked array.
|
|
Returns
|
-------
|
slices : list of slice
|
The list of slices, one for each continuous region of masked elements
|
in `a`.
|
|
See Also
|
--------
|
flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges
|
notmasked_contiguous, clump_unmasked
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> a = np.ma.masked_array(np.arange(10))
|
>>> a[[0, 1, 2, 6, 8, 9]] = np.ma.masked
|
>>> np.ma.clump_masked(a)
|
[slice(0, 3, None), slice(6, 7, None), slice(8, 10, None)]
|
|
)rs rB rH r¡ r£ s rQ r r Í s' ô< ::a=DØ v~Ø Ü D>ÐrS c ób t j | |« }t | « }|t urd||< |S )zD
|
Masked values in the input array result in rows of zeros.
|
|
r0 )r\ r. rB rH )r r¿ Ú_vanderrX s rQ r. r. ö s1 ô
|
ii1oGÜ
|
AØØ
|
Ø NrS c ó t | « } t |« }t | « }|j dk( rt |t |« « }nJ|j dk( r0t t |« « }|t
|
ur t ||dd
df « }n t d« |dt |« }|j dk7 r t d« |j d |j d k7 r t d« t |t |« « }|t
|
ur+| } ||| }t j | | || |||||« S t j | ||||||« S )zE
|
Any masked values in x is propagated in y, and vice-versa.
|
|
r7 rî Nr0 z Expected a 1D or 2D array for y!z expected a 1-d array for weightsz(expected w and y to have the same length)
|
r< rB r¦ rE r rH r® r^ r\ r' )
|
r rV ÚdegÚrcondÚfullÚwr rX ÚmyÚnot_ms
|
rQ r' r' s. ô
|
|
AÜ
|
Aä
|
AØvv{Ü AwqzÓ "Ø
|
1Ü Yq\Ó "Ø VÑ Ü2a d8Ó$AäÐ:Ó;Ð;à}Ü AJØ 66Q;ÜÐ >Ó?Ð ?Ø 771: Ò #ÜÐ FÓGÐ GÜ AwqzÓ "àØØ =Ø%AÜzz!E( A e¡H¨c°5¸$ÀÀ3ÓGÐGäzz!Q U¨D°!°SÓ9Ð9rS ri )NNF)NNFF)NN)FF)F)NTT)NTFTN)T)NFNF)erm Ú__all__r r# Únumpyr\ r1 r r2 Ú numpy.lib._function_base_implr3 Ú numpy.lib._index_tricks_implr4 Únumpy.lib.array_utilsr5 r6 Ú r8 rs r9 r: r; r< r= r> r r? r@ rA rB rC rD rE rF rG rH rI rJ rK rR r rN r r! rg r r r r r r r r/ r( r r
|
r r+ r r r r r ÚfindÚrstriprÓ r r" rì r r r r r r r r r, r r* r r r- r) r_ r r ru r r# r$ r r& r r% r¡ r r r. ru r' rz rS rQ ú<module>r¶ sì ðñò
|
ó Û ã Ý "Ý Ý 2Ý 9ß Lå ÷÷ ÷ ÷ ÷ õ ò23ó3ðl "ó : òz= ÷F2 ñ 2 ôj-_ô -ô$
|
)/ô
|
)ô?ô ô2oô ñ. % \Ó 2
|
Ù $ \Ó 2
|
Ù $ \Ó 2
|
á(¨Ó2Ð 2Ù XÓ &Ù" >Ó2 Ù XÓ &ÙGÓ$á Ó )á ! *Ó -ò òOðd ×.Ñ.×6Ñ6Ð Ô òð2 ×ÑÐ&Ø × 0Ñ 0× 8Ñ 8Ø1× Ñ × #Ñ #× (Ñ (¨Ó 1ð 3ß39±6³8ð,ñ. OÔðbeØ[[ôeóPK5ó\R ój7ót5%òp$"òN&"óRV ðr kkó 0 ðf kkó / ól#óL/ód )óB"óJ-#ó`6ò:9ó0@óD8!óv\ð~ t¨"¯+©+ÀDØ++óJô` (Ð(ô (ô@,Ð ô ,ñ2 jóB òJ5óp1Kòh4ónKò\ ò:!òH!óR ð RYY× .Ñ .°·±Ó?ó :ðF "++bjj× 0Ñ 0°'·/±/ÓB
rS
|
