| Server IP : 209.209.40.120 / Your IP : 216.73.217.112 Web Server : Microsoft-IIS/10.0 System : Windows NT NEWWWW 10.0 build 17763 (Windows Server 2019) i586 User : NEWWWW$ ( 0) PHP Version : 8.3.30 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : OFF | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /Python312/Lib/site-packages/numpy/ma/__pycache__/ |
Upload File : |
�
�g� � �l � d Z g d�ZddlZddlZddlmZ ddlmZmZm Z m
Z
m Z m Z m
Z
mZmZmZmZmZmZmZmZmZmZmZmZmZmZ ddl Z ddl m Z m
Z ddl m!Z!m"Z" dd l#m$Z$ dd
l%m&Z& d � Z'dMd �Z(e)fd
�Z*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=e jz j e=_ d%� Z>e>j �Re j| j de j| j j d&� j� � d'z e>_ dNe j� d(�d)�ZBdOd*�ZCdNd+�ZDdMd,�ZEdMd-�ZFd.� ZGd/� ZHdMd0�ZIe j� fd1�ZJe j� fd2�ZKdPd3�ZLdQd4�ZMdRd5�ZNdRd6�ZOdQd7�ZPdQd8�ZQd9� ZRdRd:�ZSdSd<�ZTdTd=�ZUdd;e j� d;e j� fd>�ZV G d?� d@e&� ZW G dA� dBeW� ZX eX� ZYdUdC�ZZdD� Z[dMdE�Z\dF� Z]dMdG�Z^dH� Z_dI� Z`dJ� ZadMdK�Zb ej� e j� j ebj � eb_ dVdL�Zd ej� e j� j edj � ed_ y)Wz�
Masked arrays add-ons.
A collection of utilities for `numpy.ma`.
:author: Pierre Gerard-Marchant
:contact: pierregm_at_uga_dot_edu
:version: $Id: extras.py 3473 2007-10-29 15:18:13Z jarrod.millman $
).�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� )�core)� MaskedArray�MAError�add�array�asarray� concatenate�filled�count�getmask� getmaskarray�make_mask_descr�masked� masked_array�mask_or�nomask�ones�sort�zeros�getdata�get_masked_subclassr )�ndarrayr6 )�normalize_axis_index�normalize_axis_tuple)�_ureduce)�AxisConcatenatorc �8 � t | t t t f� S )z6
Is seq a sequence (ndarray, list or tuple)?
)�
isinstancerG �tuple�list)�seqs �1C:\Python312\Lib\site-packages\numpy/ma/extras.py�
issequencerR ( s � �
�c�G�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])
)r< �sum)�arr�axis�ms rQ r r 0 s � �d �S��A� �5�5��;�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)r? �np�emptyrB r= )�shape�dtype�as rQ r r f s5 � �p �R�X�X�e�U�+� �'�'�%� ��)?�@� B�A� �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�viewr3 rB r^ r= r_ �_mask)rV r` s rQ r! r! � sB � �v �
�
�c�� � � �,�A��g�g�a�g�g�_�Q�W�W�%=�>�A�G� �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���f�i��.�� ��)�)�&�1�C��+�+�c� $<� =�C���m�m�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 rG � __array__r< r? r7 )rn �xr{ r| �func�_d�_ms rQ r} z _fromnxfunction_single.__call__! s� � ��r�4�=�=�)�� �a�� !��a�k�k�m�5�d�5�f�5�B��l�1�o�7��7��7�B� ���,� ,��b�j�j��m�5�d�5�f�5�B��l�1�o�7��7��7�B� ���,� ,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 �cg c] }t j |� �� c}� g|��i |��} |t |D �cg c]
}t |� �� c}� g|��i |��}t
||�� S c c}w c c}w r� )rr r\ rj rN r7 r< r? )rn r� r{ r| r� r` r� r� s rQ r} z _fromnxfunction_seq.__call__3 s{ � ��r�4�=�=�)��
�%��2�1����A� �2�3�
E�d�
E�f�
E��
�%�!�4�Q� �a� �4�5�
G��
G��
G���B�R�(�(�� 3��4s � B
� B 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 r1 ) rr r\ rj rO �lenrR �append�popr7 r< r? ) rn r{ r| r� �arrays�resr� r� r� s rQ r} z _fromnxfunction_args.__call__C s� � ��r�4�=�=�)�����D�z���$�i�!�m�
�4��7� 3� �M�M�$�(�(�1�+� &� �$�i�!�m�
�4��7� 3���� 2�A��b�j�j��m�5�d�5�f�5�B��l�1�o�7��7��7�B� �J�J�|�B�R�0� 1� 2� �v�;�!� ��q�6�M��
rS Nr� rz rS rQ r� r� : 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 r1 r0 )rr r\ rj r7 r< r� r? r� )rn r{ r| r� r� r� r� r� s rQ r} z _fromnxfunction_allargs.__call__^ s~ � ��r�4�=�=�)����� 2�A��b�j�j��m�.�v�.�B��l�1�o�0��0�B� �J�J�|�B�R�0� 1� 2� �t�9��>��q�6�M��
rS Nr� rz rS rQ r� r� S 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__r1 )r� �hasattr)rP �ks rQ �flatten_inplacer� | s` � � �A� ��C��=��c�!�f�j�)� ��V�C��1�q�5�N� �c�!�f�j�)� �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 r1 �ON���re rb ) r6 �ndimrH r\ rD rO �range�remove�slicer7 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��5��9�o�G� �N�N�4���D�$� �A�d�G��z�z�#�)�)�$�)�)�'�2�H��E�E�'�3��
��U�1�8�8�:�&�'�
9�$�
9�&�
9�C��{�{�3� �H� � � ��H� �F���
�
�b�j�j��o�+�+�,��x��(�� ��u�S�z���w�w�x� ��
���$�h� ��G�q�L�G��A��q�6�X�a�[�(�q�A��F�|��A��E�
�a��
���A���Q��� �q�6�X�a�[�(�q�A��F�|�
�E�E�'�3� ���U�1�8�8�:� .�/�A�$�A�&�A�C�!$�F�5��:� � �M�M�'�#�,�,�,� -�
��F�A� �$�h� �C�e�4�0��
�F�F�H���$��%�&����1��$�� ���g�s���w�w�x� �� � ��� � �?�� �������
�
�g�c�l�(�(�)�"�8�,���x��(��58��u�_�Q�X�X�Z�0�1�2�
���$�h� ��G�q�L�G��A��q�6�Y�q�\�)��Q��V� ��A��E�
�a��
���A���Q��� �q�6�Y�q�\�)��Q��V� �
�E�E�'�3� �
�E�E�'�3� ���U�1�8�8�:� .�/�A�$�A�&�A�C�9<�F�5� �����4�5� 6� �M�M�'�#�,�,�,� -�
��F�A� �$�h� ���"�*�*�V�,�0�0�2�3�J� �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)r7 r� r6 rs � expand_dims�
ValueError)r� r` �axes�val�NrW r{ r� s rQ r r � s� � � �!�*�C� ���A� �T�{���1� ��w���
9�� �!�8��t�8�D��T�{���D�k�� �8�8�s�x�x� ��C��.�.��d�+�C��x�x�3�8�8�#��� � "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! � fd��D � � k7 r t# d� �| j% t j& �� � } | j) t! �fd�t+ � 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^ )�.0�axr` s �rQ � <genexpr>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 �� � y�w)r1 Nrz )r� r� �srW s �rQ r� zaverage.<locals>.<genexpr>� s* �� �� � $E�(-��A� +-��*�Q�!�%;� $E�s �)rW r_ rb rz ) r7 r; rI r� r\ �_NoValue�meanr_ �typer: �
issubclass�integer�bool� result_typer^ r� rN r� � transpose�argsort�reshape� enumeraterA r[ rU �multiply� broadcast_tor� ) r` rW �weights�returnedr� rX � keepdims_kw�avg�scl�wgt� result_dtypes `` rQ r r $ s2 �� �b ��
�A���
�A� ��#�D�!�&�&�&�A���2�;�;� �� �!�8�,� ����a�f�f�T�)�[�)���i�i�n�n�Q�W�W�T�]�+���g� �� �a�g�g�l�l�R�Z�Z����$9� :� �>�>�!�'�'�3�9�9�d�C�L� �>�>�!�'�'�3�9�9�=�L�
�7�7�c�i�i� ��|� � � � � �y�y�E�!=��!=� =�=� �7�8� 8�
�-�-��
�
�4� 0�1�C��+�+�e� $E�1:�1�7�7�1C�$E� E� F�C�
�F�?�����w�-�C� �H�H���� �H��c�g�g�C�4�|�C�{�C��2�b�k�k�!�S� ,�.�.1�c�$�G�:E�G�IL�M�� � �9�9�� � � !��/�/�#�s�y�y�1�6�6�8�C��C�x���
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� r1 F�r� )r� r� rW r� r� )
r� r\ r" rE rM rG r� r? rJ �_median)r` rW r� r� r� rX s rQ r" r" � sv � �B �1�f� � �I�I�g�a�t�,�4� �� '�
)�� �a���� $��a�f�f�� ���.� .��H� �A�G�h�T�s�$3� 5� 5rS c �& ��� t j | j t j � rt j }nd }|r;��#| j � ��j
|�� n$| j
�|�� | �nt
| �|�� ���d�nt ��j � ��j � dk( rXt d � g�j z }t dd� |�< t |� }t j j �| �|�� S �j dk( �r-t t �� d� \ }}�||z dz
|dz }t j �j t j � rh�j 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� r1 � )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_maskedW se �� �
�5�5�?�?�1� ��F�F�7�<�<�d�T�B�B�a�f�f�L�C� �%�%�2�2�7�;�A�F�F�3�K� �A�F�F�3�K� rS �unsafe) r\ �
issubdtyper_ �inexact�inf�ravelrC rH r� r^ r� rN rs r� �divmodr: �sizerU � true_divide�lib� _utils_impl�_median_nancheckr� r� r[ r� �wherer8 �take_along_axisr� )r` rW r� r� r� �indexer�idx�odd�midr� �counts�h�l�lh�low_highr� r� s ` @rQ r� r� s� �� �
�}�}�Q�W�W�b�j�j�)��V�V�
��
�� �<��g�g�i�G� �L�L�J�L� /�
�F�F���F� 4��G��q�t�
�;�� �|���#�D�'�,�,�7���}�}�T��a� � ��;�-�'�,�,�.�� �a�� ���
���.���u�u�z�z�'�'�*��3�z�?�?��|�|�q���%��.�!�,���S��c�C�i�!�m�C�!�G�,��
�=�=�� � ��
�
� 3�� � �q�8H����C�� �A���N�N�1�b�&�c�B�����"�"�3�3�G�Q��E�A����S��!�A�
�5�5�?�?�1� �b�f�f�W�\�\�&:��5�5�+�+�G�4� 4���
�7���
5�F��!� �A� �1�*��/�C�
����a��1�� �A� � � ��1��D� )�B� �!�!�'�2�D�9�H� � �8� � �}�}�W�]�]�B�J�J�/� �E�E�I�I�h�T�s�I� 3��
���q�v�v�r�8����@� �F�F� � � /� /���D� A��
�H�
�E�E�J�J�x�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]])
Nr1 r� )
r7 r; rN r� r� rI rA �any�_datar� �nxarrayrO r� )r� rW rX r� r� r� s rQ r r o s� � �H ��
�A���
�A� �|��U�1�6�6�]�#��#�D�!�&�&�1�� �F�{�!�%�%�'��w�w���u�u�w��r�{�� �7�7�D�� >���T�%��)�_�t�E�"�q�&�!�&�&�,A�'B�B�C���U�4�[�N�2�%�!�%�%�T�%�*:�):�(<�<�=��>� �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� )r7 r� �NotImplementedErrorr )r� rW s rQ r
r
� s. � �f �q�z���!��!�"N�O�O� �q�t� $�$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 �r7 r� r r
�r` s rQ r r � s2 � �B ��
�A��v�v��{�!�"K�L�L� �A�q� !�!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.r1 r r s rQ r r s2 � �F ��
�A��v�v��{�!�"K�L�L� �A�q� !�!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 )Nr1 r� Nr1 ) r6 r� r r; rA r �nonzerore r� r> r\ r, )r` rW rX � maskedvals rQ r r 1 s� � �R �a�u� �A��v�v��{�!�"J�K�K���
�A��F�{�!�%�%�'���� � � �I��g�g�l�l�n�A�G� �%+��"�)�)�I�a�L�
!�"� �}� �(.��!�R�Y�Y�y��|�
$�
$�%� �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 r1 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)
r1 Nr� r0 )rs �
asanyarray�flat�insertr� r� r )rV �to_end�to_begin�edr� s rQ r r � sw � �*
�-�-��
�
!�
!�C� �Q�R��3�s��8� �B��T�F����
�
�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 r3 )�ar1r- r. �outputs rQ r, r, sk � �L �Y�Y�s�$0�&4�6�F� �&�%� ��f� ���1�I�N�N�;�/��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� r1 )rs r8 r, rC )r/ �ar2�
assume_unique�auxs rQ r r K sa � �0 ��n�n�c�3�Z�(�� �n�n�f�S�k�6�#�;� 7�8���H�H�J� �s��8�C���G�s�3�B�x�'� (�(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 Tr1 r� )r, rs r8 r� rC r9 )r/ r2 r3 r4 �auxf�flag�flag2s rQ r* r* l s� � �* ��S�k���S�k��
�.�.�#�s��$�
/�C�
�x�x�1�}��
��H�H�J� �:�:�<�D�
�>�>�D�6�D���H��S�b� �$9�T�F�C� D�D�
�!�"�X��c�r��
"�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)r. � mergesort)�kindr1 Nr� )r, rs r8 r� r� ) r/ r2 r3 �invert�rev_idx�ar�order�sar�bool_arr7 �indxs rQ r r � s� � �2 � �c�$�7� ��W��S�k�� � � ��c�
� #�B�
�J�J�K�J� (�E�
�U�)�C�
��q�r�7�c�#�2�h�&���q�r�7�c�#�2�h�&��
�>�>�7�V�H�-� .�D� �=�=�k�=� *�9�C��H� 5�D���D�z���D�z�'�"�"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)
�r3 r< )rs r7 r r� r^ )�element�
test_elementsr3 r< s rQ r r � s6 � �0 �j�j��!�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 r8 )r/ r2 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)
TrD )rs r7 r� r, r )r/ r2 r3 s rQ r) r) � sE � �* ��j�j��o�#�#�%���S�k���S�k�� �t�C��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 r1 Ni F)r� rJ r_ r� )rs r6 �floatr< r r� r^ �intr� r� r\ �float64�float32� logical_not�astype�
logical_orrA re � _sharedmaskr8 r� ) r� �y�rowvar� allow_masked�xmaskrW �tup� xnm_dtype�xnotmask�ymask� common_masks rQ �
_covhelperr\ s � � ����!�$�e�4�A� �O�O�A� �E� �E�I�I�K��6�7�7��w�w�q�z�Q����
��f� �
�F� �v�:�D�
��T�{�D�!���U�4�[�!���y�
�7�7�1�:�� �1�7�7�1�:��#7��
�
�I��
�
�I��>�>�%�(�/�/� �:�� �!�%�q�� 6������"���� � � � � :�;� ;� �9�9�;�%�)�)�+��w�w�!�'�'�!� �m�m�E�5� 9� � �f�,�8C�C�E�C�A�G�C�a�g��$)�A�M�$)�A�M� �N�N�A�q�6�4� (��
�7�7�1�:�� �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 r1 rb �ignore)�divide�invalidrZ )rL r� r\ r\ r �T�
less_equalr� �errstater9 �conjrs r6 �squeeze) r� rS rT �biasrU �ddofrY �factr[ r� r� s rQ r r S s� � �L ��D�C��I� -��2�3�3� �|� ��D��D� &�q�!�V�\� B��Q��&� ��v�v�h�j�j�(�+�d�2���}�}�T�1�D�1��
�[�[��(�
;� F��6�6�&����a�.�&�����1�*=�>��E�D� F����$�T�*�2�2�4�� �M� �v�v�h��
�
�+�d�2���}�}�T�1�D�1��
�[�[��(�
;� F��6�6�&��A�,��q�s�s�x�x�z�1�(=�>��E�D� 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 )rU )
r\ r� r r! r" r rs �sqrt�diagonalr� �MaskedConstantr� �outer) r� rS rT rf rU rg �msg�corr�stds rQ r r � s� � �| <�C� �2�;�;� �$�b�k�k�"9��
�
�c�-�!�<� �q�!�V�,� 7�D�#��g�g�b�k�k�$�'�(�� �B�K�K� � �c�3� '�'�D� �K�� � #�� � �"�"�#�s �(B � C �?C c �J � � e Zd ZdZdZ ee� Ze� fd�� Z� fd�Z � 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� r6 r[ )�clsrV r� � __class__s �rQ ru zMAxisConcatenator.makemat s, �� � �w��s�x�x�e��4���T����)�)rS c �X �� t |t � r t d� �t �| � |� S )Nz Unavailable for masked array.)rM �strr4 rt � __getitem__)rn �keyrw s �rQ rz z MAxisConcatenator.__getitem__ s) �� � �c�3� ��9�:� :��w�"�3�'�'rS ) rj r~ rk rm � __slots__� staticmethodr8 � classmethodru rz �
__classcell__)rw s @rQ rr rr s5 �� � � �I� �{�+�K��*� �*�(� (rS rr 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 )rr rp )rn s rQ rp zmr_class.__init__7 s � ��"�"�4��+rS N)rj r~ rk rm r| rp rz rS rQ r� r� " s � ��$ �I�,rS r� c # � K � t t j | � t | � j � D ] \ }}|s|�� �
|r�|d t
f�� � y�w)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$ r< r' r> )r` �
compressed�itr[ s rQ r$ r$ A 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 r1 r� N)r; rA r\ r r6 r� � flatnonzeror� )r` rX �unmaskeds rQ r r � sh � �\ ��
�A��F�{�"�&�&��)��x�x��A�F�F�Q�J��(�(��~�~�q�b�!�H�
�8�}�q����B�� � �rS c �@ � t | � } |�| j dk( r t | � S t | � }t t j | j � t j |g| j z � �� }t t | j � D �cg c]$ }|| j |� j � ��& c}� t t | j � D �cg c]$ }|| j |� j � ��& c}� gS c c}w c c}w )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])
r1 rZ )
r7 r� r r< r6 r\ �indicesr^ rN r� �minr� r� )r` rW rX r r� s rQ r& r& � s� � �V ��
�A� �|�q�v�v��{�"�1�%�%��Q��A�
��
�
�1�7�7�#�"�*�*�a�S�1�6�6�\�*B�
C�C� �%����-�H�Q�3�q�6�:�:�d�#�.�.�0�H� I� �%����-�H�Q�3�q�6�:�:�d�#�.�.�0�H� I� M� M��H��Hs �)D�%)D
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 )
r; rA 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� ��Q��L��� �M�M�%��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.Nr1 r0 ) r7 r� r r r� r� r^ r� rN )r` rW r� r� �otherr r� s rQ r% r% ) s� � �v ��
�A�
���B� �A�v�!�"J�K�K� �|�r�Q�w�'��*�*�
�F�
�A�X��N�E� �a�&�C��d�D�!�C��I�
�1�7�7�5�>�
"� ?����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.
r1 Nr� r0 c 3 �: K � | ] \ }}t ||� �� � y �wri )r� )r� �left�rights rQ r� z_ezclump.<locals>.<genexpr>� s% � �� � B�!�d�E� ��e�$� B�s �r� ) r� r� r r� r� r� �extendr� r� )r[ r �rr� r� s rQ �_ezclumpr� w s. � � �y�y�1�}��z�z�|�� ���8�d�3�B�i� �
(�
(�
*�C�
�a�&�1�*�C� �A�w� �s�8�q�=��!�T�Y�Y�'�(� (�
�1�c�!�f�
� �� ��� B�%(��Q�r�!�V��c�!�$�Q�$�i�%@�B� C� �s�8�q�=��I�36�s�5�B�q�5�z�3�q�t�!�t�9�3M� N�K�D�%�U�4��
� N�� N� �B�x� ����s�2�w�� � �*�+� �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 rA r� r� r� �r` r[ s rQ r r � s9 � �< �1�g�v� &�D� �v�~��a���� �!�!� �T�E�?�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 r; rA 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. r; rA )r� r� �_vanderrX s rQ r. r. � s1 � �
�i�i��1�o�G���
�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.
r1 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)
r7 r; r� r@ r rA r� r^ r\ r' )
r� rS �deg�rcond�full�wr rX �my�not_ms
rQ r' r' � s. � �
��
�A���
�A���
�A��v�v��{� �A�w�q�z� "��
���1��
�Y�q�\�
"��
�V� ���2�a��d�8�$�A��:�;�;��}� �A�J�� �6�6�Q�;�� >�?� ?� �7�7�1�:������ #�� F�G� G� �A�w�q�z� "�������� �=��%��A��z�z�!�E�(�A�e�H�c�5�$��3�G�G��z�z�!�Q��U�D�!�S�9�9rS ri )NNF)NNFF)NN)FF)F)NTT)NTFTN)T)NFNF)erm �__all__r� r � r2 rs r3 r4 r5 r6 r7 r8 r9 r: r; r< r= r> r? r@ rA rB rC rD rE rF r �numpyr\ rG r �numpy.lib.array_utilsrH rI � numpy.lib._function_base_implrJ � numpy.lib._index_tricks_implrK rR r rK 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 rr r� r# r$ r r& r r% r� r r r. ru r' rz rS rQ �<module>r� s� �� �
�� � � �� � � � � � � +� L� 2� 9�3�3�l "� :
�z=
�F2
� 2
�j-�_� -�$
)�/�
)��?� �2�o� �. %�\�
2�
�
$�\�
2�
�
$�\�
2�
�(��2� 2��� �X� &��"�>�2� � �X� &���G�$�� �� )�� !�*� -�� �O�` �.�.�6�6� � ��2 ���&� � 0� 0� 8� 8�1�� � � #� #� (� (�� 1� 3�39�6�8�,�. �O��be��[�[�e�PK5�\R
�j7�t5%�p$"�N&"�RV
�r �k�k� 0 �f �k�k� / �l#�L/�d )�B"�J-#�`6�:9�0@�D8!�v\�~ �t�"�+�+�D��+�+�J�` (�(� (�@,� � ,�0 �j��B �J5�p1M�h4�nK�\
�:!�H!�R � ����R�Y�Y� .� .����?��� :�D �"�+�+�b�j�j� 0� 0�'�/�/�B��rS