| Server IP : 217.160.0.135 / Your IP : 216.73.217.85 Web Server : Apache System : Linux www 6.18.52-i1-ampere #1203 SMP Mon Sep 14 18:29:59 CEST 2026 aarch64 User : sws1074145052 ( 1074145052) PHP Version : 8.3.32 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /lib/python3/dist-packages/scipy/stats/__pycache__/ |
Upload File : |
�
d�c�l � � � d Z ddlZddlZddlmZ ddlmZmZ ddlZddlm Z m
Z
m Z ddl m
Z
ddlmZ ddlmZ dd lmZ dd
lmZmZmZmZmZ ddlmZ dd l m Z d d
l m Z d dl m Z! d dl"m#Z#m$Z$m%Z%m&Z& d dl'm(Z(m)Z)m*Z*m+Z+ ddl,m-Z- d dl.m/Z/ d dl0m1Z1 d dl2m3Z3 d dl4m5Z5m6Z6 d dl7m8Z9 ddl:m;Z; ddl m<Z< ddl=m>Z> g d�Z?d� Z@d � ZAd � ZBd � ZCd � ZD e;d d!d"gg � � ZE e5d#� d d dd$d%� d&g�'� � d�d(�� � ZF e5d)� d d dd$d*� d&g�'� � d�dd+�d,�� � ZG e5d-� d d dd$d.� d&g�'� � dddd/�d0�� � ZH ed1d2� � ZId�d4�ZJd5� ZKd�d7�ZLd�d8�ZMd�d9�ZNd�d:�ZOd�d;�ZPd�d<�ZQd=� ZRd>� ZS e5eSd d?� eR�@� � d�dA�� � ZTddB�dC�ZU�d dD�ZV e5dE� dF� d �G� � �ddH�� � ZW e5dI� dJ� d �G� � �ddK�� � ZX edLdM� � ZY�ddN�ZZdO� Z[ edPdQ� � Z\�ddS�Z] edTdQ� � Z^�ddU�Z_ edVdQ� � Z`�ddW�Za e5eEd�X� � ddY�dZ�� � Zb �dd]�Zcd^� Zd�dd`�Ze edadb� � Zf �dde�Zg edfdg� � Zh�d dh�Zi edidj� � Zj�d dk�Zkdl� Zl�d
dm�Zmdn� Zndo� Zo�d dp�Zp�d dq�Zqddd3dr�ds�Zr�d dt�Zs�d
du�Ztdv eju dw� � dxz ejv dx� � z dy�Zw �dd|�Zxd}� Zydejz dvd3fd~�Z{ edd�� � Z|�dd��Z}�d d��Z~�dd��Z�d d��Z� ed�dQ� � Z�d�� Z�d�� Z�ddY�d��Z�d3d��d��Z�d�� Z� e-d�dQ� � Z�d�� Z� ed�d�d�g� � Z� e;d�d!d"gg � � Z� G d�� d�e�� � Z�dRd��d��Z��dd��Z� �dd��Z�d�� Z� �dd��Z��dd��Z� G d�� d�� � Z��dd��Z�d�� Z� e;d�g d��g � � Z�e�d�d dddfd��Z�d�� Z�d�� Z�d�� Z�d�� Z� e;d�d!d"gd�g� � Z� G d�� d�e�� � Z�d�� Z�d�� Z� e5e�dd�e�d���� � �dd��� � Z�d�� Z�d�� Z�d�� Z�d�� Z�d�� Z� ed�dQ� � Z� �dd��Z�d�� Z� �dd��Z�d�� Z�d�� Z� �dd��Z��ddZ� �ddÄZ�dĄ Z� e5e�dd�e�d�d$�Ŧ � �ddƄ� � Z�d dd�d�d�d�dʜZ��dd˄Z�d̄ Z� ed�dQ� � Z��dd΄Z��d dτZ� e;d�d!d"gd�d�g� � Z�dӄ Z�dԄ Z� ed�d֦ � �d dׄ� � Z�e�Z�d Z�dل Z�dڄ Z� ed�d֦ � �d dۄ� � Z�d܄ Z� ed�d֦ � �d dބ� � Z�d߄ Z� ed�dQ� � Z� e5e�d��� � �dd�� � Z� ed�dQ� � Z� e5e�d�� � d3d��d�� � Z� ed�dQ� � Z�d� Z� ed�dQ� � Z� �d d�Zɐd!d�Zʐd"d�Zːd"d�Z̐d"d�Z�d� Z� ed�d� � Z�d� ZАd d�Zѐd d�ZҐd#dd3d��d��ZӐd$dd+�d��Z�dS (% z�
A collection of basic statistical functions for Python.
References
----------
.. [CRCProbStat2000] Zwillinger, D. and Kokoska, S. (2000). CRC Standard
Probability and Statistics Tables and Formulae. Chapman & Hall: New
York. 2000.
� N)�gcd)�
namedtuple�Counter)�array�asarray�ma)� NumpyVersion)�suppress_warnings��cdist)�
_measurements)�check_random_state�
MapWrapper� rng_integers�_rename_parameter�
_contains_nan)�linalg� )�
distributions)�
_mstats_basic)�
_find_repeats�
linregress� theilslopes� siegelslopes)� _kendall_dis�_toint64�_weightedrankedtau�_local_correlations)�make_dataclass)�_all_partitions)�!_compute_outer_prob_inside_method)�_batch_generator)�_axis_nan_policy_factory�_broadcast_concatenate)� _binary_search_for_binom_tst)�_make_tuple_bunch)�stats)� root_scalar)B� find_repeats�gmean�hmean�pmean�mode�tmean�tvar�tmin�tmax�tstd�tsem�moment�skew�kurtosis�describe�skewtest� kurtosistest�
normaltest� jarque_bera�scoreatpercentile�percentileofscore�cumfreq�relfreq�obrientransform�sem�zmap�zscore�gzscore�iqr�gstd�median_abs_deviation� sigmaclip�trimboth�trim1� trim_mean�f_oneway�pearsonr� fisher_exact� spearmanr�pointbiserialr�
kendalltau� weightedtau�multiscale_graphcorrr r r � ttest_1samp� ttest_ind�ttest_ind_from_stats� ttest_rel�kstest�ks_1samp�ks_2samp� chisquare�power_divergence�
tiecorrect�ranksums�kruskal�friedmanchisquare�rankdata�combine_pvalues�wasserstein_distance�energy_distance�
brunnermunzel�alexandergovern� expectilec � � |�t j | � � } d}nt j | � � } |}| j dk rt j | � � } | |fS �Nr ��np�ravelr �ndim�
atleast_1d)�a�axis�outaxiss �7/usr/lib/python3/dist-packages/scipy/stats/_stats_py.py� _chk_asarrayrs X sQ � � �|� �H�Q�K�K����� �J�q�M�M�����v��{�{� �M�!� � �� �g�:�� c �6 � |�+t j | � � } t j |� � }d}n*t j | � � } t j |� � }|}| j dk rt j | � � } |j dk rt j |� � }| ||fS ri rj )ro �brp rq s rr �
_chk2_asarrayrw f s� � � �|� �H�Q�K�K�� �H�Q�K�K����� �J�q�M�M�� �J�q�M�M�����v��{�{� �M�!� � ���v��{�{� �M�!� � �� �a��=�rt c � � t | j � � } ||= n)# t $ r t j || j � � d�w xY wt
|� � S )z�
Given an array `a` and an integer `axis`, return the shape
of `a` with the `axis` dimension removed.
Examples
--------
>>> a = np.zeros((3, 5, 2))
>>> _shape_with_dropped_axis(a, 1)
(3, 2)
N)�list�shape�
IndexErrorrk � AxisErrorrm �tuple)ro rp �shps rr �_shape_with_dropped_axisr x s\ � � �q�w�-�-�C�3� ��I�I�� � 3� 3� 3��l�4���(�(�d�2�3���� ��:�:�s � �&A c �L � t | � � t |� � z
}|dk r d| z | z }|}n
| }d|z |z }g }t ||� � D ]H\ }}|dk r|}n%|dk s||k r|}nt d| � d|� d�� � �|� |� � �It |� � S )z�
Given two shapes (i.e. tuples of integers), return the shape
that would result from broadcasting two arrays with the given
shapes.
Examples
--------
>>> _broadcast_shapes((2, 1), (4, 1, 3))
(4, 2, 3)
r �r r zshapes � and � could not be broadcast together)�len�zip�
ValueError�appendr} ) �shape1�shape2�d�shp1�shp2rz �n1�n2�ns rr �_broadcast_shapesr� � s� � � �F� � �c�&�k�k�!�A��A�v�v��a�R�y�6�!��������A�v���� �E��d�D�/�/� � ���B�
��7�7��A�A�
�1�W�W��b����A�A� � 2�v� 2� 2�F� 2� 2� 2� 3� 3�
3�
� � �Q����� ��<�<�rt c � � t | |� � }t ||� � } t ||� � }n%# t $ r t d|� d|� d�� � d�w xY w|S )a=
Given two arrays `a` and `b` and an integer `axis`, find the
shape of the broadcast result after dropping `axis` from the
shapes of `a` and `b`.
Examples
--------
>>> a = np.zeros((5, 2, 1))
>>> b = np.zeros((1, 9, 3))
>>> _broadcast_shapes_with_dropped_axis(a, b, 1)
(5, 3)
znon-axis shapes r� r� N)r r� r� )ro rv rp r� r� r~ s rr �#_broadcast_shapes_with_dropped_axisr� � s� � � $�A�t� ,� ,�D� #�A�t� ,� ,�D�9� ��d�+�+���� � 9� 9� 9�� .�D� .� .�t� .� .� .� /� /�48� 9�9���� �Js �3 �"A�SignificanceResult� statistic�pvaluec � � | S �N� ��xs rr �<lambda>r� � � � �!� rt Tc � � | fS r� r� r� s rr r� r� � � � �1�$� rt �weights)� n_samples� n_outputs� too_small�paired�result_to_tuple� kwd_samplesc �2 � t j | |�� � } |�t j ||�� � }t j d�� � 5 t j | � � }ddd� � n # 1 swxY w Y t j t j |||�� � � � S )a� Compute the weighted geometric mean along the specified axis.
The weighted geometric mean of the array :math:`a_i` associated to weights
:math:`w_i` is:
.. math::
\exp \left( \frac{ \sum_{i=1}^n w_i \ln a_i }{ \sum_{i=1}^n w_i }
\right) \, ,
and, with equal weights, it gives:
.. math::
\sqrt[n]{ \prod_{i=1}^n a_i } \, .
Parameters
----------
a : array_like
Input array or object that can be converted to an array.
axis : int or None, optional
Axis along which the geometric mean is computed. Default is 0.
If None, compute over the whole array `a`.
dtype : dtype, optional
Type to which the input arrays are cast before the calculation is
performed.
weights : array_like, optional
The `weights` array must be broadcastable to the same shape as `a`.
Default is None, which gives each value a weight of 1.0.
Returns
-------
gmean : ndarray
See `dtype` parameter above.
See Also
--------
numpy.mean : Arithmetic average
numpy.average : Weighted average
hmean : Harmonic mean
References
----------
.. [1] "Weighted Geometric Mean", *Wikipedia*,
https://en.wikipedia.org/wiki/Weighted_geometric_mean.
Examples
--------
>>> from scipy.stats import gmean
>>> gmean([1, 4])
2.0
>>> gmean([1, 2, 3, 4, 5, 6, 7])
3.3800151591412964
>>> gmean([1, 4, 7], weights=[3, 1, 3])
2.80668351922014
��dtypeN�ignore��divide�rp r� )rk r �errstate�log�exp�average)ro rp r� r� �log_as rr r* r* � s� � �| �
�1�E�"�"�"�A����*�W�E�2�2�2�� ��H� %� %� %� � ���q� � ��� � � � � � � � � � ���� � � � � �6�"�*�U��w�?�?�?� @� @�@s �A%�%A)�,A)c � � | S r� r� r� s rr r� r� r� rt c � � | fS r� r� r� s rr r� r� r� rt �r� c �, � t | t j � � st j | |�� � } nY|rWt | t j j � � r"t j � | |�� � } nt j | |�� � } t j | dk � � rd|�t j ||�� � }t j d�� � 5 dt j
d| z ||�� � z cddd� � S # 1 swxY w Y dS t d� � �) a� Calculate the weighted harmonic mean along the specified axis.
The weighted harmonic mean of the array :math:`a_i` associated to weights
:math:`w_i` is:
.. math::
\frac{ \sum_{i=1}^n w_i }{ \sum_{i=1}^n \frac{w_i}{a_i} } \, ,
and, with equal weights, it gives:
.. math::
\frac{ n }{ \sum_{i=1}^n \frac{1}{a_i} } \, .
Parameters
----------
a : array_like
Input array, masked array or object that can be converted to an array.
axis : int or None, optional
Axis along which the harmonic mean is computed. Default is 0.
If None, compute over the whole array `a`.
dtype : dtype, optional
Type of the returned array and of the accumulator in which the
elements are summed. If `dtype` is not specified, it defaults to the
dtype of `a`, unless `a` has an integer `dtype` with a precision less
than that of the default platform integer. In that case, the default
platform integer is used.
weights : array_like, optional
The weights array can either be 1-D (in which case its length must be
the size of `a` along the given `axis`) or of the same shape as `a`.
Default is None, which gives each value a weight of 1.0.
.. versionadded:: 1.9
Returns
-------
hmean : ndarray
See `dtype` parameter above.
See Also
--------
numpy.mean : Arithmetic average
numpy.average : Weighted average
gmean : Geometric mean
Notes
-----
The harmonic mean is computed over a single dimension of the input
array, axis=0 by default, or all values in the array if axis=None.
float64 intermediate and return values are used for integer inputs.
References
----------
.. [1] "Weighted Harmonic Mean", *Wikipedia*,
https://en.wikipedia.org/wiki/Harmonic_mean#Weighted_harmonic_mean
.. [2] Ferger, F., "The nature and use of the harmonic mean", Journal of
the American Statistical Association, vol. 26, pp. 36-40, 1931
Examples
--------
>>> from scipy.stats import hmean
>>> hmean([1, 4])
1.6000000000000001
>>> hmean([1, 2, 3, 4, 5, 6, 7])
2.6997245179063363
>>> hmean([1, 4, 7], weights=[3, 1, 3])
1.9029126213592233
r� r Nr� r� � �?r� zHHarmonic mean only defined if all elements greater than or equal to zero) �
isinstancerk �ndarrayr r � MaskedArrayr �all�
asanyarrayr� r� r� )ro rp r� r� s rr r+ r+ sj � �T �a��� $� $� +� �H�Q�e� $� $� $��� � +� �a���*� +� +� +���
�
�a�u�
�-�-�A�A��
�1�E�*�*�*�A� �v�a�1�f�~�~� 2� � ��m�G�5�9�9�9�G�
�[��
)�
)�
)� I� I����C�!�G�$��H�H�H�H� I� I� I� I� I� I� I� I� I� I� I� I���� I� I� I� I� I� I� � 1� 2� 2� 2s � C:�:C>�C>c � � | S r� r� r� s rr r� r� p r� rt c � � | fS r� r� r� s rr r� r� q r� rt �rp r� r� c � � t |t t f� � st d� � �|dk rt | |||�� � S t | t
j � � st j | |�� � } nY|rWt | t
j j � � r"t
j �
| |�� � } nt j
| |�� � } t j | dk � � r�|�t j ||�� � }t j
d�� � 5 t j t j t j | |� � ||�� � d |z � � cddd� � S # 1 swxY w Y dS t d
� � �) u Calculate the weighted power mean along the specified axis.
The weighted power mean of the array :math:`a_i` associated to weights
:math:`w_i` is:
.. math::
\left( \frac{ \sum_{i=1}^n w_i a_i^p }{ \sum_{i=1}^n w_i }
\right)^{ 1 / p } \, ,
and, with equal weights, it gives:
.. math::
\left( \frac{ 1 }{ n } \sum_{i=1}^n a_i^p \right)^{ 1 / p } \, .
This mean is also called generalized mean or Hölder mean, and must not be
confused with the Kolmogorov generalized mean, also called
quasi-arithmetic mean or generalized f-mean [3]_.
Parameters
----------
a : array_like
Input array, masked array or object that can be converted to an array.
p : int or float
Exponent.
axis : int or None, optional
Axis along which the power mean is computed. Default is 0.
If None, compute over the whole array `a`.
dtype : dtype, optional
Type of the returned array and of the accumulator in which the
elements are summed. If `dtype` is not specified, it defaults to the
dtype of `a`, unless `a` has an integer `dtype` with a precision less
than that of the default platform integer. In that case, the default
platform integer is used.
weights : array_like, optional
The weights array can either be 1-D (in which case its length must be
the size of `a` along the given `axis`) or of the same shape as `a`.
Default is None, which gives each value a weight of 1.0.
Returns
-------
pmean : ndarray, see `dtype` parameter above.
Output array containing the power mean values.
See Also
--------
numpy.average : Weighted average
gmean : Geometric mean
hmean : Harmonic mean
Notes
-----
The power mean is computed over a single dimension of the input
array, ``axis=0`` by default, or all values in the array if ``axis=None``.
float64 intermediate and return values are used for integer inputs.
.. versionadded:: 1.9
References
----------
.. [1] "Generalized Mean", *Wikipedia*,
https://en.wikipedia.org/wiki/Generalized_mean
.. [2] Norris, N., "Convexity properties of generalized mean value
functions", The Annals of Mathematical Statistics, vol. 8,
pp. 118-120, 1937
.. [3] Bullen, P.S., Handbook of Means and Their Inequalities, 2003
Examples
--------
>>> from scipy.stats import pmean, hmean, gmean
>>> pmean([1, 4], 1.3)
2.639372938300652
>>> pmean([1, 2, 3, 4, 5, 6, 7], 1.3)
4.157111214492084
>>> pmean([1, 4, 7], -2, weights=[3, 1, 3])
1.4969684896631954
For p=-1, power mean is equal to harmonic mean:
>>> pmean([1, 4, 7], -1, weights=[3, 1, 3])
1.9029126213592233
>>> hmean([1, 4, 7], weights=[3, 1, 3])
1.9029126213592233
For p=0, power mean is defined as the geometric mean:
>>> pmean([1, 4, 7], 0, weights=[3, 1, 3])
2.80668351922014
>>> gmean([1, 4, 7], weights=[3, 1, 3])
2.80668351922014
z:Power mean only defined for exponent of type int or float.r r� r� Nr� r� r� r zEPower mean only defined if all elements greater than or equal to zero)r� �int�floatr� r* rk r� r r r� r r� r� r� � float_powerr� )ro �prp r� r� s rr r, r, o s� � �B �a�#�u� � &� &� #�� "� #� #� #��A�v�v��Q�T���@�@�@�@� �a��� $� $� +� �H�Q�e� $� $� $��� � +� �a���*� +� +� +���
�
�a�u�
�-�-�A�A��
�1�E�*�*�*�A� �v�a�1�f�~�~� 2� � ��m�G�5�9�9�9�G�
�[��
)�
)�
)� � ��>��
�2�>�!�Q�/�/�d�G�L�L�L��!��� � � � � � � � � � � � � ���� � � � � � �
� 1� 2� 2� 2s �A E!�!E%�(E%�
ModeResult)r- �count� propagatec �� � |� d}t j |t d�� � t j | � � } | j dk ro|�4t
t j g � � t j g � � � � S t j | ||�� � }t
||� � � � � S t | |� � \ } }t | |� � \ }}|r1|dk r+t j
| � � } t j | ||�� � S t j | j t j � � s t j d t& d�� � | j t( k rd
� }nd � }t j | |d � � }t j |j dd � � � } t j |j dd � | j �
� � }
t j |j dd � t j �
� � } | D ] } ||| � � \ |
| < | | < � |�|rOt5 | j � � }
d|
|< t
|
� |
� � | � |
� � � � S t
|
d | d � � S )ay Return an array of the modal (most common) value in the passed array.
If there is more than one such value, only one is returned.
The bin-count for the modal bins is also returned.
Parameters
----------
a : array_like
n-dimensional array of which to find mode(s).
axis : int or None, optional
Axis along which to operate. Default is 0. If None, compute over
the whole array `a`.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan.
The following options are available (default is 'propagate'):
* 'propagate': treats nan as it would treat any other value
* 'raise': throws an error
* 'omit': performs the calculations ignoring nan values
keepdims : bool, optional
If set to ``False``, the `axis` over which the statistic is taken
is consumed (eliminated from the output array) like other reduction
functions (e.g. `skew`, `kurtosis`). If set to ``True``, the `axis` is
retained with size one, and the result will broadcast correctly
against the input array. The default, ``None``, is undefined legacy
behavior retained for backward compatibility.
.. warning::
Unlike other reduction functions (e.g. `skew`, `kurtosis`), the
default behavior of `mode` usually retains the axis it acts
along. In SciPy 1.11.0, this behavior will change: the default
value of `keepdims` will become ``False``, the `axis` over which
the statistic is taken will be eliminated, and the value ``None``
will no longer be accepted.
.. versionadded:: 1.9.0
Returns
-------
mode : ndarray
Array of modal values.
count : ndarray
Array of counts for each mode.
Notes
-----
The mode of object arrays is calculated using `collections.Counter`, which
treats NaNs with different binary representations as distinct.
.. deprecated:: 1.9.0
Support for non-numeric arrays has been deprecated as of SciPy 1.9.0
and will be removed in 1.11.0. `pandas.DataFrame.mode`_ can
be used instead.
.. _pandas.DataFrame.mode: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.mode.html
The mode of arrays with other dtypes is calculated using `numpy.unique`.
In NumPy versions 1.21 and after, all NaNs - even those with different
binary representations - are treated as equivalent and counted as separate
instances of the same value.
Examples
--------
>>> import numpy as np
>>> a = np.array([[3, 0, 3, 7],
... [3, 2, 6, 2],
... [1, 7, 2, 8],
... [3, 0, 6, 1],
... [3, 2, 5, 5]])
>>> from scipy import stats
>>> stats.mode(a, keepdims=True)
ModeResult(mode=array([[3, 0, 6, 1]]), count=array([[4, 2, 2, 1]]))
To get mode of whole array, specify ``axis=None``:
>>> stats.mode(a, axis=None, keepdims=True)
ModeResult(mode=[3], count=[5])
>>> stats.mode(a, axis=None, keepdims=False)
ModeResult(mode=3, count=5)
Na� Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.� ��
stacklevelr �rp �keepdims�omit�r� z�Support for non-numeric arrays has been deprecated as of SciPy 1.9.0 and will be removed in 1.11.0. `pandas.DataFrame.mode` can be used instead, see https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.mode.html.c �^ �� t | � � �t ��fd��� � }|�| fS )Nc � �� �| S r� r� )r� �cntrs �rr r� z'mode.<locals>._mode1D.<locals>.<lambda>h s �� �4��7� rt )�key)r �max)ro r- r� s @rr �_mode1Dzmode.<locals>._mode1Df s9 �� ��1�:�:�D��t�!2�!2�!2�!2�3�3�3�D���d��#� #rt c � � t j | d�� � \ }}||� � � |� � � fS )NT��
return_counts)rk �unique�argmaxr� )ro �vals�cntss rr r� zmode.<locals>._mode1Dk s: � ���1�D�9�9�9�J�D�$��� � �
�
�&����
�
�2� 2rt ���r� r r� ) �warnings�warn�
FutureWarningrk r �sizer� r �mean�copyrs r r �masked_invalid� mstats_basic�_mode�
issubdtyper� �number�DeprecationWarning�object�moveaxis�ndindexrz �empty�int_ry �reshape)ro rp �
nan_policyr� �message�out� contains_nanr� �a_view�inds�modes�counts�ind�newshapes rr r- r- � sn � �d ��L�� �
�g�}��;�;�;�;�
�
�1�
�
�A��v��{�{� � � �b�h�r�l�l�B�H�R�L�L�9�9� 9� �'�!�$��:�:�:�C� �c�3�8�8�:�:�.�.� .��1�d�#�#�G�A�t� ,�Q�
� ;� ;� �L�*�� >�
�f�,�,� � �a� � ���!�!�T�H�=�=�=�=�
�=���"�)� ,� ,� 8��
� e� )�Q� 8� 8� 8� 8� �w�&��� $� $� $� $�
3� 3� 3� �[��D�"�
%�
%�F�
�:�f�l�3�B�3�'� (� (�D� �H�V�\�#�2�#�&�a�g� 6� 6� 6�E�
�X�f�l�3�B�3�'�r�w�
7�
7�
7�F�� 7� 7��")�'�&��+�"6�"6� ��c�
�F�3�K�K���8�����=�=�������%�-�-��1�1�6�>�>�(�3K�3K�L�L�L��%��)�V�B�Z�0�0�0rt c �L � |\ }}|\ }}t j | � � }|�-|rt j ||� � }nt j ||� � }|�-|rt j ||� � }nt j ||� � }|� � � dk rt d� � �|S )a� Mask an array for values outside of given limits.
This is primarily a utility function.
Parameters
----------
a : array
limits : (float or None, float or None)
A tuple consisting of the (lower limit, upper limit). Values in the
input array less than the lower limit or greater than the upper limit
will be masked out. None implies no limit.
inclusive : (bool, bool)
A tuple consisting of the (lower flag, upper flag). These flags
determine whether values exactly equal to lower or upper are allowed.
Returns
-------
A MaskedArray.
Raises
------
A ValueError if there are no values within the given limits.
Nr z#No array values within given limits)r r� � masked_less�masked_less_equal�masked_greater�masked_greater_equalr� r� )ro �limits� inclusive� lower_limit� upper_limit�
lower_include�
upper_include�ams rr �_mask_to_limitsr � s� � �2 &� �K��#,� �M�=� � �� � �B�� � � 7�� ��K�0�0�B�B��%�b�+�6�6�B�� � � :��"�2�{�3�3�B�B��(��[�9�9�B� �x�x�z�z�Q����>�?�?�?�
�Irt �TTc �0 � t | � � } |�t j | |� � S t | ||� � }t j � |� |�� � t j �� � }|j dk r|n|� � � S )a� Compute the trimmed mean.
This function finds the arithmetic mean of given values, ignoring values
outside the given `limits`.
Parameters
----------
a : array_like
Array of values.
limits : None or (lower limit, upper limit), optional
Values in the input array less than the lower limit or greater than the
upper limit will be ignored. When limits is None (default), then all
values are used. Either of the limit values in the tuple can also be
None representing a half-open interval.
inclusive : (bool, bool), optional
A tuple consisting of the (lower flag, upper flag). These flags
determine whether values exactly equal to the lower or upper limits
are included. The default value is (True, True).
axis : int or None, optional
Axis along which to compute test. Default is None.
Returns
-------
tmean : ndarray
Trimmed mean.
See Also
--------
trim_mean : Returns mean after trimming a proportion from both tails.
Examples
--------
>>> import numpy as np
>>> from scipy import stats
>>> x = np.arange(20)
>>> stats.tmean(x)
9.5
>>> stats.tmean(x, (3,17))
10.0
N�rp ��
fill_valuer ) r rk r� r r �filled�nanrm �item)ro r� r� rp r r� s rr r. r. � s{ � �T ��
�
�A�
�~��w�q�$� � � � ��F�I� .� .�B�
�5�<�<����T��*�*�r�v�<� >� >�D��9�q�=�=�4�4�d�i�i�k�k�1rt c � � t | � � } | � t � � } |�| � ||�� � S t | ||� � }|� t j �� � }t
j |||�� � S )a� Compute the trimmed variance.
This function computes the sample variance of an array of values,
while ignoring values which are outside of given `limits`.
Parameters
----------
a : array_like
Array of values.
limits : None or (lower limit, upper limit), optional
Values in the input array less than the lower limit or greater than the
upper limit will be ignored. When limits is None, then all values are
used. Either of the limit values in the tuple can also be None
representing a half-open interval. The default value is None.
inclusive : (bool, bool), optional
A tuple consisting of the (lower flag, upper flag). These flags
determine whether values exactly equal to the lower or upper limits
are included. The default value is (True, True).
axis : int or None, optional
Axis along which to operate. Default is 0. If None, compute over the
whole array `a`.
ddof : int, optional
Delta degrees of freedom. Default is 1.
Returns
-------
tvar : float
Trimmed variance.
Notes
-----
`tvar` computes the unbiased sample variance, i.e. it uses a correction
factor ``n / (n - 1)``.
Examples
--------
>>> import numpy as np
>>> from scipy import stats
>>> x = np.arange(20)
>>> stats.tvar(x)
35.0
>>> stats.tvar(x, (3,17))
20.0
N��ddofrp r ) r �astyper� �varr r rk r �nanvar)ro r� r� rp r r �amnans rr r/ r/ � sw � �\ ��
�
�A� ������A�
�~��u�u�$�T�u�*�*�*� ��F�I� .� .�B� �I�I���I� (� (�E�
�9�U��D� 1� 1� 1�1rt c �$ � t | |� � \ } }t | |df|df� � }t ||� � \ }}|r|dk rt j |� � }t j � ||� � j }|j dk r|d S |S )a� Compute the trimmed minimum.
This function finds the miminum value of an array `a` along the
specified axis, but only considering values greater than a specified
lower limit.
Parameters
----------
a : array_like
Array of values.
lowerlimit : None or float, optional
Values in the input array less than the given limit will be ignored.
When lowerlimit is None, then all values are used. The default value
is None.
axis : int or None, optional
Axis along which to operate. Default is 0. If None, compute over the
whole array `a`.
inclusive : {True, False}, optional
This flag determines whether values exactly equal to the lower limit
are included. The default value is True.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan.
The following options are available (default is 'propagate'):
* 'propagate': returns nan
* 'raise': throws an error
* 'omit': performs the calculations ignoring nan values
Returns
-------
tmin : float, int or ndarray
Trimmed minimum.
Examples
--------
>>> import numpy as np
>>> from scipy import stats
>>> x = np.arange(20)
>>> stats.tmin(x)
0
>>> stats.tmin(x, 13)
13
>>> stats.tmin(x, 13, inclusive=False)
14
NFr� r r� ) rs r r r r� �minimum�reduce�datarm )ro �
lowerlimitrp r� r� r r� �ress rr r0 r0 s� � �b �1�d�#�#�G�A�t� ��Z�� .��E�0B� C� C�B� ,�R�� <� <� �L�*�� #�
�f�,�,�
�
�r�
"�
"��
�*�
�
�B��
%�
%�
*�C�
�x�1�}�}��2�w�� �Jrt c �$ � t | |� � \ } }t | d|fd|f� � }t ||� � \ }}|r|dk rt j |� � }t j � ||� � j }|j dk r|d S |S )ax Compute the trimmed maximum.
This function computes the maximum value of an array along a given axis,
while ignoring values larger than a specified upper limit.
Parameters
----------
a : array_like
Array of values.
upperlimit : None or float, optional
Values in the input array greater than the given limit will be ignored.
When upperlimit is None, then all values are used. The default value
is None.
axis : int or None, optional
Axis along which to operate. Default is 0. If None, compute over the
whole array `a`.
inclusive : {True, False}, optional
This flag determines whether values exactly equal to the upper limit
are included. The default value is True.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan.
The following options are available (default is 'propagate'):
* 'propagate': returns nan
* 'raise': throws an error
* 'omit': performs the calculations ignoring nan values
Returns
-------
tmax : float, int or ndarray
Trimmed maximum.
Examples
--------
>>> import numpy as np
>>> from scipy import stats
>>> x = np.arange(20)
>>> stats.tmax(x)
19
>>> stats.tmax(x, 13)
13
>>> stats.tmax(x, 13, inclusive=False)
12
NFr� r r� ) rs r r r r� �maximumr r rm )ro �
upperlimitrp r� r� r r� r s rr r1 r1 Y s� � �` �1�d�#�#�G�A�t� ��T�:� .�� �0B� C� C�B� ,�R�� <� <� �L�*�� #�
�f�,�,�
�
�r�
"�
"��
�*�
�
�B��
%�
%�
*�C�
�x�1�}�}��2�w�� �Jrt c �L � t j t | ||||� � � � S )a� Compute the trimmed sample standard deviation.
This function finds the sample standard deviation of given values,
ignoring values outside the given `limits`.
Parameters
----------
a : array_like
Array of values.
limits : None or (lower limit, upper limit), optional
Values in the input array less than the lower limit or greater than the
upper limit will be ignored. When limits is None, then all values are
used. Either of the limit values in the tuple can also be None
representing a half-open interval. The default value is None.
inclusive : (bool, bool), optional
A tuple consisting of the (lower flag, upper flag). These flags
determine whether values exactly equal to the lower or upper limits
are included. The default value is (True, True).
axis : int or None, optional
Axis along which to operate. Default is 0. If None, compute over the
whole array `a`.
ddof : int, optional
Delta degrees of freedom. Default is 1.
Returns
-------
tstd : float
Trimmed sample standard deviation.
Notes
-----
`tstd` computes the unbiased sample standard deviation, i.e. it uses a
correction factor ``n / (n - 1)``.
Examples
--------
>>> import numpy as np
>>> from scipy import stats
>>> x = np.arange(20)
>>> stats.tstd(x)
5.9160797830996161
>>> stats.tstd(x, (3,17))
4.4721359549995796
)rk �sqrtr/ )ro r� r� rp r s rr r2 r2 � s% � �\ �7�4��6�9�d�D�9�9� :� :�:rt c � � t j | � � � � � } |�0| � |�� � t j | j � � z S t
| ||� � }t j t j � |||�� � � � }|t j |� � � � � z S )a� Compute the trimmed standard error of the mean.
This function finds the standard error of the mean for given
values, ignoring values outside the given `limits`.
Parameters
----------
a : array_like
Array of values.
limits : None or (lower limit, upper limit), optional
Values in the input array less than the lower limit or greater than the
upper limit will be ignored. When limits is None, then all values are
used. Either of the limit values in the tuple can also be None
representing a half-open interval. The default value is None.
inclusive : (bool, bool), optional
A tuple consisting of the (lower flag, upper flag). These flags
determine whether values exactly equal to the lower or upper limits
are included. The default value is (True, True).
axis : int or None, optional
Axis along which to operate. Default is 0. If None, compute over the
whole array `a`.
ddof : int, optional
Delta degrees of freedom. Default is 1.
Returns
-------
tsem : float
Trimmed standard error of the mean.
Notes
-----
`tsem` uses unbiased sample standard deviation, i.e. it uses a
correction factor ``n / (n - 1)``.
Examples
--------
>>> import numpy as np
>>> from scipy import stats
>>> x = np.arange(20)
>>> stats.tsem(x)
1.3228756555322954
>>> stats.tsem(x, (3,17))
1.1547005383792515
N�r r )
rk r rl �stdr r� r r r r� )ro r� r� rp r r �sds rr r3 r3 � s� � �\ �
�1�
�
��� � �A�
�~��u�u�$�u� � �"�'�!�&�/�/�1�1� ��F�I� .� .�B� ������2�D�t��4�4� 5� 5�B�
������
�
�#�#� #�#rt c � � t j | � dd� � � � }|j dk rt d� � �t |� � S )Nr4 r r z7'moment' must be a scalar or a non-empty 1D list/array.)rk rn �getr� r� r� )�kwdsr4 s rr �_moment_outputsr' sO � �
�]�4�8�8�H�a�0�0�
1�
1�F�
�{�a���� '� (� (� (� �v�;�;�rt c �` � t | � � dk r| d S t j | � � S )Nr r )r� rk r )�argss rr �_moment_result_objectr* s* � �
�4�y�y�A�~�~��A�w��
�:�d� � �rt c � � | fS r� r� r� s rr r� r� ) s � �1�$� rt )r� r� r� c �x � ��� t � �� � \ � �t � |� � \ }}|r0|dk r*t j � � � � t j � |�� � S t
j |� � s;� � �d�� � �� ��fd�|D � � }t
j |� � S t � |�� � S )a
Calculate the nth moment about the mean for a sample.
A moment is a specific quantitative measure of the shape of a set of
points. It is often used to calculate coefficients of skewness and kurtosis
due to its close relationship with them.
Parameters
----------
a : array_like
Input array.
moment : int or array_like of ints, optional
Order of central moment that is returned. Default is 1.
axis : int or None, optional
Axis along which the central moment is computed. Default is 0.
If None, compute over the whole array `a`.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan.
The following options are available (default is 'propagate'):
* 'propagate': returns nan
* 'raise': throws an error
* 'omit': performs the calculations ignoring nan values
Returns
-------
n-th central moment : ndarray or float
The appropriate moment along the given axis or over all values if axis
is None. The denominator for the moment calculation is the number of
observations, no degrees of freedom correction is done.
See Also
--------
kurtosis, skew, describe
Notes
-----
The k-th central moment of a data sample is:
.. math::
m_k = \frac{1}{n} \sum_{i = 1}^n (x_i - \bar{x})^k
Where n is the number of samples and x-bar is the mean. This function uses
exponentiation by squares [1]_ for efficiency.
Note that, if `a` is an empty array (``a.size == 0``), array `moment` with
one element (`moment.size == 1`) is treated the same as scalar `moment`
(``np.isscalar(moment)``). This might produce arrays of unexpected shape.
References
----------
.. [1] https://eli.thegreenplace.net/2009/03/21/efficient-integer-exponentiation-algorithms
Examples
--------
>>> from scipy.stats import moment
>>> moment([1, 2, 3, 4, 5], moment=1)
0.0
>>> moment([1, 2, 3, 4, 5], moment=2)
2.0
r� Tr� c �6 �� g | ]}t �|��� � � ��S )�r� )�_moment)�.0�iro rp r� s ���rr �
<listcomp>zmoment.<locals>.<listcomp>v s* �� �?�?�?�1���1�d��.�.�.�?�?�?rt ) rs r r r� r� r4 rk �isscalarr� r r/ )ro r4 rp r� r� �mmntr� s ` ` @rr r4 r4 ( s� ���� �F �1�d�#�#�G�A�t� ,�Q�
� ;� ;� �L�*�� 4�
�f�,�,� � �a� � ���"�1�f�d�3�3�3� �;�v� � � (��v�v�d�T�v�*�*��?�?�?�?�?�?��?�?�?���x��~�~� ��q�&�$�'�'�'rt r. c �D � t j |t j |� � z
� � dk rt d� � �| j dk rt j | |�� � S |dk s|dk r�t
| j � � }||= | j j dv r | j j
n t j }t |� � dk r ||dk rdnd� � S |dk rt j
||�� � nt j ||�� � S |g}|}|d k r.|d z r |dz
d z }n|d z }|� |� � |d k �.|�| � |d
� � � n|}| |z
}t j |j � � j d z } t j d
d
�� � 5 t j t j |� � |d
�� � t j |� � z }
d d d � � n # 1 swxY w Y t j d
�� � 5 t j |
| k � � } d d d � � n # 1 swxY w Y | r d} t+ j | t. d�� � |d dk r|� � � }
n|d z }
|dd d� D ]}|
d z }
|d z r|
|z }
�t j |
|� � S )Nr z&All moment parameters must be integersr r �fcr� � r� r� Tr� �
r� �r� �invalidr� �r: z�Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.� r� r� ���)rk �abs�roundr� r� r� ry rz r� �kind�type�float64r� �ones�zerosr� �finfo�
resolutionr� r� �anyr� r� �RuntimeWarningr� )ro r4 rp r� rz r� �n_list� current_n� a_zero_mean�eps�rel_diff�precision_lossr� �sr� s rr r/ r/ } sT � � �v�f�r�x��'�'�'�(�(�1�,�,��A�B�B�B� �v��{�{��w�q�t�$�$�$�$�
��{�{�f��k�k� �Q�W�
�
�� �$�K� !�� �� 4� 4��� � �"�*�� �u�:�:��?�?��5��!� � ����5�5� 5�39�Q�;�;�B�G�E��/�/�/�/���%�u�5�5�5�
7� ���� ��!�m�m��1�}�
� &��]�a� /� � ��Q�� � �M�M�)� $� $� $� �!�m�m� /3�l�q�v�v�d�T�v�*�*�*����$�h� ��h�{�(�)�)�4�r�9��
�[��(�
;�
;�
;� <� <��v�b�f�[� 1� 1��'+�-� -� -�/1�v�d�|�|�<�H� <� <� <� <� <� <� <� <� <� <� <���� <� <� <� <� �[��
*�
*�
*� 4� 4� �V�H�s�N� 3� 3�N� 4� 4� 4� 4� 4� 4� 4� 4� 4� 4� 4���� 4� 4� 4� 4� � A�J�G�
�M�'�>�a� @� @� @� @� �"�:��?�?�� � �"�"�A�A��Q��A� ���B�� � !� !�A��1��A��1�u�
!��[� ����w�q�$� � � s$ �?G�G �!G �:H � H#�&H#c � � t | d||�� � }|dk r1|�
| j | n| j }|t j |||z
� � z }|S )Nr� r. r )r/ rz r� rk r� )r� rp r r� r r� s rr �_varrQ � sV � �
�!�Q��4�
(�
(�
(�C� �q�y�y� !� -�A�G�D�M�M�1�6�� �r�y��A�d�F�#�#�#�� �Jrt c � � | S r� r� r� s rr r� r� � � � �a� rt c � � | fS r� r� r� s rr r� r� � � � �A�4� rt )r� r� c � � t | |� � \ } }| j | }t | |� � \ }}|r0|dk r*t j | � � } t j | ||� � S | � |d�� � }t | d||�� � }t | d||�� � }t j
d�� � 5 |t j |j � � j
|� |� � z dz k } t j | t j ||d z z � � }
d
d
d
� � n # 1 swxY w Y |s�| |dk z } | � � � rit j | |� � }t j | |� � }t j |d z
|z � � |d z
z |z |d z z } t j |
| | � � |
j d
k r|
� � � S |
S )a� Compute the sample skewness of a data set.
For normally distributed data, the skewness should be about zero. For
unimodal continuous distributions, a skewness value greater than zero means
that there is more weight in the right tail of the distribution. The
function `skewtest` can be used to determine if the skewness value
is close enough to zero, statistically speaking.
Parameters
----------
a : ndarray
Input array.
axis : int or None, optional
Axis along which skewness is calculated. Default is 0.
If None, compute over the whole array `a`.
bias : bool, optional
If False, then the calculations are corrected for statistical bias.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan.
The following options are available (default is 'propagate'):
* 'propagate': returns nan
* 'raise': throws an error
* 'omit': performs the calculations ignoring nan values
Returns
-------
skewness : ndarray
The skewness of values along an axis, returning NaN where all values
are equal.
Notes
-----
The sample skewness is computed as the Fisher-Pearson coefficient
of skewness, i.e.
.. math::
g_1=\frac{m_3}{m_2^{3/2}}
where
.. math::
m_i=\frac{1}{N}\sum_{n=1}^N(x[n]-\bar{x})^i
is the biased sample :math:`i\texttt{th}` central moment, and
:math:`\bar{x}` is
the sample mean. If ``bias`` is False, the calculations are
corrected for bias and the value computed is the adjusted
Fisher-Pearson standardized moment coefficient, i.e.
.. math::
G_1=\frac{k_3}{k_2^{3/2}}=
\frac{\sqrt{N(N-1)}}{N-2}\frac{m_3}{m_2^{3/2}}.
References
----------
.. [1] Zwillinger, D. and Kokoska, S. (2000). CRC Standard
Probability and Statistics Tables and Formulae. Chapman & Hall: New
York. 2000.
Section 2.2.24.1
Examples
--------
>>> from scipy.stats import skew
>>> skew([1, 2, 3, 4, 5])
0.0
>>> skew([2, 8, 0, 4, 1, 9, 9, 0])
0.2650554122698573
r� Tr� r� r. � r� �r� � �?Nr� � @r )rs rz r r r� r� r5 r� r/ rk r� rE r� rF �squeeze�wherer rG �extractr �placerm r
)
ro rp �biasr� r� r� r� �m2�m3�zeror� � can_correct�nvals
rr r5 r5 � s � �Z �1�d�#�#�G�A�t� ���
�A� ,�Q�
� ;� ;� �L�*�� 0�
�f�,�,� � �a� � ��� ��D�$�/�/�/� �6�6�$��6� &� &�D� ��A�t�$� '� '� '�B� ��A�t�$� '� '� '�B� ��� "� "� "� 4� 4��r�x���)�)�4�t�|�|�D�7I�7I�I�A�M�M���x��b�f�b�2�s�7�l�3�3��4� 4� 4� 4� 4� 4� 4� 4� 4� 4� 4���� 4� 4� 4� 4� � .��e�q�1�u�o� � �?�?� � � .���K��,�,�B���K��,�,�B��7�A��G�q�=�)�)�Q��W�5��:�R��W�D�D� �H�T�;�� -� -� -� �y�A�~�~��y�y�{�{�� �Ks �8A"D&�&D*�-D*c � � | S r� r� r� s rr r� r� - rS rt c � � | fS r� r� r� s rr r� r� - rU rt c �� � t | |� � \ } }t | |� � \ }}|r1|dk r+t j | � � } t j | |||� � S | j | }| � |d�� � }t | d||�� � }t | d||�� � } t j
d�� � 5 |t j |j � � j
|� |� � z dz k }
t j |
t j | |d z z � � } d
d
d
� � n # 1 swxY w Y |s�|
|d k z } | � � � rot j | |� � }t j | | � � } d |dz
z |d z
z |dz d z
| z |d z z d |d
z
d z z z
z }
t j | | |
dz � � | j dk r| � � � } |r| d z
n| S )a� Compute the kurtosis (Fisher or Pearson) of a dataset.
Kurtosis is the fourth central moment divided by the square of the
variance. If Fisher's definition is used, then 3.0 is subtracted from
the result to give 0.0 for a normal distribution.
If bias is False then the kurtosis is calculated using k statistics to
eliminate bias coming from biased moment estimators
Use `kurtosistest` to see if result is close enough to normal.
Parameters
----------
a : array
Data for which the kurtosis is calculated.
axis : int or None, optional
Axis along which the kurtosis is calculated. Default is 0.
If None, compute over the whole array `a`.
fisher : bool, optional
If True, Fisher's definition is used (normal ==> 0.0). If False,
Pearson's definition is used (normal ==> 3.0).
bias : bool, optional
If False, then the calculations are corrected for statistical bias.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan. 'propagate' returns nan,
'raise' throws an error, 'omit' performs the calculations ignoring nan
values. Default is 'propagate'.
Returns
-------
kurtosis : array
The kurtosis of values along an axis, returning NaN where all values
are equal.
References
----------
.. [1] Zwillinger, D. and Kokoska, S. (2000). CRC Standard
Probability and Statistics Tables and Formulae. Chapman & Hall: New
York. 2000.
Examples
--------
In Fisher's definiton, the kurtosis of the normal distribution is zero.
In the following example, the kurtosis is close to zero, because it was
calculated from the dataset, not from the continuous distribution.
>>> import numpy as np
>>> from scipy.stats import norm, kurtosis
>>> data = norm.rvs(size=1000, random_state=3)
>>> kurtosis(data)
-0.06928694200380558
The distribution with a higher kurtosis has a heavier tail.
The zero valued kurtosis of the normal distribution in Fisher's definition
can serve as a reference point.
>>> import matplotlib.pyplot as plt
>>> import scipy.stats as stats
>>> from scipy.stats import kurtosis
>>> x = np.linspace(-5, 5, 100)
>>> ax = plt.subplot()
>>> distnames = ['laplace', 'norm', 'uniform']
>>> for distname in distnames:
... if distname == 'uniform':
... dist = getattr(stats, distname)(loc=-2, scale=4)
... else:
... dist = getattr(stats, distname)
... data = dist.rvs(size=1000)
... kur = kurtosis(data, fisher=True)
... y = dist.pdf(x)
... ax.plot(x, y, label="{}, {}".format(distname, round(kur, 3)))
... ax.legend()
The Laplace distribution has a heavier tail than the normal distribution.
The uniform distribution (which has negative kurtosis) has the thinnest
tail.
r� Tr� r� r. r< r� rX rZ NrW r� r � @r )rs r r r� r� r6 rz r� r/ rk r� rE r� rF r[ r\ r rG r] r^ rm r
)ro rp �fisherr_ r� r� r� r� r` �m4rb r� rc rd s rr r6 r6 , s5 � �h �1�d�#�#�G�A�t� ,�Q�
� ;� ;� �L�*�� <�
�f�,�,� � �a� � ���$�Q��f�d�;�;�;� ���
�A� �6�6�$��6� &� &�D� ��A�t�$� '� '� '�B� ��A�t�$� '� '� '�B� ��� "� "� "� 4� 4��r�x���)�)�4�t�|�|�D�7I�7I�I�A�M�M���x��b�f�b�2�s�7�l�3�3��4� 4� 4� 4� 4� 4� 4� 4� 4� 4� 4���� 4� 4� 4� 4� � 4��e�q�1�u�o� � �?�?� � � 4���K��,�,�B���K��,�,�B���!��9�a��c�?�q�!�t�C�x��m�B��G�&;�a��1��s�
�l�&J�K�D� �H�T�;��s�
� 3� 3� 3� �y�A�~�~��y�y�{�{�� � '�4�!�8�8�4�'s �9A"D'�'D+�.D+�DescribeResult)�nobs�minmaxr� �variance�skewnessr6 c � � t | |� � \ } }t | |� � \ }}|r1|dk r+t j | � � } t j | |||� � S | j dk rt d� � �| j | }t j
| |�� � t j | |�� � f}t j | |�� � }t | ||�� � } t | ||�� � }
t | ||�� � } t! |||| |
| � � S )aw Compute several descriptive statistics of the passed array.
Parameters
----------
a : array_like
Input data.
axis : int or None, optional
Axis along which statistics are calculated. Default is 0.
If None, compute over the whole array `a`.
ddof : int, optional
Delta degrees of freedom (only for variance). Default is 1.
bias : bool, optional
If False, then the skewness and kurtosis calculations are corrected
for statistical bias.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan.
The following options are available (default is 'propagate'):
* 'propagate': returns nan
* 'raise': throws an error
* 'omit': performs the calculations ignoring nan values
Returns
-------
nobs : int or ndarray of ints
Number of observations (length of data along `axis`).
When 'omit' is chosen as nan_policy, the length along each axis
slice is counted separately.
minmax: tuple of ndarrays or floats
Minimum and maximum value of `a` along the given axis.
mean : ndarray or float
Arithmetic mean of `a` along the given axis.
variance : ndarray or float
Unbiased variance of `a` along the given axis; denominator is number
of observations minus one.
skewness : ndarray or float
Skewness of `a` along the given axis, based on moment calculations
with denominator equal to the number of observations, i.e. no degrees
of freedom correction.
kurtosis : ndarray or float
Kurtosis (Fisher) of `a` along the given axis. The kurtosis is
normalized so that it is zero for the normal distribution. No
degrees of freedom are used.
See Also
--------
skew, kurtosis
Examples
--------
>>> import numpy as np
>>> from scipy import stats
>>> a = np.arange(10)
>>> stats.describe(a)
DescribeResult(nobs=10, minmax=(0, 9), mean=4.5,
variance=9.166666666666666, skewness=0.0,
kurtosis=-1.2242424242424244)
>>> b = [[1, 2], [3, 4]]
>>> stats.describe(b)
DescribeResult(nobs=2, minmax=(array([1, 2]), array([3, 4])),
mean=array([2., 3.]), variance=array([2., 2.]),
skewness=array([0., 0.]), kurtosis=array([-2., -2.]))
r� r z The input must not be empty.r �rp r )r_ )rs r r r� r� r7 r� r� rz rk �minr� r� rQ r5 r6 rk ) ro rp r r_ r� r� r� �mm�m�v�sk�kurts rr r7 r7 � s � �B �1�d�#�#�G�A�t� ,�Q�
� ;� ;� �L�*�� :�
�f�,�,� � �a� � ���$�Q��d�D�9�9�9��v��{�{��7�8�8�8� ���
�A�
�&���
�
�
���q�t� 4� 4� 4� 5�B�
���� � � �A� �Q�T��%�%�%�A�
�a��D� !� !� !�B� �A�t�$� '� '� '�D� �!�R��A�r�4� 0� 0�0rt c �\ � |dk r t j � | � � }np|dk r t j � | � � }nJ|dk r5dt j � t j | � � � � z }nt
d� � �| j dk r| d } | |fS )z5Common code between all the normality-test functions.�less�greater� two-sidedr� �4alternative must be 'less', 'greater' or 'two-sided'r r� )r �norm�cdf�sfrk r> r� rm )�z� alternative�probs rr �_normtest_finishr� � s� � ��f� � � �!�%�%�a�(�(��� � � !� !� �!�$�$�Q�'�'��� � � #� #��=�%�(�(������3�3�3���� <� =� =� =� �v��{�{�
�b�E�� �d�7�Nrt �SkewtestResult)r� r� r{ c � � t | |� � \ } }t | |� � \ }}|r0|dk r*t j | � � } t j | ||� � S |�t
j | � � } d}t | |� � }| j | }|dk r t dt |� � z � � �|t j
|dz |dz z d|d z
z z � � z }d
|d z d |z z d z
z |dz z |dz z |d
z
|dz z |dz z |dz z z }dt j
d |dz
z � � z } dt j
dt j | � � z � � z }
t j
d
| dz
z � � } t
j |dk d|� � }|
t
j || z t
j
|| z d z dz � � z � � z } t! t# | |� � � S )a�
Test whether the skew is different from the normal distribution.
This function tests the null hypothesis that the skewness of
the population that the sample was drawn from is the same
as that of a corresponding normal distribution.
Parameters
----------
a : array
The data to be tested.
axis : int or None, optional
Axis along which statistics are calculated. Default is 0.
If None, compute over the whole array `a`.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan.
The following options are available (default is 'propagate'):
* 'propagate': returns nan
* 'raise': throws an error
* 'omit': performs the calculations ignoring nan values
alternative : {'two-sided', 'less', 'greater'}, optional
Defines the alternative hypothesis. Default is 'two-sided'.
The following options are available:
* 'two-sided': the skewness of the distribution underlying the sample
is different from that of the normal distribution (i.e. 0)
* 'less': the skewness of the distribution underlying the sample
is less than that of the normal distribution
* 'greater': the skewness of the distribution underlying the sample
is greater than that of the normal distribution
.. versionadded:: 1.7.0
Returns
-------
statistic : float
The computed z-score for this test.
pvalue : float
The p-value for the hypothesis test.
Notes
-----
The sample size must be at least 8.
References
----------
.. [1] R. B. D'Agostino, A. J. Belanger and R. B. D'Agostino Jr.,
"A suggestion for using powerful and informative tests of
normality", American Statistician 44, pp. 316-321, 1990.
Examples
--------
>>> from scipy.stats import skewtest
>>> skewtest([1, 2, 3, 4, 5, 6, 7, 8])
SkewtestResult(statistic=1.0108048609177787, pvalue=0.3121098361421897)
>>> skewtest([2, 8, 0, 4, 1, 9, 9, 0])
SkewtestResult(statistic=0.44626385374196975, pvalue=0.6554066631275459)
>>> skewtest([1, 2, 3, 4, 5, 6, 7, 8000])
SkewtestResult(statistic=3.571773510360407, pvalue=0.0003545719905823133)
>>> skewtest([100, 100, 100, 100, 100, 100, 100, 101])
SkewtestResult(statistic=3.5717766638478072, pvalue=0.000354567720281634)
>>> skewtest([1, 2, 3, 4, 5, 6, 7, 8], alternative='less')
SkewtestResult(statistic=1.0108048609177787, pvalue=0.8439450819289052)
>>> skewtest([1, 2, 3, 4, 5, 6, 7, 8], alternative='greater')
SkewtestResult(statistic=1.0108048609177787, pvalue=0.15605491807109484)
r� Nr � zFskewtest is not valid with less than 8 samples; %i samples were given.r rW � @r� rh � �F rZ � � � r� � �?)rs r r r� r� r8 rk rl r5 rz r� r� �mathr r� r\ r� r� )
ro rp r� r� r� �b2r� �y�beta2�W2�delta�alpha�Zs
rr r8 r8 s� � �J �1�d�#�#�G�A�t� ,�Q�
� ;� ;� �L�*�� ;�
�f�,�,� � �a� � ���$�Q��k�:�:�:� �|� �H�Q�K�K����
�a�� � �B� ���
�A��1�u�u��
� ��V�V�
$�%� %� %� �T�Y��Q��1�q�5�)�c�Q��U�m�<�
=�
=�=�A�
�A�q�D�2�a�4�K�"�$�
%��1��
-��1��
5���u��1��o��1��%��1��-�/�E� �d�i��U�Q�Y��(�(� (�B�
�� �#���� � �,�-�-� -�E� �I�c�R�!�V�n� %� %�E�
���a���A� � �A�
���q�5�y�2�7�A��I��>�A�+=�#>�#>�>�?�?�?�A� �+�A�{�;�;� <�<rt �KurtosistestResultc � � t | |� � \ } }t | |� � \ }}|r0|dk r*t j | � � } t j | ||� � S | j | }|dk r t dt |� � z � � �|dk r$t j
dt |� � z � � t | |d�� � }d|d z
z |d z z }d
|z |d z
z |d z
z |d z |d
z z |d z z |dz z z }||z
t j
|� � z } d||z d|z z
d z z |dz |dz z z t j
d|d z z |dz z ||d z
z |d z
z z � � z }
dd|
z d|
z t j
d d|
d z z z � � z z z } d d d| z z z
} d | t j
d | dz
z � � z z }
t j |
� � t j |
dk t j t j d d| z z
t j |
� � z d� � � � z }t j |
dk � � r d}t j
|t( � � | |z
t j
d d| z z � � z }t+ t- ||� � � S )a� Test whether a dataset has normal kurtosis.
This function tests the null hypothesis that the kurtosis
of the population from which the sample was drawn is that
of the normal distribution.
Parameters
----------
a : array
Array of the sample data.
axis : int or None, optional
Axis along which to compute test. Default is 0. If None,
compute over the whole array `a`.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan.
The following options are available (default is 'propagate'):
* 'propagate': returns nan
* 'raise': throws an error
* 'omit': performs the calculations ignoring nan values
alternative : {'two-sided', 'less', 'greater'}, optional
Defines the alternative hypothesis.
The following options are available (default is 'two-sided'):
* 'two-sided': the kurtosis of the distribution underlying the sample
is different from that of the normal distribution
* 'less': the kurtosis of the distribution underlying the sample
is less than that of the normal distribution
* 'greater': the kurtosis of the distribution underlying the sample
is greater than that of the normal distribution
.. versionadded:: 1.7.0
Returns
-------
statistic : float
The computed z-score for this test.
pvalue : float
The p-value for the hypothesis test.
Notes
-----
Valid only for n>20. This function uses the method described in [1]_.
References
----------
.. [1] see e.g. F. J. Anscombe, W. J. Glynn, "Distribution of the kurtosis
statistic b2 for normal samples", Biometrika, vol. 70, pp. 227-234, 1983.
Examples
--------
>>> import numpy as np
>>> from scipy.stats import kurtosistest
>>> kurtosistest(list(range(20)))
KurtosistestResult(statistic=-1.7058104152122062, pvalue=0.08804338332528348)
>>> kurtosistest(list(range(20)), alternative='less')
KurtosistestResult(statistic=-1.7058104152122062, pvalue=0.04402169166264174)
>>> kurtosistest(list(range(20)), alternative='greater')
KurtosistestResult(statistic=-1.7058104152122062, pvalue=0.9559783083373583)
>>> rng = np.random.default_rng()
>>> s = rng.normal(0, 1, 1000)
>>> kurtosistest(s)
KurtosistestResult(statistic=-1.475047944490622, pvalue=0.14019965402996987)
r� r� zJkurtosistest requires at least 5 observations; %i observations were given.� z=kurtosistest only valid for n>=20 ... continuing anyway, n=%iF)ri rh r g 8@r� rW r� r� r� r� g @rZ � @g "@r7 gUUUUUU�?r z\Test statistic not defined in some cases due to division by zero. Return nan in that case...)rs r r r� r� r9 rz r� r� r� r� r6 rk r �signr\ r �powerr> rG rH r� r� )ro rp r� r� r� r� r� �E�varb2r� � sqrtbeta1�A�term1�denom�term2�msgr� s rr r9 r9 v s� � �H �1�d�#�#�G�A�t� ,�Q�
� ;� ;� �L�*�� ?�
�f�,�,� � �a� � ���(��D�+�>�>�>� ���
�A��1�u�u��
� ��V�V�
$�%� %� %� �2�v�v��
� %�'*�1�v�v�.� /� /� /� �!�T�%� (� (� (�B� �Q�q�S� �Q�q�S��A� ��F�A�a�C�L�!�A�#� �1�Q�3��2��,��!��"4�a��c�":� ;�E� �A����� � � �A��Q�q�S��1��W�Q�Y��!�A�#��!���-����a��c��A�a�C� �9:�A�a�C��!�A�#� �9H� 1I� 1I� I�I� �c�)�m�s�9�}�r�w�q��i��l�9K�7K�/L�/L� L�M�M�A�
��3�q�5� �M�E�
��"�'�!�Q�s�U�)�$�$�$� $�E� �G�E�N�N�R�X�e�s�l�B�F�&(�h��#�a�%����� � �/F��&N�&N� P� P�
P�E� �v�e�q�j��� +�1���
�c�>�*�*�*� �� �"�'�!�S��U�)�,�,�,�A� � /��;� ?� ?� @�@rt �NormaltestResultc �n � t | |� � \ } }t | |� � \ }}|r/|dk r)t j | � � } t j | |� � S t
| |� � \ }}t | |� � \ }}||z ||z z }t |t j
� |d� � � � S )a Test whether a sample differs from a normal distribution.
This function tests the null hypothesis that a sample comes
from a normal distribution. It is based on D'Agostino and
Pearson's [1]_, [2]_ test that combines skew and kurtosis to
produce an omnibus test of normality.
Parameters
----------
a : array_like
The array containing the sample to be tested.
axis : int or None, optional
Axis along which to compute test. Default is 0. If None,
compute over the whole array `a`.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan.
The following options are available (default is 'propagate'):
* 'propagate': returns nan
* 'raise': throws an error
* 'omit': performs the calculations ignoring nan values
Returns
-------
statistic : float or array
``s^2 + k^2``, where ``s`` is the z-score returned by `skewtest` and
``k`` is the z-score returned by `kurtosistest`.
pvalue : float or array
A 2-sided chi squared probability for the hypothesis test.
References
----------
.. [1] D'Agostino, R. B. (1971), "An omnibus test of normality for
moderate and large sample size", Biometrika, 58, 341-348
.. [2] D'Agostino, R. and Pearson, E. S. (1973), "Tests for departure from
normality", Biometrika, 60, 613-622
Examples
--------
>>> import numpy as np
>>> from scipy import stats
>>> rng = np.random.default_rng()
>>> pts = 1000
>>> a = rng.normal(0, 1, size=pts)
>>> b = rng.normal(2, 1, size=pts)
>>> x = np.concatenate((a, b))
>>> k2, p = stats.normaltest(x)
>>> alpha = 1e-3
>>> print("p = {:g}".format(p))
p = 8.4713e-19
>>> if p < alpha: # null hypothesis: x comes from a normal distribution
... print("The null hypothesis can be rejected")
... else:
... print("The null hypothesis cannot be rejected")
The null hypothesis can be rejected
r� r� ) rs r r r� r� r: r8 r9 r� r �chi2r )ro rp r� r� rO �_�k�k2s rr r: r: � s� � �v �1�d�#�#�G�A�t� ,�Q�
� ;� ;� �L�*�� 0�
�f�,�,� � �a� � ���&�q�$�/�/�/� �A�t� � �D�A�q� ��4� � �D�A�q�
�1��q��s��B� �B�
� 2� 5� 5�b�!� <� <� =� =�=rt )� default_axisr c � � t j | � � } |�| � � � } d}| j | }|dk rt d� � �| � |d�� � }| |z
}t
||d�� � }t ||d�� � }|dz |dz |dz d z z z }t j �
|d�
� � }t ||� � S ) a� Perform the Jarque-Bera goodness of fit test on sample data.
The Jarque-Bera test tests whether the sample data has the skewness and
kurtosis matching a normal distribution.
Note that this test only works for a large enough number of data samples
(>2000) as the test statistic asymptotically has a Chi-squared distribution
with 2 degrees of freedom.
Parameters
----------
x : array_like
Observations of a random variable.
axis : int or None, default: 0
If an int, the axis of the input along which to compute the statistic.
The statistic of each axis-slice (e.g. row) of the input will appear in
a corresponding element of the output.
If ``None``, the input will be raveled before computing the statistic.
Returns
-------
result : SignificanceResult
An object with the following attributes:
statistic : float
The test statistic.
pvalue : float
The p-value for the hypothesis test.
References
----------
.. [1] Jarque, C. and Bera, A. (1980) "Efficient tests for normality,
homoscedasticity and serial independence of regression residuals",
6 Econometric Letters 255-259.
Examples
--------
>>> import numpy as np
>>> from scipy import stats
>>> rng = np.random.default_rng()
>>> x = rng.normal(0, 1, 100000)
>>> jarque_bera_test = stats.jarque_bera(x)
>>> jarque_bera_test
Jarque_beraResult(statistic=3.3415184718131554, pvalue=0.18810419594996775)
>>> jarque_bera_test.statistic
3.3415184718131554
>>> jarque_bera_test.pvalue
0.18810419594996775
Nr z%At least one observation is required.Tr� )rp �_no_deco� r� r< ��df) rk r rl rz r� r� r5 r6 r r� r r� ) r� rp r� �mu�diffxrO r� r� r� s rr r; r; 0 s� � �h �
�1�
�
�A� �|�
�G�G�I�I���� ���
�A��A�v�v��@�A�A�A�
���T�D�� )� )�B�
��F�E� �U���-�-�-�A���T�D�1�1�1�A��A���A���1��q�� �)�I�
�
�
"�
"�9��
"�
3�
3�F� �i�� 0� 0�0rt r� �fractionc � � t j | � � } | j dk rbt j |� � r t j S t j t j |� � j t j t j �� � S |r | |d | k | |d k z } t j | |�� � }|�d}t ||||� � S )a� Calculate the score at a given percentile of the input sequence.
For example, the score at `per=50` is the median. If the desired quantile
lies between two data points, we interpolate between them, according to
the value of `interpolation`. If the parameter `limit` is provided, it
should be a tuple (lower, upper) of two values.
Parameters
----------
a : array_like
A 1-D array of values from which to extract score.
per : array_like
Percentile(s) at which to extract score. Values should be in range
[0,100].
limit : tuple, optional
Tuple of two scalars, the lower and upper limits within which to
compute the percentile. Values of `a` outside
this (closed) interval will be ignored.
interpolation_method : {'fraction', 'lower', 'higher'}, optional
Specifies the interpolation method to use,
when the desired quantile lies between two data points `i` and `j`
The following options are available (default is 'fraction'):
* 'fraction': ``i + (j - i) * fraction`` where ``fraction`` is the
fractional part of the index surrounded by ``i`` and ``j``
* 'lower': ``i``
* 'higher': ``j``
axis : int, optional
Axis along which the percentiles are computed. Default is None. If
None, compute over the whole array `a`.
Returns
-------
score : float or ndarray
Score at percentile(s).
See Also
--------
percentileofscore, numpy.percentile
Notes
-----
This function will become obsolete in the future.
For NumPy 1.9 and higher, `numpy.percentile` provides all the functionality
that `scoreatpercentile` provides. And it's significantly faster.
Therefore it's recommended to use `numpy.percentile` for users that have
numpy >= 1.9.
Examples
--------
>>> import numpy as np
>>> from scipy import stats
>>> a = np.arange(100)
>>> stats.scoreatpercentile(a, 50)
49.5
r r� r r )
rk r r� r3 r �fullrz rB �sort�_compute_qth_percentile)ro �per�limit�interpolation_methodrp �sorted_s rr r< r< | s� � �| �
�1�
�
�A��v��{�{�
�;�s� � � L��6�M��7�2�:�c�?�?�0�"�&��
�K�K�K� K� � 1�
�u�Q�x�1�}��e�A�h� �/� 0���g�a�d�#�#�#�G� �|��� "�7�C�1E�t� L� L�Lrt c � � ��� t j |� � s$��� fd�|D � � }t j |� � S d|cxk rdk sn t d� � �t d � � g� j z }|dz � j � dz
z }t |� � |k rf�dk r"t t j |� � � � }n>�dk r"t t j |� � � � }n�d k rnt d
� � �t |� � }||k r(t ||dz � � |�< t d� � }d } nct ||d z � � |�< |dz }
t |
|z
||z
gt � � }dg� j z } d | �< | |_ |� � � } t j �
� t |� � |z ��
� � | z S )Nc �4 �� g | ]}t �|��� � ��S r� )r� )r0 r1 rp r� r� s ���rr r2 z+_compute_qth_percentile.<locals>.<listcomp>� s> �� � � � �� )��!�)=�t�E� E� � � rt r �d z(percentile must be in the range [0, 100]� Y@r �lower�higherr� z@interpolation_method can only be 'fraction', 'lower' or 'higher'r� r� r )rk r3 r r� �slicerm rz r� �floor�ceilr� �sum�addr r} ) r� r� r� rp �score�indexer�idxr1 r� �sumval�j�wshapes ` `` rr r� r� � s� ���� �
�;�s� � � � � � � � � � � � � �� �x���� �
��O�O�O�O��O�O�O�O��C�D�D�D��T�{�{�m�g�l�*�G�
��*��
�d�+�a�/�
0�C�
�3�x�x�3��� �7� *� *��b�h�s�m�m�$�$�C�C�
!�X�
-�
-��b�g�c�l�l�#�#�C�C�
!�Z�
/�
/� � � 3� 4� 4�
4� �C���A��C�x�x� �a��Q������
���(�(����� �a��Q������
�
��E���!�c�'�S�1�W�.��6�6����w�|�#����t� � ��
���� � �� �6�=�=���w� � �0�7�:��=� F� F�� O�Ort �rankc �� � t j | � � } t | � � }t j |� � }t | |d�� � \ }}t ||d�� � \ }}|s|r|dk rt d� � �|r't j t j |� � |� � }|rI|dk r;t j t j | � � | � � } | � � � }|dk rd}|dk r-t j |t j
t j �� � } �n|d }d
� }
t � � 5 } | �
t d � � | �
t d � � |d
k r3 |
| |k � � } |
| |k � � }
| |
k }| |
z |z d|z z } nw|dk r |
| |k � � d|z z } n[|dk r |
| |k � � d|z z } n?|dk r* |
| |k � � } |
| |k � � }
| |
z d|z z } nt d� � �ddd� � n # 1 swxY w Y t j | t j
� � } | j dk r| d S | S )a� Compute the percentile rank of a score relative to a list of scores.
A `percentileofscore` of, for example, 80% means that 80% of the
scores in `a` are below the given score. In the case of gaps or
ties, the exact definition depends on the optional keyword, `kind`.
Parameters
----------
a : array_like
Array to which `score` is compared.
score : array_like
Scores to compute percentiles for.
kind : {'rank', 'weak', 'strict', 'mean'}, optional
Specifies the interpretation of the resulting score.
The following options are available (default is 'rank'):
* 'rank': Average percentage ranking of score. In case of multiple
matches, average the percentage rankings of all matching scores.
* 'weak': This kind corresponds to the definition of a cumulative
distribution function. A percentileofscore of 80% means that 80%
of values are less than or equal to the provided score.
* 'strict': Similar to "weak", except that only values that are
strictly less than the given score are counted.
* 'mean': The average of the "weak" and "strict" scores, often used
in testing. See https://en.wikipedia.org/wiki/Percentile_rank
nan_policy : {'propagate', 'raise', 'omit'}, optional
Specifies how to treat `nan` values in `a`.
The following options are available (default is 'propagate'):
* 'propagate': returns nan (for each value in `score`).
* 'raise': throws an error
* 'omit': performs the calculations ignoring nan values
Returns
-------
pcos : float
Percentile-position of score (0-100) relative to `a`.
See Also
--------
numpy.percentile
scipy.stats.scoreatpercentile, scipy.stats.rankdata
Examples
--------
Three-quarters of the given values lie below a given score:
>>> import numpy as np
>>> from scipy import stats
>>> stats.percentileofscore([1, 2, 3, 4], 3)
75.0
With multiple matches, note how the scores of the two matches, 0.6
and 0.8 respectively, are averaged:
>>> stats.percentileofscore([1, 2, 3, 3, 4], 3)
70.0
Only 2/5 values are strictly less than 3:
>>> stats.percentileofscore([1, 2, 3, 3, 4], 3, kind='strict')
40.0
But 4/5 values are less than or equal to 3:
>>> stats.percentileofscore([1, 2, 3, 3, 4], 3, kind='weak')
80.0
The average between the weak and the strict scores is:
>>> stats.percentileofscore([1, 2, 3, 3, 4], 3, kind='mean')
60.0
Score arrays (of any dimensionality) are supported:
>>> stats.percentileofscore([1, 2, 3, 3, 4], [2, 3])
array([40., 70.])
The inputs can be infinite:
>>> stats.percentileofscore([-np.inf, 0, 1, np.inf], [1, 2, np.inf])
array([75., 75., 100.])
If `a` is empty, then the resulting percentiles are all `nan`:
>>> stats.percentileofscore([], [1, 2])
array([nan, nan])
F)�
use_summation�raisez The input contains nan valuesr� r� r r� ).Nc �, � t j | d� � S )Nr� )rk �
count_nonzeror� s rr r� z percentileofscore.<locals>.countt s � ��#�A�r�*�*� *rt z!invalid value encountered in lessz$invalid value encountered in greaterr� g I@�strictr� �weakr� z3kind can only be 'rank', 'strict', 'weak' or 'mean'Nr� )rk r r� r r� r � masked_where�isnanr� � full_liker rB r
�filterrH r rm )ro r� r@ r� r� �cna�npa�cns�nps�perctr� �sup�left�right�plus1s rr r= r= � s � �t �
�1�
�
�A� �A���A� �J�u� � �E� �Q�
�%�@�@�@�H�C�� �U�J�e�D�D�D�H�C�� � :�s� :�
�g�-�-��8�9�9�9�
� 8� ��������7�7��
� � �� � ������ � �Q�/�/�A���� � �A� �� $� $��A� �A�v�v�� �U�B�F�"�*�=�=�=��� �i� �� +� +� +� �
�
� K�C� �J�J�~�:�
<�
<�
<� �J�J�~�=�
?�
?�
?� �v�~�~� �u�Q��Y�'�'�� ��a�5�j�)�)�� �u� �� �� ��-�$��(�;�����!�!� ��a�%�i�(�(�E�A�I�6����� � � ��a�5�j�)�)�U�Q�Y�7����� � � �u�Q��Y�'�'�� ��a�5�j�)�)�� �� �$��(�3��� �I�K� K� K�+ K� K� K� K� K� K� K� K� K� K� K���� K� K� K� K�2
�I�e�R�V� $� $�E� �z�Q����R�y�� �Ls �;C'H.�.H2�5H2�HistogramResult)r� r �binsize� extrapointsr8 Fc � �� t j | � � } ��N| j dk rd�n@| � � � }| � � � }||z
d|dz
z z }||z
||z f�t j | |�|�� � \ }} t j |t �� � }| d | d z
}
t �fd �| D � � � � } | dk r|rt j
d
| z � � t |�d |
| � � S ) a Create a histogram.
Separate the range into several bins and return the number of instances
in each bin.
Parameters
----------
a : array_like
Array of scores which will be put into bins.
numbins : int, optional
The number of bins to use for the histogram. Default is 10.
defaultlimits : tuple (lower, upper), optional
The lower and upper values for the range of the histogram.
If no value is given, a range slightly larger than the range of the
values in a is used. Specifically ``(a.min() - s, a.max() + s)``,
where ``s = (1/2)(a.max() - a.min()) / (numbins - 1)``.
weights : array_like, optional
The weights for each value in `a`. Default is None, which gives each
value a weight of 1.0
printextras : bool, optional
If True, if there are extra points (i.e. the points that fall outside
the bin limits) a warning is raised saying how many of those points
there are. Default is False.
Returns
-------
count : ndarray
Number of points (or sum of weights) in each bin.
lowerlimit : float
Lowest value of histogram, the lower limit of the first bin.
binsize : float
The size of the bins (all bins have the same size).
extrapoints : int
The number of points outside the range of the histogram.
See Also
--------
numpy.histogram
Notes
-----
This histogram is based on numpy's histogram but has a larger range by
default if default limits is not set.
Nr �r r rZ r� )�bins�ranger� r� r c �D �� g | ] }�d |k s |�d k �|�� S r� r� )r0 ru �
defaultlimitss �rr r2 z _histogram.<locals>.<listcomp>� sD �� � H� H� H�Q�'��*�Q�.�.�!�m�A�6F�2F�2F� �2F�2F�2Frt z)Points outside given histogram range = %s) rk rl r� rr r� � histogramr r� r� r� r� r� ) ro �numbinsr� r� � printextras�data_min�data_maxrO �hist� bin_edgesr� r� s ` rr �
_histogramr� � sD �� �^ ��� � �A�� � �6�Q�;�;� "�M�M� �u�u�w�w�H��u�u�w�w�H��H�$��w��|�)<�=�A� %��\�8�a�<� 8�M� �l�1�7�-�+2�4� 4� 4�O�D�)� �8�D�� &� &� &�D� ��l�Y�q�\�)�G�� H� H� H� H�!� H� H� H� I� I�K��Q���;���
�A�#�$� %� %� %� �4� �q�!1�7�K� H� H�Hrt �
CumfreqResult)�cumcountr r� r� c � � t | |||�� � \ }}}}t j |dz d�� � }t ||||� � S )a� Return a cumulative frequency histogram, using the histogram function.
A cumulative histogram is a mapping that counts the cumulative number of
observations in all of the bins up to the specified bin.
Parameters
----------
a : array_like
Input array.
numbins : int, optional
The number of bins to use for the histogram. Default is 10.
defaultreallimits : tuple (lower, upper), optional
The lower and upper values for the range of the histogram.
If no value is given, a range slightly larger than the range of the
values in `a` is used. Specifically ``(a.min() - s, a.max() + s)``,
where ``s = (1/2)(a.max() - a.min()) / (numbins - 1)``.
weights : array_like, optional
The weights for each value in `a`. Default is None, which gives each
value a weight of 1.0
Returns
-------
cumcount : ndarray
Binned values of cumulative frequency.
lowerlimit : float
Lower real limit
binsize : float
Width of each bin.
extrapoints : int
Extra points.
Examples
--------
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy import stats
>>> rng = np.random.default_rng()
>>> x = [1, 4, 2, 1, 3, 1]
>>> res = stats.cumfreq(x, numbins=4, defaultreallimits=(1.5, 5))
>>> res.cumcount
array([ 1., 2., 3., 3.])
>>> res.extrapoints
3
Create a normal distribution with 1000 random values
>>> samples = stats.norm.rvs(size=1000, random_state=rng)
Calculate cumulative frequencies
>>> res = stats.cumfreq(samples, numbins=25)
Calculate space of values for x
>>> x = res.lowerlimit + np.linspace(0, res.binsize*res.cumcount.size,
... res.cumcount.size)
Plot histogram and cumulative histogram
>>> fig = plt.figure(figsize=(10, 4))
>>> ax1 = fig.add_subplot(1, 2, 1)
>>> ax2 = fig.add_subplot(1, 2, 2)
>>> ax1.hist(samples, bins=25)
>>> ax1.set_title('Histogram')
>>> ax2.bar(x, res.cumcount, width=res.binsize)
>>> ax2.set_title('Cumulative histogram')
>>> ax2.set_xlim([x.min(), x.max()])
>>> plt.show()
r� r r r )r� rk �cumsumr� ) ro r� �defaultreallimitsr� �h�lrv �e�cumhists rr r> r> � sP � �P �A�w�(9�7�K�K�K�J�A�q�!�Q��i��A��A�&�&�&�G� ��!�Q�� *� *�*rt �
RelfreqResult)� frequencyr r� r� c � � t j | � � } t | |||�� � \ }}}}|| j d z }t ||||� � S )a~ Return a relative frequency histogram, using the histogram function.
A relative frequency histogram is a mapping of the number of
observations in each of the bins relative to the total of observations.
Parameters
----------
a : array_like
Input array.
numbins : int, optional
The number of bins to use for the histogram. Default is 10.
defaultreallimits : tuple (lower, upper), optional
The lower and upper values for the range of the histogram.
If no value is given, a range slightly larger than the range of the
values in a is used. Specifically ``(a.min() - s, a.max() + s)``,
where ``s = (1/2)(a.max() - a.min()) / (numbins - 1)``.
weights : array_like, optional
The weights for each value in `a`. Default is None, which gives each
value a weight of 1.0
Returns
-------
frequency : ndarray
Binned values of relative frequency.
lowerlimit : float
Lower real limit.
binsize : float
Width of each bin.
extrapoints : int
Extra points.
Examples
--------
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy import stats
>>> rng = np.random.default_rng()
>>> a = np.array([2, 4, 1, 2, 3, 2])
>>> res = stats.relfreq(a, numbins=4)
>>> res.frequency
array([ 0.16666667, 0.5 , 0.16666667, 0.16666667])
>>> np.sum(res.frequency) # relative frequencies should add up to 1
1.0
Create a normal distribution with 1000 random values
>>> samples = stats.norm.rvs(size=1000, random_state=rng)
Calculate relative frequencies
>>> res = stats.relfreq(samples, numbins=25)
Calculate space of values for x
>>> x = res.lowerlimit + np.linspace(0, res.binsize*res.frequency.size,
... res.frequency.size)
Plot relative frequency histogram
>>> fig = plt.figure(figsize=(5, 4))
>>> ax = fig.add_subplot(1, 1, 1)
>>> ax.bar(x, res.frequency, width=res.binsize)
>>> ax.set_title('Relative frequency histogram')
>>> ax.set_xlim([x.min(), x.max()])
>>> plt.show()
r� r )rk r� r� rz r� )ro r� r� r� r� r� rv r� s rr r? r? D sV � �J �
�a���A��A�w�(9�7�K�K�K�J�A�q�!�Q� �A�G�A�J��A� ��A�q�!� $� $�$rt c � � t j t j t � � j � � }g }d}| D ]�}t j |� � }t
|� � }t j |� � }||z
dz }|� � � } |dz
|z |z d| z z
|dz
|dz
z z }
| |dz
z } t | t j |
� � z
� � |k rt d� � �|� |
� � |j }��|r5|dd� D ]*} || j k r t j
|t �� � c S �+t j
|� � S ) ax Compute the O'Brien transform on input data (any number of arrays).
Used to test for homogeneity of variance prior to running one-way stats.
Each array in ``*samples`` is one level of a factor.
If `f_oneway` is run on the transformed data and found significant,
the variances are unequal. From Maxwell and Delaney [1]_, p.112.
Parameters
----------
sample1, sample2, ... : array_like
Any number of arrays.
Returns
-------
obrientransform : ndarray
Transformed data for use in an ANOVA. The first dimension
of the result corresponds to the sequence of transformed
arrays. If the arrays given are all 1-D of the same length,
the return value is a 2-D array; otherwise it is a 1-D array
of type object, with each element being an ndarray.
References
----------
.. [1] S. E. Maxwell and H. D. Delaney, "Designing Experiments and
Analyzing Data: A Model Comparison Perspective", Wadsworth, 1990.
Examples
--------
We'll test the following data sets for differences in their variance.
>>> x = [10, 11, 13, 9, 7, 12, 12, 9, 10]
>>> y = [13, 21, 5, 10, 8, 14, 10, 12, 7, 15]
Apply the O'Brien transform to the data.
>>> from scipy.stats import obrientransform
>>> tx, ty = obrientransform(x, y)
Use `scipy.stats.f_oneway` to apply a one-way ANOVA test to the
transformed data.
>>> from scipy.stats import f_oneway
>>> F, p = f_oneway(tx, ty)
>>> p
0.1314139477040335
If we require that ``p < 0.05`` for significance, we cannot conclude
that the variances are different.
Nr� rY r� r z'Lack of convergence in obrientransform.r� r� )rk r rE r� rL r r� r� r� r> r� r� rz r r� )
�samples�TINY�arrays�sLast�samplero r� r� �sq�sumsq�tr �arrs
rr r@ r@ � s_ � �f �7�2�8�E�?�?�&� '� '�D� �F� �E�� � �� �J�v� � �� ��F�F��
�W�Q�Z�Z���"�f�q�[�������� �#�g��]�R�
�#��+�
-�1�q�5�Q��U�2C� D�� �q�1�u�o�� �s�R�W�Q�Z�Z� � � �4� '� '� � F�G�G� G��
�
�a�������� � 6��#�2�#�;� 6� 6�C��� �!�!��x��f�5�5�5�5�5�5� "�
�8�F� � �rt c �( � t | |� � \ } }t | |� � \ }}|r0|dk r*t j | � � } t j | ||� � S | j | }t j | ||�� � t j |� � z }|S )ab Compute standard error of the mean.
Calculate the standard error of the mean (or standard error of
measurement) of the values in the input array.
Parameters
----------
a : array_like
An array containing the values for which the standard error is
returned.
axis : int or None, optional
Axis along which to operate. Default is 0. If None, compute over
the whole array `a`.
ddof : int, optional
Delta degrees-of-freedom. How many degrees of freedom to adjust
for bias in limited samples relative to the population estimate
of variance. Defaults to 1.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan.
The following options are available (default is 'propagate'):
* 'propagate': returns nan
* 'raise': throws an error
* 'omit': performs the calculations ignoring nan values
Returns
-------
s : ndarray or float
The standard error of the mean in the sample(s), along the input axis.
Notes
-----
The default value for `ddof` is different to the default (0) used by other
ddof containing routines, such as np.std and np.nanstd.
Examples
--------
Find standard error along the first axis:
>>> import numpy as np
>>> from scipy import stats
>>> a = np.arange(20).reshape(5,4)
>>> stats.sem(a)
array([ 2.8284, 2.8284, 2.8284, 2.8284])
Find standard error across the whole array, using n degrees of freedom:
>>> stats.sem(a, axis=None, ddof=0)
1.2893796958227628
r� rq )
rs r r r� r� rA rz rk r" r )ro rp r r� r� r� rO s rr rA rA � s� � �h �1�d�#�#�G�A�t� ,�Q�
� ;� ;� �L�*�� /�
�f�,�,� � �a� � ��� ��4��.�.�.� ���
�A�
��q�t�$�'�'�'�"�'�!�*�*�4�A� �Hrt c � � | t j | � � }|j dk rt j dg� � S |d |k � d�� � S )z�
Check if all values in x are the same. nans are ignored.
x must be a 1d array.
The return value is a 1d array with length 1, so it can be used
in np.apply_along_axis.
r Tr� )rk r� r� r r� �r� r� s rr �_isconstr (
sP � �
�2�8�A�;�;�,��A��v��{�{��x��� � � ��!��� �����-�-�-rt c � � | t j | � � }|j dk r t j t j g� � S t j |d�� � S )z�
Compute nanmean for the 1d array x, but quietly return nan if x is all nan.
The return value is a 1d array with length 1, so it can be used
in np.apply_along_axis.
r Tr� )rk r� r� r r r� r
s rr �_quiet_nanmeanr
8
sK � �
�2�8�A�;�;�,��A��v��{�{��x����!�!�!��w�q�4�(�(�(�(rt c � � | t j | � � }|j dk r t j t j g� � S t j |d|�� � S )z�
Compute nanstd for the 1d array x, but quietly return nan if x is all nan.
The return value is a 1d array with length 1, so it can be used
in np.apply_along_axis.
r T)r� r )rk r� r� r r r" )r� r r� s rr �
_quiet_nanstdr F
sM � �
�2�8�A�;�;�,��A��v��{�{��x����!�!�!��v�a�$�T�2�2�2�2rt c �* � t | | |||�� � S )a�
Compute the z score.
Compute the z score of each value in the sample, relative to the
sample mean and standard deviation.
Parameters
----------
a : array_like
An array like object containing the sample data.
axis : int or None, optional
Axis along which to operate. Default is 0. If None, compute over
the whole array `a`.
ddof : int, optional
Degrees of freedom correction in the calculation of the
standard deviation. Default is 0.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan. 'propagate' returns nan,
'raise' throws an error, 'omit' performs the calculations ignoring nan
values. Default is 'propagate'. Note that when the value is 'omit',
nans in the input also propagate to the output, but they do not affect
the z-scores computed for the non-nan values.
Returns
-------
zscore : array_like
The z-scores, standardized by mean and standard deviation of
input array `a`.
Notes
-----
This function preserves ndarray subclasses, and works also with
matrices and masked arrays (it uses `asanyarray` instead of
`asarray` for parameters).
Examples
--------
>>> import numpy as np
>>> a = np.array([ 0.7972, 0.0767, 0.4383, 0.7866, 0.8091,
... 0.1954, 0.6307, 0.6599, 0.1065, 0.0508])
>>> from scipy import stats
>>> stats.zscore(a)
array([ 1.1273, -1.247 , -0.0552, 1.0923, 1.1664, -0.8559, 0.5786,
0.6748, -1.1488, -1.3324])
Computing along a specified axis, using n-1 degrees of freedom
(``ddof=1``) to calculate the standard deviation:
>>> b = np.array([[ 0.3148, 0.0478, 0.6243, 0.4608],
... [ 0.7149, 0.0775, 0.6072, 0.9656],
... [ 0.6341, 0.1403, 0.9759, 0.4064],
... [ 0.5918, 0.6948, 0.904 , 0.3721],
... [ 0.0921, 0.2481, 0.1188, 0.1366]])
>>> stats.zscore(b, axis=1, ddof=1)
array([[-0.19264823, -1.28415119, 1.07259584, 0.40420358],
[ 0.33048416, -1.37380874, 0.04251374, 1.00081084],
[ 0.26796377, -1.12598418, 1.23283094, -0.37481053],
[-0.22095197, 0.24468594, 1.19042819, -1.21416216],
[-0.82780366, 1.4457416 , -0.43867764, -0.1792603 ]])
An example with `nan_policy='omit'`:
>>> x = np.array([[25.11, 30.10, np.nan, 32.02, 43.15],
... [14.95, 16.06, 121.25, 94.35, 29.81]])
>>> stats.zscore(x, axis=1, nan_policy='omit')
array([[-1.13490897, -0.37830299, nan, -0.08718406, 1.60039602],
[-0.91611681, -0.89090508, 1.4983032 , 0.88731639, -0.5785977 ]])
�rp r r� )rB )ro rp r r� s rr rC rC T
s � �J ��1�4�d�z� B� B� B�Brt r c �� � t j | � � } t | t j � � r t j n t j }t
|| � � |||�� � S )a�
Compute the geometric standard score.
Compute the geometric z score of each strictly positive value in the
sample, relative to the geometric mean and standard deviation.
Mathematically the geometric z score can be evaluated as::
gzscore = log(a/gmu) / log(gsigma)
where ``gmu`` (resp. ``gsigma``) is the geometric mean (resp. standard
deviation).
Parameters
----------
a : array_like
Sample data.
axis : int or None, optional
Axis along which to operate. Default is 0. If None, compute over
the whole array `a`.
ddof : int, optional
Degrees of freedom correction in the calculation of the
standard deviation. Default is 0.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan. 'propagate' returns nan,
'raise' throws an error, 'omit' performs the calculations ignoring nan
values. Default is 'propagate'. Note that when the value is 'omit',
nans in the input also propagate to the output, but they do not affect
the geometric z scores computed for the non-nan values.
Returns
-------
gzscore : array_like
The geometric z scores, standardized by geometric mean and geometric
standard deviation of input array `a`.
See Also
--------
gmean : Geometric mean
gstd : Geometric standard deviation
zscore : Standard score
Notes
-----
This function preserves ndarray subclasses, and works also with
matrices and masked arrays (it uses ``asanyarray`` instead of
``asarray`` for parameters).
.. versionadded:: 1.8
Examples
--------
Draw samples from a log-normal distribution:
>>> import numpy as np
>>> from scipy.stats import zscore, gzscore
>>> import matplotlib.pyplot as plt
>>> rng = np.random.default_rng()
>>> mu, sigma = 3., 1. # mean and standard deviation
>>> x = rng.lognormal(mu, sigma, size=500)
Display the histogram of the samples:
>>> fig, ax = plt.subplots()
>>> ax.hist(x, 50)
>>> plt.show()
Display the histogram of the samples standardized by the classical zscore.
Distribution is rescaled but its shape is unchanged.
>>> fig, ax = plt.subplots()
>>> ax.hist(zscore(x), 50)
>>> plt.show()
Demonstrate that the distribution of geometric zscores is rescaled and
quasinormal:
>>> fig, ax = plt.subplots()
>>> ax.hist(gzscore(x), 50)
>>> plt.show()
r )rk r� r� r r� r� rC )ro rp r r� r� s rr rD rD �
sQ � �f �
�a���A� �q�"�.�1�1�
=�"�&�&�r�v�C� �#�#�a�&�&�t�$�:� F� F� F�Frt c � � t j |� � }|j dk rt j |j � � S t ||� � \ }}|r�|dk r�|�ft
|� � � � � }t |� � � |�� � }t |� � � � � } n�t j
t ||� � }t j
t |||�� � }t j
t ||� � } n�|� |d�� � }|� ||d�� � }|�,|�
d� � |k � � � } n)t ||� � |k � |d�� � } d|| < | |z
|z }
t j |
t j | |
j � � < |
S ) a�
Calculate the relative z-scores.
Return an array of z-scores, i.e., scores that are standardized to
zero mean and unit variance, where mean and variance are calculated
from the comparison array.
Parameters
----------
scores : array_like
The input for which z-scores are calculated.
compare : array_like
The input from which the mean and standard deviation of the
normalization are taken; assumed to have the same dimension as
`scores`.
axis : int or None, optional
Axis over which mean and variance of `compare` are calculated.
Default is 0. If None, compute over the whole array `scores`.
ddof : int, optional
Degrees of freedom correction in the calculation of the
standard deviation. Default is 0.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle the occurrence of nans in `compare`.
'propagate' returns nan, 'raise' raises an exception, 'omit'
performs the calculations ignoring nan values. Default is
'propagate'. Note that when the value is 'omit', nans in `scores`
also propagate to the output, but they do not affect the z-scores
computed for the non-nan values.
Returns
-------
zscore : array_like
Z-scores, in the same shape as `scores`.
Notes
-----
This function preserves ndarray subclasses, and works also with
matrices and masked arrays (it uses `asanyarray` instead of
`asarray` for parameters).
Examples
--------
>>> from scipy.stats import zmap
>>> a = [0.5, 2.0, 2.5, 3]
>>> b = [0, 1, 2, 3, 4]
>>> zmap(a, b)
array([-1.06066017, 0. , 0.35355339, 0.70710678])
r r� Nr! Tr� )rp r r� r� )rk r� r� r� rz r r
rl r r �apply_along_axisr� r" r
r� �_firstr � broadcast_to) �scores�comparerp r r� ro r� �mnr" �isconstr� s rr rB rB �
s� � �d �
�g� � �A��v��{�{��x��� � � � ,�Q�
� ;� ;� �L�*�� K�
�f�,�,� �<� ���� � �*�*�B� ���� � ��5�5�5�C� �q�w�w�y�y�)�)�G�G��$�^�T�1�=�=�B��%�m�T�1�4�H�H�H�C��)�(�D�!�<�<�G�G�
�V�V���V�
-�
-���e�e��D�4�e�8�8�� �<��v�v�a�y�y�A�~�*�*�,�,�G�G� �a����!�+�0�0�d�T�0�J�J�G� �C��L� �"����A�+-�6�A�b�o�g�q�w�'�'�(� �Hrt c � � t j | � � } t | t j � � r t j n t j } t
j � � 5 t
j dt � � t j
t j || � � ||�� � � � cddd� � S # 1 swxY w Y dS # t $ �r"}t j | � � �
� � rt d� � |�t j | � � }|�
� � }|r't j t j | � � d� � s)|s7t j | d� � �
� � rt d� � |�dt% |� � k rt |� � |�t j
t j || | �� � ||�� � � � cY d}~S d}~wt& $ r}t d � � |�d}~ww xY w)
a
Calculate the geometric standard deviation of an array.
The geometric standard deviation describes the spread of a set of numbers
where the geometric mean is preferred. It is a multiplicative factor, and
so a dimensionless quantity.
It is defined as the exponent of the standard deviation of ``log(a)``.
Mathematically the population geometric standard deviation can be
evaluated as::
gstd = exp(std(log(a)))
.. versionadded:: 1.3.0
Parameters
----------
a : array_like
An array like object containing the sample data.
axis : int, tuple or None, optional
Axis along which to operate. Default is 0. If None, compute over
the whole array `a`.
ddof : int, optional
Degree of freedom correction in the calculation of the
geometric standard deviation. Default is 1.
Returns
-------
ndarray or float
An array of the geometric standard deviation. If `axis` is None or `a`
is a 1d array a float is returned.
See Also
--------
gmean : Geometric mean
numpy.std : Standard deviation
Notes
-----
As the calculation requires the use of logarithms the geometric standard
deviation only supports strictly positive values. Any non-positive or
infinite values will raise a `ValueError`.
The geometric standard deviation is sometimes confused with the exponent of
the standard deviation, ``exp(std(a))``. Instead the geometric standard
deviation is ``exp(std(log(a)))``.
The default value for `ddof` is different to the default value (0) used
by other ddof containing functions, such as ``np.std`` and ``np.nanstd``.
References
----------
.. [1] Kirkwood, T. B., "Geometric means and measures of dispersion",
Biometrics, vol. 35, pp. 908-909, 1979
Examples
--------
Find the geometric standard deviation of a log-normally distributed sample.
Note that the standard deviation of the distribution is one, on a
log scale this evaluates to approximately ``exp(1)``.
>>> import numpy as np
>>> from scipy.stats import gstd
>>> rng = np.random.default_rng()
>>> sample = rng.lognormal(mean=0, sigma=1, size=1000)
>>> gstd(sample)
2.810010162475324
Compute the geometric standard deviation of a multidimensional array and
of a given axis.
>>> a = np.arange(1, 25).reshape(2, 3, 4)
>>> gstd(a, axis=None)
2.2944076136018947
>>> gstd(a, axis=2)
array([[1.82424757, 1.22436866, 1.13183117],
[1.09348306, 1.07244798, 1.05914985]])
>>> gstd(a, axis=(1,2))
array([2.12939215, 1.22120169])
The geometric standard deviation further handles masked arrays.
>>> a = np.arange(1, 25).reshape(2, 3, 4)
>>> ma = np.ma.masked_where(a > 16, a)
>>> ma
masked_array(
data=[[[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]],
[[13, 14, 15, 16],
[--, --, --, --],
[--, --, --, --]]],
mask=[[[False, False, False, False],
[False, False, False, False],
[False, False, False, False]],
[[False, False, False, False],
[ True, True, True, True],
[ True, True, True, True]]],
fill_value=999999)
>>> gstd(ma, axis=2)
masked_array(
data=[[1.8242475707663655, 1.2243686572447428, 1.1318311657788478],
[1.0934830582350938, --, --]],
mask=[[False, False, False],
[False, True, True]],
fill_value=999999)
�errorrq NzjInfinite value encountered. The geometric standard deviation is defined for strictly positive values only.r znNon positive value encountered. The geometric standard deviation is defined for strictly positive values only.z!Degrees of freedom <= 0 for slice)r\ zRInvalid array input. The inputs could not be safely coerced to any supported types)rk r� r� r r� r� r� �catch_warnings� simplefilterrH r� r" �isinfrG r� r� �
less_equal�nanmin�str� TypeError)ro rp r r� �w�a_nan� a_nan_anyr� s rr rF rF G sp � �V �
�a���A� �q�"�.�1�1�
=�"�&�&�r�v�C� <�
�
$�
&�
&� @� @� � !�'�>� :� :� :��6�"�&���Q���d��>�>�>�?�?� @� @� @� @� @� @� @� @� @� @� @� @���� @� @� @� @� @� @�� � N� N� N�
�8�A�;�;�?�?� � � � �@�� � �
� ��� � ���I�I�K�K� � �
N�2�=���1� � �q�9�9�
N� �
N�#%�=��A�#6�#6�#:�#:�#<�#<�
N� �J�� � �
� 1�C��F�F�
:�
:� �Q�-�-�Q� &� �6�"�&���Q�u�f�!5�!5�!5�D�t�L�L�L�M�M� M� M� M� M� M� M����� � <� <� <��
4�5� 5�:;� <�����<���sP �C �A B4�' C �4B8�8C �;B8�<C � H � DG)�#H �)
H �6H�H r� r� rZ )�raw�normal�� �K �linearc �\ � t | � � } | j s t j S t |t
� � rp|� � � }|t vr"t d� |� � � � �|dk r d}t j |t d�� � t | }t | |� � \ } }| r|dk r
t j }
n t j }
t! |� � dk rt# d� � �t j |� � � � � rt d� � �t) |� � }t+ t j � � d k r |
| ||||�
� � } n |
| ||||� � � } t j | d | d
� � } |dk r| |z } | S )aQ
Compute the interquartile range of the data along the specified axis.
The interquartile range (IQR) is the difference between the 75th and
25th percentile of the data. It is a measure of the dispersion
similar to standard deviation or variance, but is much more robust
against outliers [2]_.
The ``rng`` parameter allows this function to compute other
percentile ranges than the actual IQR. For example, setting
``rng=(0, 100)`` is equivalent to `numpy.ptp`.
The IQR of an empty array is `np.nan`.
.. versionadded:: 0.18.0
Parameters
----------
x : array_like
Input array or object that can be converted to an array.
axis : int or sequence of int, optional
Axis along which the range is computed. The default is to
compute the IQR for the entire array.
rng : Two-element sequence containing floats in range of [0,100] optional
Percentiles over which to compute the range. Each must be
between 0 and 100, inclusive. The default is the true IQR:
``(25, 75)``. The order of the elements is not important.
scale : scalar or str, optional
The numerical value of scale will be divided out of the final
result. The following string values are recognized:
* 'raw' : No scaling, just return the raw IQR.
**Deprecated!** Use ``scale=1`` instead.
* 'normal' : Scale by
:math:`2 \sqrt{2} erf^{-1}(\frac{1}{2}) \approx 1.349`.
The default is 1.0. The use of ``scale='raw'`` is deprecated infavor
of ``scale=1`` and will raise an error in SciPy 1.12.0.
Array-like `scale` is also allowed, as long
as it broadcasts correctly to the output such that
``out / scale`` is a valid operation. The output dimensions
depend on the input array, `x`, the `axis` argument, and the
`keepdims` flag.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan.
The following options are available (default is 'propagate'):
* 'propagate': returns nan
* 'raise': throws an error
* 'omit': performs the calculations ignoring nan values
interpolation : str, optional
Specifies the interpolation method to use when the percentile
boundaries lie between two data points ``i`` and ``j``.
The following options are available (default is 'linear'):
* 'linear': ``i + (j - i)*fraction``, where ``fraction`` is the
fractional part of the index surrounded by ``i`` and ``j``.
* 'lower': ``i``.
* 'higher': ``j``.
* 'nearest': ``i`` or ``j`` whichever is nearest.
* 'midpoint': ``(i + j)/2``.
For NumPy >= 1.22.0, the additional options provided by the ``method``
keyword of `numpy.percentile` are also valid.
keepdims : bool, optional
If this is set to True, the reduced axes are left in the
result as dimensions with size one. With this option, the result
will broadcast correctly against the original array `x`.
Returns
-------
iqr : scalar or ndarray
If ``axis=None``, a scalar is returned. If the input contains
integers or floats of smaller precision than ``np.float64``, then the
output data-type is ``np.float64``. Otherwise, the output data-type is
the same as that of the input.
See Also
--------
numpy.std, numpy.var
References
----------
.. [1] "Interquartile range" https://en.wikipedia.org/wiki/Interquartile_range
.. [2] "Robust measures of scale" https://en.wikipedia.org/wiki/Robust_measures_of_scale
.. [3] "Quantile" https://en.wikipedia.org/wiki/Quantile
Examples
--------
>>> import numpy as np
>>> from scipy.stats import iqr
>>> x = np.array([[10, 7, 4], [3, 2, 1]])
>>> x
array([[10, 7, 4],
[ 3, 2, 1]])
>>> iqr(x)
4.0
>>> iqr(x, axis=0)
array([ 3.5, 2.5, 1.5])
>>> iqr(x, axis=1)
array([ 3., 1.])
>>> iqr(x, axis=1, keepdims=True)
array([[ 3.],
[ 1.]])
z {0} not a valid scale for `iqr`r' zdThe use of 'scale="raw"' is deprecated infavor of 'scale=1' and will raise an error in SciPy 1.12.0.r� r� r� z+quantile range must be two element sequencezrange must not contain NaNsz1.22.0)rp �methodr� )rp �
interpolationr� r r r� )r r� rk r r� r" r� �_scale_conversionsr� �formatr� r� r� r �
nanpercentile�
percentiler� r# r� rG �sortedr � __version__�subtract)
r� rp �rng�scaler� r/ r� � scale_keyr� r� �percentile_func�pctr� s
rr rE rE � s� � �\ ��
�
�A�
�6� ��v�
� �%�� � � .��K�K�M�M� � � .� .� .� � >� E� E�e� L� L�M�M� M� �� � �H�C� �M�#� 1�a� @� @� @� @�"�9�-�� -�Q�
� ;� ;� �L�*�� (�
�f�,�,� �*��� �-��
�3�x�x�1�}�}��E�F�F�F� �x��}�}����� 8��6�7�7�7�
��+�+�C��B�N�#�#�x�/�/� �o�a��4�
�'/�1� 1� 1��� �o�a��4�}�'/�1� 1� 1��
�+�c�!�f�c�!�f�
%�
%�C� ��|�|� �u� �� �Jrt c �" � t j | � � }|� � � r|dk r t j S | | } | j dk r t j S || � � }t j t j | |z
� � � � }|S )Nr� r )rk r� rG r r� �medianr> )r� �centerr� r� �med�mads rr �_mad_1drA x s} � �
�H�Q�K�K�E� �y�y�{�{� � �� $� $��6�M�
�u�f�I���v��{�{��v�
�
�&��)�)�C�
�)�B�F�1�s�7�O�O�
$�
$�C� �Jrt c � �� t |� � s t dt |� � � d�� � �t |t � � r-|� � � dk rd}nt
|� d�� � �t | � � } | j sl�� t j
S t �fd�t | j
� � D � � � � }|dk r t j
S t j |t j
� � S t | |� � \ }}|rD��$t! | � � � ||� � }n�t j t �| ||� � }n���7 || d� � � }t j t j | |z
� � � � }nKt j || �� � � �� � }t j t j | |z
� � �� � � }||z S )
aX
Compute the median absolute deviation of the data along the given axis.
The median absolute deviation (MAD, [1]_) computes the median over the
absolute deviations from the median. It is a measure of dispersion
similar to the standard deviation but more robust to outliers [2]_.
The MAD of an empty array is ``np.nan``.
.. versionadded:: 1.5.0
Parameters
----------
x : array_like
Input array or object that can be converted to an array.
axis : int or None, optional
Axis along which the range is computed. Default is 0. If None, compute
the MAD over the entire array.
center : callable, optional
A function that will return the central value. The default is to use
np.median. Any user defined function used will need to have the
function signature ``func(arr, axis)``.
scale : scalar or str, optional
The numerical value of scale will be divided out of the final
result. The default is 1.0. The string "normal" is also accepted,
and results in `scale` being the inverse of the standard normal
quantile function at 0.75, which is approximately 0.67449.
Array-like scale is also allowed, as long as it broadcasts correctly
to the output such that ``out / scale`` is a valid operation. The
output dimensions depend on the input array, `x`, and the `axis`
argument.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan.
The following options are available (default is 'propagate'):
* 'propagate': returns nan
* 'raise': throws an error
* 'omit': performs the calculations ignoring nan values
Returns
-------
mad : scalar or ndarray
If ``axis=None``, a scalar is returned. If the input contains
integers or floats of smaller precision than ``np.float64``, then the
output data-type is ``np.float64``. Otherwise, the output data-type is
the same as that of the input.
See Also
--------
numpy.std, numpy.var, numpy.median, scipy.stats.iqr, scipy.stats.tmean,
scipy.stats.tstd, scipy.stats.tvar
Notes
-----
The `center` argument only affects the calculation of the central value
around which the MAD is calculated. That is, passing in ``center=np.mean``
will calculate the MAD around the mean - it will not calculate the *mean*
absolute deviation.
The input array may contain `inf`, but if `center` returns `inf`, the
corresponding MAD for that data will be `nan`.
References
----------
.. [1] "Median absolute deviation",
https://en.wikipedia.org/wiki/Median_absolute_deviation
.. [2] "Robust measures of scale",
https://en.wikipedia.org/wiki/Robust_measures_of_scale
Examples
--------
When comparing the behavior of `median_abs_deviation` with ``np.std``,
the latter is affected when we change a single value of an array to have an
outlier value while the MAD hardly changes:
>>> import numpy as np
>>> from scipy import stats
>>> x = stats.norm.rvs(size=100, scale=1, random_state=123456)
>>> x.std()
0.9973906394005013
>>> stats.median_abs_deviation(x)
0.82832610097857
>>> x[0] = 345.6
>>> x.std()
34.42304872314415
>>> stats.median_abs_deviation(x)
0.8323442311590675
Axis handling example:
>>> x = np.array([[10, 7, 4], [3, 2, 1]])
>>> x
array([[10, 7, 4],
[ 3, 2, 1]])
>>> stats.median_abs_deviation(x)
array([3.5, 2.5, 1.5])
>>> stats.median_abs_deviation(x, axis=None)
2.0
Scale normal example:
>>> x = stats.norm.rvs(size=1000000, scale=2, random_state=123456)
>>> stats.median_abs_deviation(x)
1.3487398527041636
>>> stats.median_abs_deviation(x, scale='normal')
1.9996446978061115
z8The argument 'center' must be callable. The given value z is not callable.r( gI�R�k��?z is not a valid scale value.Nc 3 �. �K � | ]\ }}|�k � |V � �d S r� r� )r0 r1 r
rp s �rr � <genexpr>z'median_abs_deviation.<locals>.<genexpr>
s+ �� � � �N�N�7�1�d�A��I�I�$�I�I�I�I�N�Nrt r� r )�callabler# �reprr� r" r� r� r r� rk r r} � enumeraterz r� r rA rl r r= r> � expand_dims) r� rp r> r8 r� � nan_shaper� r@ r? s ` rr rG rG � s� �� �\ �F� � � B�� A�!%�f� � �A� A� A� B� B� B�
�%�� � � E� �;�;�=�=�H� $� $�&�E�E� �� C� C� C�D�D� D���
�
�A�
�6� *� �<��6�M��N�N�N�N�i���.@�.@�N�N�N�N�N� � ��?�?��6�M��w�y�"�&�)�)�)� ,�Q�
� ;� ;� �L�*��
8� �<��!�'�'�)�)�V�Z�8�8�C�C��%�g�t�Q��
�K�K�C�C� �<��&���&�&�&�C��)�B�F�1�s�7�O�O�,�,�C�C� �.�����!5�!5�!5�t�<�<�C��)�B�F�1�s�7�O�O�$�7�7�7�C� ��;�rt �SigmaclipResult)�clippedr� �upperr� c �4 � t j | � � � � � }d}|r^|� � � }|� � � }|j }|||z z
}|||z z } |||k || k z }||j z
}|�^t
||| � � S )a� Perform iterative sigma-clipping of array elements.
Starting from the full sample, all elements outside the critical range are
removed, i.e. all elements of the input array `c` that satisfy either of
the following conditions::
c < mean(c) - std(c)*low
c > mean(c) + std(c)*high
The iteration continues with the updated sample until no
elements are outside the (updated) range.
Parameters
----------
a : array_like
Data array, will be raveled if not 1-D.
low : float, optional
Lower bound factor of sigma clipping. Default is 4.
high : float, optional
Upper bound factor of sigma clipping. Default is 4.
Returns
-------
clipped : ndarray
Input array with clipped elements removed.
lower : float
Lower threshold value use for clipping.
upper : float
Upper threshold value use for clipping.
Examples
--------
>>> import numpy as np
>>> from scipy.stats import sigmaclip
>>> a = np.concatenate((np.linspace(9.5, 10.5, 31),
... np.linspace(0, 20, 5)))
>>> fact = 1.5
>>> c, low, upp = sigmaclip(a, fact, fact)
>>> c
array([ 9.96666667, 10. , 10.03333333, 10. ])
>>> c.var(), c.std()
(0.00055555555555555165, 0.023570226039551501)
>>> low, c.mean() - fact*c.std(), c.min()
(9.9646446609406727, 9.9646446609406727, 9.9666666666666668)
>>> upp, c.mean() + fact*c.std(), c.max()
(10.035355339059327, 10.035355339059327, 10.033333333333333)
>>> a = np.concatenate((np.linspace(9.5, 10.5, 11),
... np.linspace(-100, -50, 3)))
>>> c, low, upp = sigmaclip(a, 1.8, 1.8)
>>> (c == np.linspace(9.5, 10.5, 11)).all()
True
r )rk r rl r" r� r� rJ )
ro �low�high�cr� �c_std�c_meanr� � critlower� crituppers
rr rH rH 0
s� � �n �
�1�
�
��� � �A�
�E�
� ��������������v���U�S�[�(� ��U�T�\�)� �
�q�I�~�!�y�.�1� 2���q�v�
�� � � �1�i�� 3� 3�3rt c � � t j | � � } | j dk r| S |�| � � � } d}| j | }t ||z � � }||z
}||k rt
d� � �t j | ||dz
f|� � }t d� � g|j z }t ||� � ||< |t |� � S )au Slice off a proportion of items from both ends of an array.
Slice off the passed proportion of items from both ends of the passed
array (i.e., with `proportiontocut` = 0.1, slices leftmost 10% **and**
rightmost 10% of scores). The trimmed values are the lowest and
highest ones.
Slice off less if proportion results in a non-integer slice index (i.e.
conservatively slices off `proportiontocut`).
Parameters
----------
a : array_like
Data to trim.
proportiontocut : float
Proportion (in range 0-1) of total data set to trim of each end.
axis : int or None, optional
Axis along which to trim data. Default is 0. If None, compute over
the whole array `a`.
Returns
-------
out : ndarray
Trimmed version of array `a`. The order of the trimmed content
is undefined.
See Also
--------
trim_mean
Examples
--------
Create an array of 10 values and trim 10% of those values from each end:
>>> import numpy as np
>>> from scipy import stats
>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> stats.trimboth(a, 0.1)
array([1, 3, 2, 4, 5, 6, 7, 8])
Note that the elements of the input array are trimmed by value, but the
output array is not necessarily sorted.
The proportion to trim is rounded down to the nearest integer. For
instance, trimming 25% of the values from each end of an array of 10
values will return an array of 6 values:
>>> b = np.arange(10)
>>> stats.trimboth(b, 1/4).shape
(6,)
Multidimensional arrays can be trimmed along any axis or across the entire
array:
>>> c = [2, 4, 6, 8, 0, 1, 3, 5, 7, 9]
>>> d = np.array([a, b, c])
>>> stats.trimboth(d, 0.4, axis=0).shape
(1, 10)
>>> stats.trimboth(d, 0.4, axis=1).shape
(3, 2)
>>> stats.trimboth(d, 0.4, axis=None).shape
(6,)
r N�Proportion too big.r ) rk r r� rl rz r� r� � partitionr� rm r} �ro �proportiontocutrp rl �lowercut�uppercut�atmp�sls rr rI rI u
s� � �@ �
�1�
�
�A��v��{�{��� �|�
�G�G�I�I���� �7�4�=�D��?�T�)�*�*�H��h��H��H� � ��.�/�/�/�
�<��H�h��l�3�T� :� :�D�
��+�+� ��� "�B��X�x�(�(�B�t�H� ��b� � �?�rt r� c �� � t j | � � } |�| � � � } d}| j | }|dk rg S |� � � dk rd}|t ||z � � z
}n,|� � � dk rt ||z � � }|}t j | ||dz
f|� � }t d� � g|j z }t ||� � ||< |t |� � S )a, Slice off a proportion from ONE end of the passed array distribution.
If `proportiontocut` = 0.1, slices off 'leftmost' or 'rightmost'
10% of scores. The lowest or highest values are trimmed (depending on
the tail).
Slice off less if proportion results in a non-integer slice index
(i.e. conservatively slices off `proportiontocut` ).
Parameters
----------
a : array_like
Input array.
proportiontocut : float
Fraction to cut off of 'left' or 'right' of distribution.
tail : {'left', 'right'}, optional
Defaults to 'right'.
axis : int or None, optional
Axis along which to trim data. Default is 0. If None, compute over
the whole array `a`.
Returns
-------
trim1 : ndarray
Trimmed version of array `a`. The order of the trimmed content is
undefined.
Examples
--------
Create an array of 10 values and trim 20% of its lowest values:
>>> import numpy as np
>>> from scipy import stats
>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> stats.trim1(a, 0.2, 'left')
array([2, 4, 3, 5, 6, 7, 8, 9])
Note that the elements of the input array are trimmed by value, but the
output array is not necessarily sorted.
The proportion to trim is rounded down to the nearest integer. For
instance, trimming 25% of the values from an array of 10 values will
return an array of 8 values:
>>> b = np.arange(10)
>>> stats.trim1(b, 1/4).shape
(8,)
Multidimensional arrays can be trimmed along any axis or across the entire
array:
>>> c = [2, 4, 6, 8, 0, 1, 3, 5, 7, 9]
>>> d = np.array([a, b, c])
>>> stats.trim1(d, 0.8, axis=0).shape
(1, 10)
>>> stats.trim1(d, 0.8, axis=1).shape
(3, 2)
>>> stats.trim1(d, 0.8, axis=None).shape
(6,)
Nr r r� r� )
rk r rl rz r� r� rW r� rm r} ) ro rY �tailrp rl rZ r[ r\ r] s rr rJ rJ �
s� � �z �
�1�
�
�A� �|�
�G�G�I�I���� �7�4�=�D� �!���� � �z�z�|�|�w� � ����#�o�� 4�5�5�5���
��� � �� � ����-�.�.����
�<��H�h��l�3�T� :� :�D�
��+�+� ��� "�B��X�x�(�(�B�t�H� ��b� � �?�rt c �� � t j | � � } | j dk r t j S |�| � � � } d}| j | }t
||z � � }||z
}||k rt d� � �t j | ||dz
f|� � }t d� � g|j
z }t ||� � ||< t j |t |� � |�� � S )a9 Return mean of array after trimming distribution from both tails.
If `proportiontocut` = 0.1, slices off 'leftmost' and 'rightmost' 10% of
scores. The input is sorted before slicing. Slices off less if proportion
results in a non-integer slice index (i.e., conservatively slices off
`proportiontocut` ).
Parameters
----------
a : array_like
Input array.
proportiontocut : float
Fraction to cut off of both tails of the distribution.
axis : int or None, optional
Axis along which the trimmed means are computed. Default is 0.
If None, compute over the whole array `a`.
Returns
-------
trim_mean : ndarray
Mean of trimmed array.
See Also
--------
trimboth
tmean : Compute the trimmed mean ignoring values outside given `limits`.
Examples
--------
>>> import numpy as np
>>> from scipy import stats
>>> x = np.arange(20)
>>> stats.trim_mean(x, 0.1)
9.5
>>> x2 = x.reshape(5, 4)
>>> x2
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15],
[16, 17, 18, 19]])
>>> stats.trim_mean(x2, 0.25)
array([ 8., 9., 10., 11.])
>>> stats.trim_mean(x2, 0.25, axis=1)
array([ 1.5, 5.5, 9.5, 13.5, 17.5])
r NrV r r )
rk r r� r rl rz r� r� rW r� rm r� r} rX s rr rK rK " s� � �` �
�1�
�
�A��v��{�{��v�
� �|�
�G�G�I�I���� �7�4�=�D��?�T�)�*�*�H��h��H��8����.�/�/�/�
�<��H�h��l�3�T� :� :�D�
��+�+� ��� "�B��X�x�(�(�B�t�H�
�7�4��b� � �?�� .� .� .�.rt �F_onewayResultc �\ � t j j � |t | � � � � }| d|� | |dz d� z }|dk rt j }t j }n4t j |t j �� � }|� � � }t ||� � S )z�
This is a helper function for f_oneway for creating the return values
in certain degenerate conditions. It creates return values that are
all nan with the appropriate shape for the given `shape` and `axis`.
Nr r� r ) rk �core�
multiarray�normalize_axis_indexr� r r� r� ra )rz rp r~ �fr� s rr �_create_f_oneway_nan_resultrg k s� � � �7� � 2� 2�4��U��� D� D�D�
����,��t�A�v�w�w� �
'�C�
�b�y�y� �F���v��� �G�C�B�F� +� +� +���v�v�x�x�� �!�T� "� "�"rt c �` � t j | t j d| j �� � |� � S )z>Return arr[..., 0:1, ...] where 0:1 is in the `axis` position.r )�ndmin)rk �take_along_axisr rm )r rp s rr r r | s( � �
� �c�2�8�A�S�X�#>�#>�#>�� E� E�Ert c �, � � t |� � dk r t dt |� � � d�� � �d� |D � � }t |� � }t j |� �� � }|j � }t � fd�|D � � � � r;t
j t j d� � � � t |j � � � S t � fd�|D � � � � r=d }t
j t j |� � � � t |j � � � S t j � fd
�|D � � � �� � }|� � �� � }|� � � r(d }t
j t j |� � � � t |� � � |k � � �� � }|� � d �
� � } || z }t |� �� � |z }
t! |� �� � |
z
} d} |D ]'}
| t |
| z
� �� � |
j � z z
} �(| |
z } | | z
}|dz
}||z
}| |z }||z }t j dd�� � 5 ||z }ddd� � n # 1 swxY w Y t% j |||� � }t j |� � r,|rt j }t j }nC|rt j }d}n2t j ||< d||< t j ||< t j ||< t/ ||� � S )aq Perform one-way ANOVA.
The one-way ANOVA tests the null hypothesis that two or more groups have
the same population mean. The test is applied to samples from two or
more groups, possibly with differing sizes.
Parameters
----------
sample1, sample2, ... : array_like
The sample measurements for each group. There must be at least
two arguments. If the arrays are multidimensional, then all the
dimensions of the array must be the same except for `axis`.
axis : int, optional
Axis of the input arrays along which the test is applied.
Default is 0.
Returns
-------
statistic : float
The computed F statistic of the test.
pvalue : float
The associated p-value from the F distribution.
Warns
-----
`~scipy.stats.ConstantInputWarning`
Raised if all values within each of the input arrays are identical.
In this case the F statistic is either infinite or isn't defined,
so ``np.inf`` or ``np.nan`` is returned.
`~scipy.stats.DegenerateDataWarning`
Raised if the length of any input array is 0, or if all the input
arrays have length 1. ``np.nan`` is returned for the F statistic
and the p-value in these cases.
Notes
-----
The ANOVA test has important assumptions that must be satisfied in order
for the associated p-value to be valid.
1. The samples are independent.
2. Each sample is from a normally distributed population.
3. The population standard deviations of the groups are all equal. This
property is known as homoscedasticity.
If these assumptions are not true for a given set of data, it may still
be possible to use the Kruskal-Wallis H-test (`scipy.stats.kruskal`) or
the Alexander-Govern test (`scipy.stats.alexandergovern`) although with
some loss of power.
The length of each group must be at least one, and there must be at
least one group with length greater than one. If these conditions
are not satisfied, a warning is generated and (``np.nan``, ``np.nan``)
is returned.
If all values in each group are identical, and there exist at least two
groups with different values, the function generates a warning and
returns (``np.inf``, 0).
If all values in all groups are the same, function generates a warning
and returns (``np.nan``, ``np.nan``).
The algorithm is from Heiman [2]_, pp.394-7.
References
----------
.. [1] R. Lowry, "Concepts and Applications of Inferential Statistics",
Chapter 14, 2014, http://vassarstats.net/textbook/
.. [2] G.W. Heiman, "Understanding research methods and statistics: An
integrated introduction for psychology", Houghton, Mifflin and
Company, 2001.
.. [3] G.H. McDonald, "Handbook of Biological Statistics", One-way ANOVA.
http://www.biostathandbook.com/onewayanova.html
Examples
--------
>>> import numpy as np
>>> from scipy.stats import f_oneway
Here are some data [3]_ on a shell measurement (the length of the anterior
adductor muscle scar, standardized by dividing by length) in the mussel
Mytilus trossulus from five locations: Tillamook, Oregon; Newport, Oregon;
Petersburg, Alaska; Magadan, Russia; and Tvarminne, Finland, taken from a
much larger data set used in McDonald et al. (1991).
>>> tillamook = [0.0571, 0.0813, 0.0831, 0.0976, 0.0817, 0.0859, 0.0735,
... 0.0659, 0.0923, 0.0836]
>>> newport = [0.0873, 0.0662, 0.0672, 0.0819, 0.0749, 0.0649, 0.0835,
... 0.0725]
>>> petersburg = [0.0974, 0.1352, 0.0817, 0.1016, 0.0968, 0.1064, 0.105]
>>> magadan = [0.1033, 0.0915, 0.0781, 0.0685, 0.0677, 0.0697, 0.0764,
... 0.0689]
>>> tvarminne = [0.0703, 0.1026, 0.0956, 0.0973, 0.1039, 0.1045]
>>> f_oneway(tillamook, newport, petersburg, magadan, tvarminne)
F_onewayResult(statistic=7.121019471642447, pvalue=0.0002812242314534544)
`f_oneway` accepts multidimensional input arrays. When the inputs
are multidimensional and `axis` is not given, the test is performed
along the first axis of the input arrays. For the following data, the
test is performed three times, once for each column.
>>> a = np.array([[9.87, 9.03, 6.81],
... [7.18, 8.35, 7.00],
... [8.39, 7.58, 7.68],
... [7.45, 6.33, 9.35],
... [6.41, 7.10, 9.33],
... [8.00, 8.24, 8.44]])
>>> b = np.array([[6.35, 7.30, 7.16],
... [6.65, 6.68, 7.63],
... [5.72, 7.73, 6.72],
... [7.01, 9.19, 7.41],
... [7.75, 7.87, 8.30],
... [6.90, 7.97, 6.97]])
>>> c = np.array([[3.31, 8.77, 1.01],
... [8.25, 3.24, 3.62],
... [6.32, 8.81, 5.19],
... [7.48, 8.83, 8.91],
... [8.59, 6.01, 6.07],
... [3.07, 9.72, 7.48]])
>>> F, p = f_oneway(a, b, c)
>>> F
array([1.75676344, 0.03701228, 3.76439349])
>>> p
array([0.20630784, 0.96375203, 0.04733157])
r� z&at least two inputs are required; got �.c �D � g | ] }t j |t � � � �� S �r� �rk r r� �r0 r s rr r2 z f_oneway.<locals>.<listcomp> �' � �E�E�E�6�r�z�&��.�.�.�E�E�Ert r c 3 �: �K � | ]}|j � d k V � �dS �r N�rz �r0 r rp s �rr rD zf_oneway.<locals>.<genexpr> �/ �� � � �
9�
9�v�6�<�� �� "�
9�
9�
9�
9�
9�
9rt z at least one input has length 0c 3 �: �K � | ]}|j � d k V � �dS )r Nrt ru s �rr rD zf_oneway.<locals>.<genexpr> rv rt zeall input arrays have length 1. f_oneway requires that at least one input has length greater than 1.c �b �� g | ]+}t |�� � |k � �d �� � ��,S )Tr� )r r� ru s �rr r2 z f_oneway.<locals>.<listcomp>* sR �� � � � �
� ���
�
�&�
(� -� -�4�7;�
.�
=�
=� � � rt zOEach of the input arrays is constant;the F statistic is not defined or infiniteTr� r r r� r9 Nr7 )r� r# rk � concatenaterz rG r� r� r' �DegenerateDataWarningrg r� �ConstantInputWarningr r� �_square_of_sums�_sum_of_squaresr� �special�fdtrcr3 r �infra )rp r� �
num_groups�alldata�bignr� �is_const� all_const�all_same_const�offset�
normalized_ss�sstot�ssbnr �sswn�dfbn�dfwn�msb�mswrf r� s ` rr rL rL � s� �� �B �7�|�|�a���� 0� #�G� � �0� 0� 0� 1� 1� 1� F�E�W�E�E�E�G� �W� � �J� �n�W�4�0�0�0�G� �=�� �D� �
9�
9�
9�
9��
9�
9�
9�9�9� @��
�e�1� 3A� B� B� C� C� C�*�7�=�$�?�?�?� �
9�
9�
9�
9��
9�
9�
9�9�9� @�<���
�e�1�#�6�6�7�7�7�*�7�=�$�?�?�?� �~� � � � � � � � � � � � �H� � � �$� �'�'�I��}�}��� 7�<���
�e�0��5�5�6�6�6� �W�d�+�+�w�6�;�;��;�F�F�N� �\�\�t�d�\�
3�
3�F� �v��G�#�G�$�7�7�7�$�>�M� �G�$� /� /� /�-� ?�E� �D�� @� @�� �����%)�+� +� +�-3�\�$�-?�@� @���
�M��D� �4�<�D� ��>�D� �*� �D�
��+�C�
��+�C� ��H�h� 7� 7� 7� � � �#�I��� � � � � � � � � � ���� � � � � �=��t�Q� '� '�D�
�{�1�~�~� &� � ���A��6�D�D�
� ���A��D���v��)� � ��Y�� �F��.�� !�v��^� � �!�T� "� "�"s �!I3�3I7�:I7�r� c � � � t |� � � }t j d� |D � � � � rLd}t j t j |� � � � t t j t j � � S t j � fd�|D � � � � }t j d� |D � � � � }d� t ||� � D � � }dt j |� � z }|t j |� � z }t j ||z � � }||z
|z } |dz
}
|
dz
} d| d z z } | t j
d| d z |
z z � � z dz }
|
|
d
z d
|
z z | z z d |
d z z d
|
dz z z d|
d
z z z d|
z z | d z dz d| z |
d z z z d| z z z z
}t j t j |� � � � }t j � |t# |� � dz
� � }t ||� � S )a� Performs the Alexander Govern test.
The Alexander-Govern approximation tests the equality of k independent
means in the face of heterogeneity of variance. The test is applied to
samples from two or more groups, possibly with differing sizes.
Parameters
----------
sample1, sample2, ... : array_like
The sample measurements for each group. There must be at least
two samples.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan.
The following options are available (default is 'propagate'):
* 'propagate': returns nan
* 'raise': throws an error
* 'omit': performs the calculations ignoring nan values
Returns
-------
statistic : float
The computed A statistic of the test.
pvalue : float
The associated p-value from the chi-squared distribution.
Warns
-----
`~scipy.stats.ConstantInputWarning`
Raised if an input is a constant array. The statistic is not defined
in this case, so ``np.nan`` is returned.
See Also
--------
f_oneway : one-way ANOVA
Notes
-----
The use of this test relies on several assumptions.
1. The samples are independent.
2. Each sample is from a normally distributed population.
3. Unlike `f_oneway`, this test does not assume on homoscedasticity,
instead relaxing the assumption of equal variances.
Input samples must be finite, one dimensional, and with size greater than
one.
References
----------
.. [1] Alexander, Ralph A., and Diane M. Govern. "A New and Simpler
Approximation for ANOVA under Variance Heterogeneity." Journal
of Educational Statistics, vol. 19, no. 2, 1994, pp. 91-101.
JSTOR, www.jstor.org/stable/1165140. Accessed 12 Sept. 2020.
Examples
--------
>>> from scipy.stats import alexandergovern
Here are some data on annual percentage rate of interest charged on
new car loans at nine of the largest banks in four American cities
taken from the National Institute of Standards and Technology's
ANOVA dataset.
We use `alexandergovern` to test the null hypothesis that all cities
have the same mean APR against the alternative that the cities do not
all have the same mean APR. We decide that a significance level of 5%
is required to reject the null hypothesis in favor of the alternative.
>>> atlanta = [13.75, 13.75, 13.5, 13.5, 13.0, 13.0, 13.0, 12.75, 12.5]
>>> chicago = [14.25, 13.0, 12.75, 12.5, 12.5, 12.4, 12.3, 11.9, 11.9]
>>> houston = [14.0, 14.0, 13.51, 13.5, 13.5, 13.25, 13.0, 12.5, 12.5]
>>> memphis = [15.0, 14.0, 13.75, 13.59, 13.25, 12.97, 12.5, 12.25,
... 11.89]
>>> alexandergovern(atlanta, chicago, houston, memphis)
AlexanderGovernResult(statistic=4.65087071883494,
pvalue=0.19922132490385214)
The p-value is 0.1992, indicating a nearly 20% chance of observing
such an extreme value of the test statistic under the null hypothesis.
This exceeds 5%, so we do not reject the null hypothesis in favor of
the alternative.
c �J � g | ] }||d k � � � ��!S �r rX rp s rr r2 z#alexandergovern.<locals>.<listcomp>� s- � �A�A�A�v��&��)�#�(�(�*�*�A�A�Art z9An input array is constant; the statistic is not defined.c �b �� g | ]+}�d k rt j |� � nt |� � ��,S )r� )r r� r� )r0 r r� s �rr r2 z#alexandergovern.<locals>.<listcomp>� sO �� � @� @� @�-3� -7�&�,@�,@����(�(�(� ��[�[�@� @� @rt c �6 � g | ]}t j |� � ��S r� )rk r� rp s rr r2 z#alexandergovern.<locals>.<listcomp>� s � �<�<�<�&�b�g�f�o�o�<�<�<rt c �j � g | ]0\ }}t j |d �� � t j |� � z ��1S )r r! )rk r" r )r0 r �lengths rr r2 z#alexandergovern.<locals>.<listcomp>� sN � � D� D� D�)�6�6� �v�f�1�-�-�-������?� D� D� Drt r r� �0 r� rW r< r� �! r� �� iW r8 r� �� )�!_alexandergovern_input_validationrk rG r� r� r' r{ �AlexanderGovernResultr r r� �squarer� r� r r� r r� )r� r� r� �lengths�means�standard_errors� inv_sq_ser� �var_w�t_statsru ro rv rP r� r� r� s ` rr rf rf l sU �� �j 0���D�D�G� �v�A�A��A�A�A�B�B� 5�I���
�e�0��5�5�6�6�6�$�R�V�R�V�4�4�4� �h� @� @� @� @�7>�@� @� @� A� A�G� �H�<�<�G�<�<�<� =� =�E�D� D�-0��'�-B�-B�D� D� D�O� �B�I�o�.�.�.�I��"�&��+�+�+�G�
�F�7�U�?� #� #�E� �u�}�o�-�G� �!� �A� �B��A�
�Q��T� �A�
�R�V�A��A� �q�(�(�
)�
)� )�B�.�A�
�q�!�t�a��c�z�1�n� � �Q��T�6�B�q�!�t�G� �c�!�Q�$�h� &��Q�� .� �a�4��7�Q�q�S��A��X� ��Q�� &� (�
)�A�
��r�y��|�|� � �A� �� � �a��W� � ��!1�2�2�A� ��A� &� &�&rt c � � t | � � dk r t dt | � � � �� � �d� | D � � } t | � � D ]�\ }}t j |� � dk rt d� � �|j dk rt d� � �t j |� � � � � rt d� � �t ||�� � \ }}|r |d k rt j |� � | |< ��| S )
Nr� z 2 or more inputs required, got c �D � g | ] }t j |t � � � �� S rn ro rp s rr r2 z5_alexandergovern_input_validation.<locals>.<listcomp>� rq rt r z+Input sample size must be greater than one.z%Input samples must be one-dimensionalz Input samples must be finite.r� r� ) r� r# rG rk r� r� rm r rG r r r� )r� r� r1 r r� s rr r� r� � s � �
�7�|�|�a����H�#�g�,�,�H�H�I�I�I� F�E�W�E�E�E�G� �w�'�'� 3� 3� ��6�
�7�6�?�?�a� � � � J�K�K� K� �;�!� � � � D�E�E� E�
�8�F� � � � � !� !� >� � <�=�=� =�#0��<F�$H� $H� $H� � �j� � 3�J�&� 0� 0��*�6�2�2�G�A�J�� �Nrt r� c �n � | dk r
t j }n(| dk rt j }nt j | � � }|dk r�t j d|dz
z � � }|dk rSt j d|dz z � � }|||z z
}|||z z }t j |� � } t j |� � }
nq|dk r3t j |� � }|||z z }t j |� � }
d} n8t j |� � }|||z z
}t j |� � } d }
nd
\ } }
t | |
� � � S ) z�
Compute the confidence interval for Pearson's R.
Fisher's transformation is used to compute the confidence interval
(https://en.wikipedia.org/wiki/Fisher_transformation).
r r� rW r{ r� r� ry � �r� )r� r� �rN rO )rk r� �arctanhr r~ �ndtri�tanh�ConfidenceInterval) �rr� �confidence_levelr� �zr�ser� �zlo�zhi�rlo�rhis rr �_pearsonr_fisher_cir� s= � � �A�v�v�
�V���
�b����f�W���
�Z��]�]���1�u�u�
�W�Q�!�a�%�[�
!�
!�� �+� %� %��
�c�$4�Q�$6� 6�7�7�A��q��t�)�C��q��t�)�C��'�#�,�,�C��'�#�,�,�C�C�
�F�
"�
"��
� .�/�/�A��q��t�)�C��'�#�,�,�C��C�C� �
� .�/�/�A��q��t�)�C��'�#�,�,�C��C�C� ���S� �#�C� 0� 0� 0�0rt r� rN rO �PearsonRResultBasec �* � � e Zd ZdZ� fd�Zdd�Z� xZS )�PearsonRResulta�
Result of `scipy.stats.pearsonr`
Attributes
----------
statistic : float
Pearson product-moment correlation coefficient.
pvalue : float
The p-value associated with the chosen alternative.
Methods
-------
confidence_interval
Computes the confidence interval of the correlation
coefficient `statistic` for the given confidence level.
c �v �� t � � � ||� � || _ || _ || _ d S r� )�super�__init__� _alternative�_n� correlation)�selfr� r� r� r� � __class__s �rr r� zPearsonRResult.__init__M s< �� �
������F�+�+�+� '������ %����rt �ffffff�?c �D � t | j | j || j � � S )a�
The confidence interval for the correlation coefficient.
Compute the confidence interval for the correlation coefficient
``statistic`` with the given confidence level.
The confidence interval is computed using the Fisher transformation
F(r) = arctanh(r) [1]_. When the sample pairs are drawn from a
bivariate normal distribution, F(r) approximately follows a normal
distribution with standard error ``1/sqrt(n - 3)``, where ``n`` is the
length of the original samples along the calculation axis. When
``n <= 3``, this approximation does not yield a finite, real standard
error, so we define the confidence interval to be -1 to 1.
Parameters
----------
confidence_level : float
The confidence level for the calculation of the correlation
coefficient confidence interval. Default is 0.95.
Returns
-------
ci : namedtuple
The confidence interval is returned in a ``namedtuple`` with
fields `low` and `high`.
References
----------
.. [1] "Pearson correlation coefficient", Wikipedia,
https://en.wikipedia.org/wiki/Pearson_correlation_coefficient
)r� r� r� r� )r� r� s rr �confidence_intervalz"PearsonRResult.confidence_intervalU s( � �@ #�4�>�4�7�<L�#'�#4�6� 6� 6rt �r� ��__name__�
__module__� __qualname__�__doc__r� r� �
__classcell__�r� s @rr r� r� ; sV �� � � � � �� �"%� %� %� %� %�!6� !6� !6� !6� !6� !6� !6� !6rt r� )r� c �0 � t | � � }|t |� � k rt d� � �|dk rt d� � �t j | � � } t j |� � }t j | j t j � � s$t j |j t j � � rt d� � �| | d k � � � s ||d k � � � rQd}t j t j |� � � � t t j
t j
||�� � }|S t d| d z |d z � � }|dk re |t j | d | d z
� � t j |d |d z
� � z � � }t |d||�� � }|S | � |�
� � }|� |�
� � } | � |� � |z
}
|� |� � | z
} t% j |
� � } t% j | � � }
d }| |t) |� � z k s|
|t) | � � z k r(d }t j t j |� � � � t j |
| z | |
z � � }t/ t1 |d� � d
� � }|dz d z
}t j ||dd�� � }|dk r&d|� t) |� � � � z }nG|dk r|� |� � }n+|dk r|� |� � }nt d� � �t ||||�� � S )a
Pearson correlation coefficient and p-value for testing non-correlation.
The Pearson correlation coefficient [1]_ measures the linear relationship
between two datasets. Like other correlation
coefficients, this one varies between -1 and +1 with 0 implying no
correlation. Correlations of -1 or +1 imply an exact linear relationship.
Positive correlations imply that as x increases, so does y. Negative
correlations imply that as x increases, y decreases.
This function also performs a test of the null hypothesis that the
distributions underlying the samples are uncorrelated and normally
distributed. (See Kowalski [3]_
for a discussion of the effects of non-normality of the input on the
distribution of the correlation coefficient.)
The p-value roughly indicates the probability of an uncorrelated system
producing datasets that have a Pearson correlation at least as extreme
as the one computed from these datasets.
Parameters
----------
x : (N,) array_like
Input array.
y : (N,) array_like
Input array.
alternative : {'two-sided', 'greater', 'less'}, optional
Defines the alternative hypothesis. Default is 'two-sided'.
The following options are available:
* 'two-sided': the correlation is nonzero
* 'less': the correlation is negative (less than zero)
* 'greater': the correlation is positive (greater than zero)
.. versionadded:: 1.9.0
Returns
-------
result : `~scipy.stats._result_classes.PearsonRResult`
An object with the following attributes:
statistic : float
Pearson product-moment correlation coefficient.
pvalue : float
The p-value associated with the chosen alternative.
The object has the following method:
confidence_interval(confidence_level=0.95)
This method computes the confidence interval of the correlation
coefficient `statistic` for the given confidence level.
The confidence interval is returned in a ``namedtuple`` with
fields `low` and `high`. See the Notes for more details.
Warns
-----
`~scipy.stats.ConstantInputWarning`
Raised if an input is a constant array. The correlation coefficient
is not defined in this case, so ``np.nan`` is returned.
`~scipy.stats.NearConstantInputWarning`
Raised if an input is "nearly" constant. The array ``x`` is considered
nearly constant if ``norm(x - mean(x)) < 1e-13 * abs(mean(x))``.
Numerical errors in the calculation ``x - mean(x)`` in this case might
result in an inaccurate calculation of r.
See Also
--------
spearmanr : Spearman rank-order correlation coefficient.
kendalltau : Kendall's tau, a correlation measure for ordinal data.
Notes
-----
The correlation coefficient is calculated as follows:
.. math::
r = \frac{\sum (x - m_x) (y - m_y)}
{\sqrt{\sum (x - m_x)^2 \sum (y - m_y)^2}}
where :math:`m_x` is the mean of the vector x and :math:`m_y` is
the mean of the vector y.
Under the assumption that x and y are drawn from
independent normal distributions (so the population correlation coefficient
is 0), the probability density function of the sample correlation
coefficient r is ([1]_, [2]_):
.. math::
f(r) = \frac{{(1-r^2)}^{n/2-2}}{\mathrm{B}(\frac{1}{2},\frac{n}{2}-1)}
where n is the number of samples, and B is the beta function. This
is sometimes referred to as the exact distribution of r. This is
the distribution that is used in `pearsonr` to compute the p-value.
The distribution is a beta distribution on the interval [-1, 1],
with equal shape parameters a = b = n/2 - 1. In terms of SciPy's
implementation of the beta distribution, the distribution of r is::
dist = scipy.stats.beta(n/2 - 1, n/2 - 1, loc=-1, scale=2)
The default p-value returned by `pearsonr` is a two-sided p-value. For a
given sample with correlation coefficient r, the p-value is
the probability that abs(r') of a random sample x' and y' drawn from
the population with zero correlation would be greater than or equal
to abs(r). In terms of the object ``dist`` shown above, the p-value
for a given r and length n can be computed as::
p = 2*dist.cdf(-abs(r))
When n is 2, the above continuous distribution is not well-defined.
One can interpret the limit of the beta distribution as the shape
parameters a and b approach a = b = 0 as a discrete distribution with
equal probability masses at r = 1 and r = -1. More directly, one
can observe that, given the data x = [x1, x2] and y = [y1, y2], and
assuming x1 != x2 and y1 != y2, the only possible values for r are 1
and -1. Because abs(r') for any sample x' and y' with length 2 will
be 1, the two-sided p-value for a sample of length 2 is always 1.
For backwards compatibility, the object that is returned also behaves
like a tuple of length two that holds the statistic and the p-value.
References
----------
.. [1] "Pearson correlation coefficient", Wikipedia,
https://en.wikipedia.org/wiki/Pearson_correlation_coefficient
.. [2] Student, "Probable error of a correlation coefficient",
Biometrika, Volume 6, Issue 2-3, 1 September 1908, pp. 302-310.
.. [3] C. J. Kowalski, "On the Effects of Non-Normality on the Distribution
of the Sample Product-Moment Correlation Coefficient"
Journal of the Royal Statistical Society. Series C (Applied
Statistics), Vol. 21, No. 1 (1972), pp. 1-12.
Examples
--------
>>> import numpy as np
>>> from scipy import stats
>>> res = stats.pearsonr([1, 2, 3, 4, 5], [10, 9, 2.5, 6, 4])
>>> res
PearsonRResult(statistic=-0.7426106572325056, pvalue=0.15055580885344558)
>>> res.confidence_interval()
ConfidenceInterval(low=-0.9816918044786463, high=0.40501116769030976)
There is a linear dependence between x and y if y = a + b*x + e, where
a,b are constants and e is a random error term, assumed to be independent
of x. For simplicity, assume that x is standard normal, a=0, b=1 and let
e follow a normal distribution with mean zero and standard deviation s>0.
>>> rng = np.random.default_rng()
>>> s = 0.5
>>> x = stats.norm.rvs(size=500, random_state=rng)
>>> e = stats.norm.rvs(scale=s, size=500, random_state=rng)
>>> y = x + e
>>> stats.pearsonr(x, y).statistic
0.9001942438244763
This should be close to the exact value given by
>>> 1/np.sqrt(1 + s**2)
0.8944271909999159
For s=0.5, we observe a high level of correlation. In general, a large
variance of the noise reduces the correlation, while the correlation
approaches one as the variance of the error goes to zero.
It is important to keep in mind that no correlation does not imply
independence unless (x, y) is jointly normal. Correlation can even be zero
when there is a very simple dependence structure: if X follows a
standard normal distribution, let y = abs(x). Note that the correlation
between x and y is zero. Indeed, since the expectation of x is zero,
cov(x, y) = E[x*y]. By definition, this equals E[x*abs(x)] which is zero
by symmetry. The following lines of code illustrate this observation:
>>> y = np.abs(x)
>>> stats.pearsonr(x, y)
PearsonRResult(statistic=-0.05444919272687482, pvalue=0.22422294836207743)
A non-zero correlation coefficient can be misleading. For example, if X has
a standard normal distribution, define y = x if x < 0 and y = 0 otherwise.
A simple calculation shows that corr(x, y) = sqrt(2/Pi) = 0.797...,
implying a high level of correlation:
>>> y = np.where(x < 0, x, 0)
>>> stats.pearsonr(x, y)
PearsonRResult(statistic=0.861985781588, pvalue=4.813432002751103e-149)
This is unintuitive since there is no dependence of x and y if x is larger
than zero which happens in about half of the cases if we sample x and y.
z"x and y must have the same length.r� z$x and y must have length at least 2.z+This function does not support complex datar �GAn input array is constant; the correlation coefficient is not defined.)r� r� r� r� r� r r� g�vIh�%<=zZAn input array is nearly constant; the computed correlation coefficient may be inaccurate.r� r� )�locr8 r{ ry rz z;alternative must be one of ["two-sided", "less", "greater"]) r� r� rk r r� r� �complexfloatingr� r� r� r' r{ r� r rA r� r� r r r} r> �NearConstantInputWarning�dotr� rr �betar r~ )r� r� r� r� r� �resultr� r� �xmean�ymean�xm�ym�normxm�normym� threshold�ab�distr� s rr rM rM y sZ � �z �A���A��C��F�F�{�{��=�>�>�>��1�u�u��?�@�@�@�
�
�1�
�
�A�
�
�1�
�
�A�
�
�a�g�r� 1�2�2� H��}�Q�W�b�&8�9�9�H��F�G�G�G�
�Q�q�T� ����� �Q�!�A�$�Y�O�O� -� -� �!���
�e�0��5�5�6�6�6� �"�&���1�,7�9� 9� 9���
�
��q��t��a��d�"� #� #�E��A�v�v� �E�"�'�!�A�$��1��+�&�&�r�w�q��t�a��d�{�';�';�;� <� <�� �!�C�1�,7�9� 9� 9���
�
�F�F��F� � �E�
�F�F��F� � �E�
���%� � �5� �B�
���%� � �5� �B�
�[��_�_�F�
�[��_�_�F��I�
� �#�e�*�*�$�$�$���3�u�:�:�1E�(E�(E�<���
�e�4�S�9�9�:�:�:�
��r�&�y�"�V�)�$�$�A� �C��3�K�K�� � �A�
�1��q��B� �:�b�"�"�A� .� .� .�D��k�!�!������Q��� � � ��� �� � ��x�x��{�{��� � � !� !��w�w�q�z�z���� <� =� =� =� �A�d�a�&1� 3� 3� 3� 3rt c �> ������ t j �t j | t j �� � }|j dk st
d� � �t j |dk � � rt
d� � �d|� d�� � v sd|� d�� � v rt t j
d� � S |d dk r0|d
dk r$|d |d z |d |d
z z }n t j }|d |d
z �|d |d z �|d |d z �����fd
��|dk r#�� |d ��z ��� � }�n|dk r2�� |d
��z �|d
|d z � � }�n�|dk �r�t �dz �dz z ��z dz z � � }�� |d ��z ��� � }�� |��z ��� � }d}d|z } t j ||z
� � t j ||� � z |k rt |d� � S |d |k r��� |d ��z ��� � }
�� ���z ��� � || z k rt ||
� � S t# �fd�| | z |�� � } |
�� | ��z ��� � z }n��� |d dz
��z ��� � } �� d��z ��� � || z k rt || � � S t# �|| z d|� � } | �� | ��z ��� � z }nd}
t
|
� � �t' |d� � }t ||� � S )ah Perform a Fisher exact test on a 2x2 contingency table.
The null hypothesis is that the true odds ratio of the populations
underlying the observations is one, and the observations were sampled
from these populations under a condition: the marginals of the
resulting table must equal those of the observed table. The statistic
returned is the unconditional maximum likelihood estimate of the odds
ratio, and the p-value is the probability under the null hypothesis of
obtaining a table at least as extreme as the one that was actually
observed. There are other possible choices of statistic and two-sided
p-value definition associated with Fisher's exact test; please see the
Notes for more information.
Parameters
----------
table : array_like of ints
A 2x2 contingency table. Elements must be non-negative integers.
alternative : {'two-sided', 'less', 'greater'}, optional
Defines the alternative hypothesis.
The following options are available (default is 'two-sided'):
* 'two-sided': the odds ratio of the underlying population is not one
* 'less': the odds ratio of the underlying population is less than one
* 'greater': the odds ratio of the underlying population is greater
than one
See the Notes for more details.
Returns
-------
res : SignificanceResult
An object containing attributes:
statistic : float
This is the prior odds ratio, not a posterior estimate.
pvalue : float
The probability under the null hypothesis of obtaining a
table at least as extreme as the one that was actually observed.
See Also
--------
chi2_contingency : Chi-square test of independence of variables in a
contingency table. This can be used as an alternative to
`fisher_exact` when the numbers in the table are large.
contingency.odds_ratio : Compute the odds ratio (sample or conditional
MLE) for a 2x2 contingency table.
barnard_exact : Barnard's exact test, which is a more powerful alternative
than Fisher's exact test for 2x2 contingency tables.
boschloo_exact : Boschloo's exact test, which is a more powerful alternative
than Fisher's exact test for 2x2 contingency tables.
Notes
-----
*Null hypothesis and p-values*
The null hypothesis is that the true odds ratio of the populations
underlying the observations is one, and the observations were sampled at
random from these populations under a condition: the marginals of the
resulting table must equal those of the observed table. Equivalently,
the null hypothesis is that the input table is from the hypergeometric
distribution with parameters (as used in `hypergeom`)
``M = a + b + c + d``, ``n = a + b`` and ``N = a + c``, where the
input table is ``[[a, b], [c, d]]``. This distribution has support
``max(0, N + n - M) <= x <= min(N, n)``, or, in terms of the values
in the input table, ``min(0, a - d) <= x <= a + min(b, c)``. ``x``
can be interpreted as the upper-left element of a 2x2 table, so the
tables in the distribution have form::
[ x n - x ]
[N - x M - (n + N) + x]
For example, if::
table = [6 2]
[1 4]
then the support is ``2 <= x <= 7``, and the tables in the distribution
are::
[2 6] [3 5] [4 4] [5 3] [6 2] [7 1]
[5 0] [4 1] [3 2] [2 3] [1 4] [0 5]
The probability of each table is given by the hypergeometric distribution
``hypergeom.pmf(x, M, n, N)``. For this example, these are (rounded to
three significant digits)::
x 2 3 4 5 6 7
p 0.0163 0.163 0.408 0.326 0.0816 0.00466
These can be computed with::
>>> import numpy as np
>>> from scipy.stats import hypergeom
>>> table = np.array([[6, 2], [1, 4]])
>>> M = table.sum()
>>> n = table[0].sum()
>>> N = table[:, 0].sum()
>>> start, end = hypergeom.support(M, n, N)
>>> hypergeom.pmf(np.arange(start, end+1), M, n, N)
array([0.01631702, 0.16317016, 0.40792541, 0.32634033, 0.08158508,
0.004662 ])
The two-sided p-value is the probability that, under the null hypothesis,
a random table would have a probability equal to or less than the
probability of the input table. For our example, the probability of
the input table (where ``x = 6``) is 0.0816. The x values where the
probability does not exceed this are 2, 6 and 7, so the two-sided p-value
is ``0.0163 + 0.0816 + 0.00466 ~= 0.10256``::
>>> from scipy.stats import fisher_exact
>>> res = fisher_exact(table, alternative='two-sided')
>>> res.pvalue
0.10256410256410257
The one-sided p-value for ``alternative='greater'`` is the probability
that a random table has ``x >= a``, which in our example is ``x >= 6``,
or ``0.0816 + 0.00466 ~= 0.08626``::
>>> res = fisher_exact(table, alternative='greater')
>>> res.pvalue
0.08624708624708627
This is equivalent to computing the survival function of the
distribution at ``x = 5`` (one less than ``x`` from the input table,
because we want to include the probability of ``x = 6`` in the sum)::
>>> hypergeom.sf(5, M, n, N)
0.08624708624708627
For ``alternative='less'``, the one-sided p-value is the probability
that a random table has ``x <= a``, (i.e. ``x <= 6`` in our example),
or ``0.0163 + 0.163 + 0.408 + 0.326 + 0.0816 ~= 0.9949``::
>>> res = fisher_exact(table, alternative='less')
>>> res.pvalue
0.9953379953379957
This is equivalent to computing the cumulative distribution function
of the distribution at ``x = 6``:
>>> hypergeom.cdf(6, M, n, N)
0.9953379953379957
*Odds ratio*
The calculated odds ratio is different from the value computed by the
R function ``fisher.test``. This implementation returns the "sample"
or "unconditional" maximum likelihood estimate, while ``fisher.test``
in R uses the conditional maximum likelihood estimate. To compute the
conditional maximum likelihood estimate of the odds ratio, use
`scipy.stats.contingency.odds_ratio`.
Examples
--------
Say we spend a few days counting whales and sharks in the Atlantic and
Indian oceans. In the Atlantic ocean we find 8 whales and 1 shark, in the
Indian ocean 2 whales and 5 sharks. Then our contingency table is::
Atlantic Indian
whales 8 2
sharks 1 5
We use this table to find the p-value:
>>> from scipy.stats import fisher_exact
>>> res = fisher_exact([[8, 2], [1, 5]])
>>> res.pvalue
0.0349...
The probability that we would observe this or an even more imbalanced ratio
by chance is about 3.5%. A commonly used significance level is 5%--if we
adopt that, we can therefore conclude that our observed imbalance is
statistically significant; whales prefer the Atlantic while sharks prefer
the Indian ocean.
r� �r� r� z*The input `table` must be of shape (2, 2).r z*All values in `table` must be nonnegative.r r r� �r r r� )r r )r r c �: �� �� | ��z ��� � S r� )�pmf)r� � hypergeomr� r� r� s ����rr r� zfisher_exact.<locals>.pmfO s �� ��}�}�Q��R���Q�/�/�/rt ry rz r{ r� g�+����=c � �� �| � � S r� r� )r� r� s �rr r� z fisher_exact.<locals>.<lambda>g s �� �c�c�!�f�f�W� rt z?`alternative` should be one of {'two-sided', 'less', 'greater'})r r� rk r �int64rz r� rG r� r� r r� r~ r� r� r> r �_binary_searchr rr )�tabler� rP � oddsratior� r- �pexact�pmode�epsilon�gamma�plower�guess�pupperr� r� r� r� r� r� s @@@@@rr rN rN � s� ������ �b �'�I�
�
�5���)�)�)�A� �7�f� � ��E�F�F�F� �v�a�!�e�}�}� G��E�F�F�F��A�E�E�q�E�M�M���Q�!�%�%�Q�%�-�-� /� /� "�"�&�#�.�.�.���w��{�{�q��w��{�{��d�G�a��g�%��4��1�T�7�):�;� � ��F� �
�4��1�T�7� �B�
�4��1�T�7� �B� �$��!�D�'��A�0� 0� 0� 0� 0� 0� 0� 0� �f� � �� � �q��w��R���Q�7�7��� � � !� !�� � �q��w��R���Q�t�W�q��w�5F�G�G��� � � #� #��A��E�b�1�f�%��b��1��5�6�6��� � �q��w��R���Q�7�7���
�
�d�B��G�R��3�3�����G� ��
�6�&�5�.� !� !�B�J�v�u�$=�$=� =�� H� H�%�i��4�4� 4�
�t�W�t�^�^� �]�]�1�T�7�B��G�R��;�;�F��}�}�Q��R���Q�/�/�&�5�.�@�@�)�)�V�<�<�<�"�#4�#4�#4�#4�v�g��o�t�Q�O�O�E��i�l�l�5�"�r�'�2�q� A� A�A�F�F� �\�\�!�D�'�A�+�r�B�w��A�>�>�F��}�}�Q��R���Q�/�/�&�5�.�@�@�)�)�V�<�<�<�"�3�����4�@�@�E��i�m�m�E�2��7�B�� B� B�B�F�F�O����o�o� �
���
�
�F� �i�� 0� 0�0rt c � � |�(|dk r"t d� |� � � � �t | |� � \ } }| j dk rt d� � �|�| j dk rt d� � �nFt ||� � \ }}|dk rt j | |f� � } nt j | |f� � } | j d|z
}| j | }|dk r7t t j t j � � } t j | _
| S d}
|dk r�| dd�df d | dd�df k � � � s2| dd�df d | dd�df k � � � r]t j
t j |
� � � � t t j t j � � } t j | _
| S n�| ddd�f d | ddd�f k � � � s2| ddd�f d | ddd�f k � � � r]t j
t j |
� � � � t t j t j � � } t j | _
| S t! | |� � \ } }t j |t$ � � � } | r�|d
k rt' j | |||� � � S |d k rp| j dk s|dk r7t t j t j � � } t j | _
| S t j | � � � |�
� � } t j t0 || � � }
t j |
|�� � }|dz
}t j d�� � 5 |t j ||dz d|z
z z � d� � � � z }ddd� � n # 1 swxY w Y t; |||� � \ }}|j dk r+t |d |d � � } |d | _
| S t j || dd�f< t j |dd�| f< t ||� � } || _
| S )a� Calculate a Spearman correlation coefficient with associated p-value.
The Spearman rank-order correlation coefficient is a nonparametric measure
of the monotonicity of the relationship between two datasets.
Like other correlation coefficients,
this one varies between -1 and +1 with 0 implying no correlation.
Correlations of -1 or +1 imply an exact monotonic relationship. Positive
correlations imply that as x increases, so does y. Negative correlations
imply that as x increases, y decreases.
The p-value roughly indicates the probability of an uncorrelated system
producing datasets that have a Spearman correlation at least as extreme
as the one computed from these datasets. Although calculation of the
p-value does not make strong assumptions about the distributions underlying
the samples, it is only accurate for very large samples (>500
observations). For smaller sample sizes, consider a permutation test (see
Examples section below).
Parameters
----------
a, b : 1D or 2D array_like, b is optional
One or two 1-D or 2-D arrays containing multiple variables and
observations. When these are 1-D, each represents a vector of
observations of a single variable. For the behavior in the 2-D case,
see under ``axis``, below.
Both arrays need to have the same length in the ``axis`` dimension.
axis : int or None, optional
If axis=0 (default), then each column represents a variable, with
observations in the rows. If axis=1, the relationship is transposed:
each row represents a variable, while the columns contain observations.
If axis=None, then both arrays will be raveled.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan.
The following options are available (default is 'propagate'):
* 'propagate': returns nan
* 'raise': throws an error
* 'omit': performs the calculations ignoring nan values
alternative : {'two-sided', 'less', 'greater'}, optional
Defines the alternative hypothesis. Default is 'two-sided'.
The following options are available:
* 'two-sided': the correlation is nonzero
* 'less': the correlation is negative (less than zero)
* 'greater': the correlation is positive (greater than zero)
.. versionadded:: 1.7.0
Returns
-------
res : SignificanceResult
An object containing attributes:
statistic : float or ndarray (2-D square)
Spearman correlation matrix or correlation coefficient (if only 2
variables are given as parameters). Correlation matrix is square
with length equal to total number of variables (columns or rows) in
``a`` and ``b`` combined.
pvalue : float
The p-value for a hypothesis test whose null hypothesis
is that two sets of data are linearly uncorrelated. See
`alternative` above for alternative hypotheses. `pvalue` has the
same shape as `statistic`.
Warns
-----
`~scipy.stats.ConstantInputWarning`
Raised if an input is a constant array. The correlation coefficient
is not defined in this case, so ``np.nan`` is returned.
References
----------
.. [1] Zwillinger, D. and Kokoska, S. (2000). CRC Standard
Probability and Statistics Tables and Formulae. Chapman & Hall: New
York. 2000.
Section 14.7
.. [2] Kendall, M. G. and Stuart, A. (1973).
The Advanced Theory of Statistics, Volume 2: Inference and Relationship.
Griffin. 1973.
Section 31.18
Examples
--------
>>> import numpy as np
>>> from scipy import stats
>>> res = stats.spearmanr([1, 2, 3, 4, 5], [5, 6, 7, 8, 7])
>>> res.statistic
0.8207826816681233
>>> res.pvalue
0.08858700531354381
>>> rng = np.random.default_rng()
>>> x2n = rng.standard_normal((100, 2))
>>> y2n = rng.standard_normal((100, 2))
>>> res = stats.spearmanr(x2n)
>>> res.statistic, res.pvalue
(-0.07960396039603959, 0.4311168705769747)
>>> res = stats.spearmanr(x2n[:, 0], x2n[:, 1])
>>> res.statistic, res.pvalue
(-0.07960396039603959, 0.4311168705769747)
>>> res = stats.spearmanr(x2n, y2n)
>>> res.statistic
array([[ 1. , -0.07960396, -0.08314431, 0.09662166],
[-0.07960396, 1. , -0.14448245, 0.16738074],
[-0.08314431, -0.14448245, 1. , 0.03234323],
[ 0.09662166, 0.16738074, 0.03234323, 1. ]])
>>> res.pvalue
array([[0. , 0.43111687, 0.41084066, 0.33891628],
[0.43111687, 0. , 0.15151618, 0.09600687],
[0.41084066, 0.15151618, 0. , 0.74938561],
[0.33891628, 0.09600687, 0.74938561, 0. ]])
>>> res = stats.spearmanr(x2n.T, y2n.T, axis=1)
>>> res.statistic
array([[ 1. , -0.07960396, -0.08314431, 0.09662166],
[-0.07960396, 1. , -0.14448245, 0.16738074],
[-0.08314431, -0.14448245, 1. , 0.03234323],
[ 0.09662166, 0.16738074, 0.03234323, 1. ]])
>>> res = stats.spearmanr(x2n, y2n, axis=None)
>>> res.statistic, res.pvalue
(0.044981624540613524, 0.5270803651336189)
>>> res = stats.spearmanr(x2n.ravel(), y2n.ravel())
>>> res.statistic, res.pvalue
(0.044981624540613524, 0.5270803651336189)
>>> rng = np.random.default_rng()
>>> xint = rng.integers(10, size=(100, 2))
>>> res = stats.spearmanr(xint)
>>> res.statistic, res.pvalue
(0.09800224850707953, 0.3320271757932076)
For small samples, consider performing a permutation test instead of
relying on the asymptotic p-value. Note that to calculate the null
distribution of the statistic (for all possibly pairings between
observations in sample ``x`` and ``y``), only one of the two inputs needs
to be permuted.
>>> x = [1.76405235, 0.40015721, 0.97873798,
... 2.2408932, 1.86755799, -0.97727788]
>>> y = [2.71414076, 0.2488, 0.87551913,
... 2.6514917, 2.01160156, 0.47699563]
>>> def statistic(x): # permute only `x`
... return stats.spearmanr(x, y).statistic
>>> res_exact = stats.permutation_test((x,), statistic,
... permutation_type='pairings')
>>> res_asymptotic = stats.spearmanr(x, y)
>>> res_exact.pvalue, res_asymptotic.pvalue # asymptotic pvalue is too low
(0.10277777777777777, 0.07239650145772594)
Nr zqspearmanr only handles 1-D or 2-D arrays, supplied axis argument {}, please use only values 0, 1 or None for axisr� z(spearmanr only handles 1-D or 2-D arraysz1`spearmanr` needs at least 2 variables to comparer r� r� r� )rp r� r� r� r )�rowvarr� r� r� r� r� ) r� r1 rs rm rk � column_stack� row_stackrz r� r r� r� r� r� r' r{ r rD �boolr� rO r� rG r ra �corrcoefr� r �clip�
_ttest_finish)ro rv rp r� r� �axisoutr� �n_vars�n_obsr �warn_msg�a_contains_nan�variable_has_nan�a_ranked�rs�dofr r� s rr rO rO y s� � �n ��D�1�H�H�� 8�8>��t� � �F� F� F� �a��&�&�J�A�w��v��z�z��C�D�D�D��y� �6�A�:�:� � 4� 5� 5�
5� � �A�t�$�$���1� �a�<�<����A��'�'�A�A�� �a��V�$�$�A�
�W�Q��[�
!�F�
�G�G� �E� ��z�z� �����0�0�� �&����
�"�H��!�|�|�
�a�a�a��d�G�A�J�!�A�A�A�q�D�'� !� &� &� (� (� �Q�q�q�q�!�t�W�Q�Z�1�Q�Q�Q��T�7�-B�,G�,G�,I�,I� �
�M�%�4�X�>�>� ?� ?� ?�$�R�V�R�V�4�4�C� �f�C�O��J�
�
�a����d�G�A�J�!�A�q�q�q�D�'� !� &� &� (� (� �Q�q�!�!�!�t�W�Q�Z�1�Q����T�7�-B�,G�,G�,I�,I� �
�M�%�4�X�>�>� ?� ?� ?�$�R�V�R�V�4�4�C� �f�C�O��J�!.�q�*�!=�!=� �N�J��x��d�3�3�3��� A� �� � � �)�!�$�:�6A�C� C� C�
C�
�;�
&�
&��v��{�{�f��k�k�(�����8�8��"$�&����
� $&�8�A�;�;�?�?��?�#@�#@� ��"�8�W�a�8�8�H� ��X�g� .� .� .�B�
�!�)�C�
��H� %� %� %� <� <�
���#��3���R�� 0�1�7�7��:�:�;�;� ;��<� <� <� <� <� <� <� <� <� <� <���� <� <� <� <�
�C��K�0�0�G�A�t�
�x�6��� ��D��4��:�6�6�� �T�(����
�"$�&�� �Q�Q�Q� � �"$�&��1�1�1� � � � ��T�*�*�� ����
s �/7O2�2O6�9O6c �Z � t | |� � \ }}t ||� � }||_ |S )a~ Calculate a point biserial correlation coefficient and its p-value.
The point biserial correlation is used to measure the relationship
between a binary variable, x, and a continuous variable, y. Like other
correlation coefficients, this one varies between -1 and +1 with 0
implying no correlation. Correlations of -1 or +1 imply a determinative
relationship.
This function may be computed using a shortcut formula but produces the
same result as `pearsonr`.
Parameters
----------
x : array_like of bools
Input array.
y : array_like
Input array.
Returns
-------
res: SignificanceResult
An object containing attributes:
statistic : float
The R value.
pvalue : float
The two-sided p-value.
Notes
-----
`pointbiserialr` uses a t-test with ``n-1`` degrees of freedom.
It is equivalent to `pearsonr`.
The value of the point-biserial correlation can be calculated from:
.. math::
r_{pb} = \frac{\overline{Y_{1}} -
\overline{Y_{0}}}{s_{y}}\sqrt{\frac{N_{1} N_{2}}{N (N - 1))}}
Where :math:`Y_{0}` and :math:`Y_{1}` are means of the metric
observations coded 0 and 1 respectively; :math:`N_{0}` and :math:`N_{1}`
are number of observations coded 0 and 1 respectively; :math:`N` is the
total number of observations and :math:`s_{y}` is the standard
deviation of all the metric observations.
A value of :math:`r_{pb}` that is significantly different from zero is
completely equivalent to a significant difference in means between the two
groups. Thus, an independent groups t Test with :math:`N-2` degrees of
freedom may be used to test whether :math:`r_{pb}` is nonzero. The
relation between the t-statistic for comparing two independent groups and
:math:`r_{pb}` is given by:
.. math::
t = \sqrt{N - 2}\frac{r_{pb}}{\sqrt{1 - r^{2}_{pb}}}
References
----------
.. [1] J. Lev, "The Point Biserial Coefficient of Correlation", Ann. Math.
Statist., Vol. 20, no.1, pp. 125-126, 1949.
.. [2] R.F. Tate, "Correlation Between a Discrete and a Continuous
Variable. Point-Biserial Correlation.", Ann. Math. Statist., Vol. 25,
np. 3, pp. 603-607, 1954.
.. [3] D. Kornbrot "Point Biserial Correlation", In Wiley StatsRef:
Statistics Reference Online (eds N. Balakrishnan, et al.), 2014.
:doi:`10.1002/9781118445112.stat06227`
Examples
--------
>>> import numpy as np
>>> from scipy import stats
>>> a = np.array([0, 0, 0, 1, 1, 1, 1])
>>> b = np.arange(7)
>>> stats.pointbiserialr(a, b)
(0.8660254037844386, 0.011724811003954652)
>>> stats.pearsonr(a, b)
(0.86602540378443871, 0.011724811003954626)
>>> np.corrcoef(a, b)
array([[ 1. , 0.8660254],
[ 0.8660254, 1. ]])
)rM r� r� )r� r� �rpbr� r s rr rP rP j s1 � �l ��A���I�C��
�S�$�
'�
'�C��C�O� �Jrt �autorv c �H � |� d}t j |t d�� � t j | � � � � � } t j |� � � � � }| j |j k r t d| j � d|j � �� � �| j r|j s7t t j t j � � }t j |_
|S t | |� � \ } }
t ||� � \ } } | p| }
|
dk s| dk rd}|
r=|dk r7t t j t j � � }t j |_
|S |
r^|dk rXt j
| � � } t j
|� � }|d k rt j | ||d
|� � � S d }t |� � �d
� }| j }t j |� � }| | || }} t j d
|dd� |dd� k f � t j �� � }t j | d�� � }| | || }} t j d
| dd� | dd� k f � t j �� � } t) | |� � }t j d
| dd� | dd� k |dd� |dd� k z d
f }t j t j |� � d � � � dd�� � }||dz
z dz � � � } || � � \ }}} ||� � \ }}}||dz
z dz } || k s|| k r7t t j t j � � }t j |_
|S | |z
|z
|z d|z z
} |d k r3| t j | |z
� � z t j | |z
� � z } nr|dk rYt5 t7 t9 | � � � � t7 t9 |� � � � � � } d| z |dz | dz
z | z z } nt d|� d�� � �t5 dt; d| � � � � } |d k r|dk s|dk rt d � � �|d k r.|dk r&|dk r |d k st5 || |z
� � dk rd }nd }|dk r&|dk r |d k rt j || |z
|� � } n~|d k re||dz
z }!|!d|z d!z z |z
|z
d"z d|z |z |!z z ||z d#|!z |dz
z z z }"| t j |"� � z }#t? |#|� � \ }$} nt d$|� d%�� � �t | | � � }| |_
|S )&a� Calculate Kendall's tau, a correlation measure for ordinal data.
Kendall's tau is a measure of the correspondence between two rankings.
Values close to 1 indicate strong agreement, and values close to -1
indicate strong disagreement. This implements two variants of Kendall's
tau: tau-b (the default) and tau-c (also known as Stuart's tau-c). These
differ only in how they are normalized to lie within the range -1 to 1;
the hypothesis tests (their p-values) are identical. Kendall's original
tau-a is not implemented separately because both tau-b and tau-c reduce
to tau-a in the absence of ties.
Parameters
----------
x, y : array_like
Arrays of rankings, of the same shape. If arrays are not 1-D, they
will be flattened to 1-D.
initial_lexsort : bool, optional, deprecated
This argument is unused.
.. deprecated:: 1.10.0
`kendalltau` keyword argument `initial_lexsort` is deprecated as it
is unused and will be removed in SciPy 1.12.0.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan.
The following options are available (default is 'propagate'):
* 'propagate': returns nan
* 'raise': throws an error
* 'omit': performs the calculations ignoring nan values
method : {'auto', 'asymptotic', 'exact'}, optional
Defines which method is used to calculate the p-value [5]_.
The following options are available (default is 'auto'):
* 'auto': selects the appropriate method based on a trade-off
between speed and accuracy
* 'asymptotic': uses a normal approximation valid for large samples
* 'exact': computes the exact p-value, but can only be used if no ties
are present. As the sample size increases, the 'exact' computation
time may grow and the result may lose some precision.
variant : {'b', 'c'}, optional
Defines which variant of Kendall's tau is returned. Default is 'b'.
alternative : {'two-sided', 'less', 'greater'}, optional
Defines the alternative hypothesis. Default is 'two-sided'.
The following options are available:
* 'two-sided': the rank correlation is nonzero
* 'less': the rank correlation is negative (less than zero)
* 'greater': the rank correlation is positive (greater than zero)
Returns
-------
res : SignificanceResult
An object containing attributes:
statistic : float
The tau statistic.
pvalue : float
The p-value for a hypothesis test whose null hypothesis is
an absence of association, tau = 0.
See Also
--------
spearmanr : Calculates a Spearman rank-order correlation coefficient.
theilslopes : Computes the Theil-Sen estimator for a set of points (x, y).
weightedtau : Computes a weighted version of Kendall's tau.
Notes
-----
The definition of Kendall's tau that is used is [2]_::
tau_b = (P - Q) / sqrt((P + Q + T) * (P + Q + U))
tau_c = 2 (P - Q) / (n**2 * (m - 1) / m)
where P is the number of concordant pairs, Q the number of discordant
pairs, T the number of ties only in `x`, and U the number of ties only in
`y`. If a tie occurs for the same pair in both `x` and `y`, it is not
added to either T or U. n is the total number of samples, and m is the
number of unique values in either `x` or `y`, whichever is smaller.
References
----------
.. [1] Maurice G. Kendall, "A New Measure of Rank Correlation", Biometrika
Vol. 30, No. 1/2, pp. 81-93, 1938.
.. [2] Maurice G. Kendall, "The treatment of ties in ranking problems",
Biometrika Vol. 33, No. 3, pp. 239-251. 1945.
.. [3] Gottfried E. Noether, "Elements of Nonparametric Statistics", John
Wiley & Sons, 1967.
.. [4] Peter M. Fenwick, "A new data structure for cumulative frequency
tables", Software: Practice and Experience, Vol. 24, No. 3,
pp. 327-336, 1994.
.. [5] Maurice G. Kendall, "Rank Correlation Methods" (4th Edition),
Charles Griffin & Co., 1970.
Examples
--------
>>> from scipy import stats
>>> x1 = [12, 2, 1, 12, 2]
>>> x2 = [1, 4, 7, 1, 0]
>>> res = stats.kendalltau(x1, x2)
>>> res.statistic
-0.47140452079103173
>>> res.pvalue
0.2827454599327748
Nzr'kendalltau' keyword argument 'initial_lexsort' is deprecated as it is unused and will be removed in SciPy 1.12.0.r� r� zBAll inputs to `kendalltau` must be of the same size, found x-size � and y-size r� r� rv T)r. �use_tiesr� z@nan_policy='omit' is currently compatible only with variant='b'.c �* � t j | � � � dd�� � }||dk }||dz
z dz � � � ||dz
z |dz
z � � � ||dz
z d|z dz z � � � fS )Nr� F�r� r r� r� r� )rk �bincountr r� )�ranks�cnts rr �count_rank_tiez"kendalltau.<locals>.count_rank_tie\ s� � ��k�%� � �'�'��e�'�<�<���#��'�l����a�� �A�%�*�*�,�,���b��!�S�1�W�-�2�2�4�4���b��!�Q�s�U�Q�Y�/�4�4�6�6�8� 8rt r r� r� � mergesort�r@ r r� Fr rP z&Unknown variant of the method chosen: z . variant must be 'b' or 'c'.r� r� �exactz(Ties found, exact method cannot be used.r r� �
asymptoticr� � r� zUnknown method z1 specified. Use 'auto', 'exact' or 'asymptotic'.) r� r� r� rk r rl r� r� r� r r� r r r� r� rQ �argsort�r_r� �intpr �diff�nonzeror r� r rr r� �setr� �_kendall_p_exactr� )%r� r� �initial_lexsortr� r. �variantr� r� r �cnx�npx�cny�npyr� r� r r� �perm�dis�obsr �ntie�xtie�x0�x1�ytie�y0�y1�tot�
con_minus_dis�tau�
minclassesr� rt r r� r� s% rr rQ rQ � s � �Z �"�G���
�c�-�!�<�<�<�<�
�
�1�
�
��� � �A�
�
�1�
�
��� � �A��v������ L�/0�v�L� L�CD�6�L� L� M� M� M�
�V� �1�6� � �����0�0�� �&����
� �Q�
�+�+�H�C�� �Q�
�+�+�H�C���:�#�L�
�f�}�}��v�
�
��
�� &�
�k�1�1� �����0�0�� �&����
� � &�*��.�.� � �a� � �� � �a� � �� �c�>�>� �*�1�a���7B�D� D� D�
D�&�G� �W�%�%� %�8� 8� 8�
�6�D�
�:�a�=�=�D� �T�7�A�d�G�q�A�
��d�A�a�b�b�E�Q�s��s�V�O�#�$�+�+�"�'�+�:�:�A� �:�a�k� *� *� *�D� �T�7�A�d�G�q�A�
��d�A�a�b�b�E�Q�s��s�V�O�#�$�+�+�"�'�+�:�:�A�
�q�!�
�
�C�
�%��q����u��#�2�#���1�Q�R�R�5�A�c�r�c�F�?�;�T�A�
B�C�
�'�"�*�S�/�/�!�$�
%�
%�
,�
,�W�5�
,�
A�
A�C� �3��7�O�q� � %� %� '� '�D�!�>�!�$�$�L�D�"�b�!�>�!�$�$�L�D�"�b� �4�!�8� ��
"�C� �s�{�{�d�c�k�k� �����0�0�� �&����
� �$�J��%��,�q�3�w�6�M��#�~�~��b�g�c�D�j� 1� 1�1�B�G�C�$�J�4G�4G�G��� �C� � ���S��V�V���c�#�a�&�&�k�k�2�2�
��
�o��q��J�q�L�!9�*�!D�E���� 7�'� 7� 7� 7� 8� 8� 8� �b�#�c�3�-�-�
�
�C� ����d�a�i�i�4�1�9�9��C�D�D�D�
���� �A�I�I�$�!�)�)�$�"�*�*�*-�c�3�s�7�*;�*;�q�*@�*@� �F�F�!�F� �q�y�y�T�Q�Y�Y�6�W�#4�#4� �.�t�S��W�k�J�J��� �<� � � �D�2�I� ���Q�t�V�a�Z� �2�%��*�b�0��D��4��1�$�%�')�B�w�!�a�%�4�!�8�2D�'E�F�� �B�G�C�L�L� (��$�Q� �4�4� ��6�6�� 4�6� 4� 4� 4� 5� 5� 5� �S�&�
)�
)�C��C�O� �Jrt c � � t j | � � � � � } t j |� � � � � }| j |j k r t d| j �d|j ��� � �| j s7t t j t j � � }t j |_ |S t j t j | � � � � rt | � � } t j t j |� � � � rt |� � }| j |j k rI| j t j k rt | � � } |j t j k rt |� � }nS| j t j
t j t j t j fvr t | � � } t |� � }|du rMt! | |d||� � t! || d||� � z dz }t |t j � � }||_ |S |du r&t j | j t j �� � }nW|�Ut j |� � � � � }|j | j k r t d| j �d|j ��� � �t! | ||||� � }t |t j � � }||_ |S ) a� Compute a weighted version of Kendall's :math:`\tau`.
The weighted :math:`\tau` is a weighted version of Kendall's
:math:`\tau` in which exchanges of high weight are more influential than
exchanges of low weight. The default parameters compute the additive
hyperbolic version of the index, :math:`\tau_\mathrm h`, which has
been shown to provide the best balance between important and
unimportant elements [1]_.
The weighting is defined by means of a rank array, which assigns a
nonnegative rank to each element (higher importance ranks being
associated with smaller values, e.g., 0 is the highest possible rank),
and a weigher function, which assigns a weight based on the rank to
each element. The weight of an exchange is then the sum or the product
of the weights of the ranks of the exchanged elements. The default
parameters compute :math:`\tau_\mathrm h`: an exchange between
elements with rank :math:`r` and :math:`s` (starting from zero) has
weight :math:`1/(r+1) + 1/(s+1)`.
Specifying a rank array is meaningful only if you have in mind an
external criterion of importance. If, as it usually happens, you do
not have in mind a specific rank, the weighted :math:`\tau` is
defined by averaging the values obtained using the decreasing
lexicographical rank by (`x`, `y`) and by (`y`, `x`). This is the
behavior with default parameters. Note that the convention used
here for ranking (lower values imply higher importance) is opposite
to that used by other SciPy statistical functions.
Parameters
----------
x, y : array_like
Arrays of scores, of the same shape. If arrays are not 1-D, they will
be flattened to 1-D.
rank : array_like of ints or bool, optional
A nonnegative rank assigned to each element. If it is None, the
decreasing lexicographical rank by (`x`, `y`) will be used: elements of
higher rank will be those with larger `x`-values, using `y`-values to
break ties (in particular, swapping `x` and `y` will give a different
result). If it is False, the element indices will be used
directly as ranks. The default is True, in which case this
function returns the average of the values obtained using the
decreasing lexicographical rank by (`x`, `y`) and by (`y`, `x`).
weigher : callable, optional
The weigher function. Must map nonnegative integers (zero
representing the most important element) to a nonnegative weight.
The default, None, provides hyperbolic weighing, that is,
rank :math:`r` is mapped to weight :math:`1/(r+1)`.
additive : bool, optional
If True, the weight of an exchange is computed by adding the
weights of the ranks of the exchanged elements; otherwise, the weights
are multiplied. The default is True.
Returns
-------
res: SignificanceResult
An object containing attributes:
statistic : float
The weighted :math:`\tau` correlation index.
pvalue : float
Presently ``np.nan``, as the null distribution of the statistic is
unknown (even in the additive hyperbolic case).
See Also
--------
kendalltau : Calculates Kendall's tau.
spearmanr : Calculates a Spearman rank-order correlation coefficient.
theilslopes : Computes the Theil-Sen estimator for a set of points (x, y).
Notes
-----
This function uses an :math:`O(n \log n)`, mergesort-based algorithm
[1]_ that is a weighted extension of Knight's algorithm for Kendall's
:math:`\tau` [2]_. It can compute Shieh's weighted :math:`\tau` [3]_
between rankings without ties (i.e., permutations) by setting
`additive` and `rank` to False, as the definition given in [1]_ is a
generalization of Shieh's.
NaNs are considered the smallest possible score.
.. versionadded:: 0.19.0
References
----------
.. [1] Sebastiano Vigna, "A weighted correlation index for rankings with
ties", Proceedings of the 24th international conference on World
Wide Web, pp. 1166-1176, ACM, 2015.
.. [2] W.R. Knight, "A Computer Method for Calculating Kendall's Tau with
Ungrouped Data", Journal of the American Statistical Association,
Vol. 61, No. 314, Part 1, pp. 436-439, 1966.
.. [3] Grace S. Shieh. "A weighted Kendall's tau statistic", Statistics &
Probability Letters, Vol. 39, No. 1, pp. 17-24, 1998.
Examples
--------
>>> import numpy as np
>>> from scipy import stats
>>> x = [12, 2, 1, 12, 2]
>>> y = [1, 4, 7, 1, 0]
>>> res = stats.weightedtau(x, y)
>>> res.statistic
-0.56694968153682723
>>> res.pvalue
nan
>>> res = stats.weightedtau(x, y, additive=False)
>>> res.statistic
-0.62205716951801038
NaNs are considered the smallest possible score:
>>> x = [12, 2, 1, 12, 2]
>>> y = [1, 4, 7, 1, np.nan]
>>> res = stats.weightedtau(x, y)
>>> res.statistic
-0.56694968153682723
This is exactly Kendall's tau:
>>> x = [12, 2, 1, 12, 2]
>>> y = [1, 4, 7, 1, 0]
>>> res = stats.weightedtau(x, y, weigher=lambda x: 1)
>>> res.statistic
-0.47140452079103173
>>> x = [12, 2, 1, 12, 2]
>>> y = [1, 4, 7, 1, 0]
>>> stats.weightedtau(x, y, rank=None)
SignificanceResult(statistic=-0.4157652301037516, pvalue=nan)
>>> stats.weightedtau(y, x, rank=None)
SignificanceResult(statistic=-0.7181341329699028, pvalue=nan)
zCAll inputs to `weightedtau` must be of the same size, found x-size r TNr� Fr� z and rank-size )rk r rl r� r� r� r r� r� r� r r� r� �int32�float32rB r �aranger )r� r� r� �weigher�additiver r+ s rr rR rR � sr � �J �
�1�
�
��� � �A�
�
�1�
�
��� � �A��v������j�<=�F�F�F�A�F�F�L� M� M� M�
�6� � �����0�0�� �&����
�
�x���q� � ��� � �Q�K�K�� �x���q� � ��� � �Q�K�K�� �w�!�'��� �7�b�h� � ��� � �A� �7�b�h� � ��� � �A�� �7�2�8�R�X�r�z�2�:�F� F� F��� � �A��� � �A� �t�|�|� �q�!�T�7�H� =� =� �q�!�T�7�H� =� =�
>�
��� !��b�f�-�-�� ����
� �u�}�}��y���r�w�/�/�/���
� ��z�$� � �%�%�'�'�� �9��� � � �*�67�f�f�f�d�i�i�I�� �
�
�Q��4��(�
;�
;�C�
�S�"�&�
)�
)�C��C�O� �Jrt c � � e Zd ZdZd� Zd� ZdS )�
_ParallelPz.Helper function to calculate parallel p-value.c �0 � || _ || _ || _ d S r� �r� r� �
random_states)r� r� r� r7 s rr r� z_ParallelP.__init__m s � ������� *����rt c �� � | j | � | j j d � � }| j | d d �|f }t | j |� � d }|S ri )r7 � permutationr� rz � _mgc_statr� )r� �index�order�permy� perm_stats rr �__call__z_ParallelP.__call__r s[ � ��"�5�)�5�5�d�f�l�1�o�F�F����u�
�a�a�a��h�'�� �d�f�e�,�,�Q�/� ��rt N)r� r� r� r� r� r? r� rt rr r4 r4 j s8 � � � � � �8�8�+� +� +�
� � � � rt r4 r� r� c � �� t �� � ��fd�t |� � D � � }t | ||�� � }t |� � 5 }t j t
||t |� � � � � � � � } ddd� � n # 1 swxY w Y d| |k � � � z d|z z }
|
| fS )a� Helper function that calculates the p-value. See below for uses.
Parameters
----------
x, y : ndarray
`x` and `y` have shapes `(n, p)` and `(n, q)`.
stat : float
The sample test statistic.
reps : int, optional
The number of replications used to estimate the null when using the
permutation test. The default is 1000 replications.
workers : int or map-like callable, optional
If `workers` is an int the population is subdivided into `workers`
sections and evaluated in parallel (uses
`multiprocessing.Pool <multiprocessing>`). Supply `-1` to use all cores
available to the Process. Alternatively supply a map-like callable,
such as `multiprocessing.Pool.map` for evaluating the population in
parallel. This evaluation is carried out as `workers(func, iterable)`.
Requires that `func` be pickleable.
random_state : {None, int, `numpy.random.Generator`,
`numpy.random.RandomState`}, optional
If `seed` is None (or `np.random`), the `numpy.random.RandomState`
singleton is used.
If `seed` is an int, a new ``RandomState`` instance is used,
seeded with `seed`.
If `seed` is already a ``Generator`` or ``RandomState`` instance then
that instance is used.
Returns
-------
pvalue : float
The sample test p-value.
null_dist : list
The approximated null distribution.
c
� �� g | ]<}t j � t �d dt j �� � � � ��=S )l r< )r� r� )rk �random� RandomStater �uint32)r0 r� � random_states �rr r2 z _perm_test.<locals>.<listcomp>� s] �� � E� E� E�34� �Y�*�*�<� �g��2�9�,.� ,.� ,.� /� /� E� E� Ert r6 Nr )r r� r4 r rk r ry r� ) r� r� �stat�reps�workersrE r7 � parallelp�
mapwrapper� null_distr� s ` rr �
_perm_testrL | s( �� �P &�l�3�3�L�E� E� E� E�8=�d� � �E� E� E�M� �Q�!�=�A�A�A�I� �G� � � G�
��H�T�*�*�Y��d� � �"D�"D� E� E�F�F� �G� G� G� G� G� G� G� G� G� G� G���� G� G� G� G� �9��$�)�)�+�+�+��D��
9�F� �9� � s �
9B�B�Bc �" � t | | � � S r� r r� s rr �_euclidean_distrN � s � � ��A�;�;�rt � MGCResult)r� r� �mgc_dictc � � t | t j � � rt |t j � � st d� � �| j dk r| dd�t j f } n2| j dk r't d� | j � � � � �|j dk r|dd�t j f }n2|j dk r't d� |j � � � � �| j \ }}|j \ } }
t | d�� � t |d�� � t j t j
| � � � � d k s*t j t j
|� � � � d k rt d
� � �|| k r||
k rd }nt d � � �|d
k s| d
k rt d� � �| � t j � � } |� t j � � }t |� � s|�t d� � �t |t � � r|d k rt d� � �|dk r d} t j | t" � � |r$|�t d� � �t% | |� � \ } }|� || � � } ||� � }t' | |� � \ } }
|
d }|
d }t) | || |||�� � \ }}|||d�}t+ | ||� � }| |_ |S )a�# Computes the Multiscale Graph Correlation (MGC) test statistic.
Specifically, for each point, MGC finds the :math:`k`-nearest neighbors for
one property (e.g. cloud density), and the :math:`l`-nearest neighbors for
the other property (e.g. grass wetness) [1]_. This pair :math:`(k, l)` is
called the "scale". A priori, however, it is not know which scales will be
most informative. So, MGC computes all distance pairs, and then efficiently
computes the distance correlations for all scales. The local correlations
illustrate which scales are relatively informative about the relationship.
The key, therefore, to successfully discover and decipher relationships
between disparate data modalities is to adaptively determine which scales
are the most informative, and the geometric implication for the most
informative scales. Doing so not only provides an estimate of whether the
modalities are related, but also provides insight into how the
determination was made. This is especially important in high-dimensional
data, where simple visualizations do not reveal relationships to the
unaided human eye. Characterizations of this implementation in particular
have been derived from and benchmarked within in [2]_.
Parameters
----------
x, y : ndarray
If ``x`` and ``y`` have shapes ``(n, p)`` and ``(n, q)`` where `n` is
the number of samples and `p` and `q` are the number of dimensions,
then the MGC independence test will be run. Alternatively, ``x`` and
``y`` can have shapes ``(n, n)`` if they are distance or similarity
matrices, and ``compute_distance`` must be sent to ``None``. If ``x``
and ``y`` have shapes ``(n, p)`` and ``(m, p)``, an unpaired
two-sample MGC test will be run.
compute_distance : callable, optional
A function that computes the distance or similarity among the samples
within each data matrix. Set to ``None`` if ``x`` and ``y`` are
already distance matrices. The default uses the euclidean norm metric.
If you are calling a custom function, either create the distance
matrix before-hand or create a function of the form
``compute_distance(x)`` where `x` is the data matrix for which
pairwise distances are calculated.
reps : int, optional
The number of replications used to estimate the null when using the
permutation test. The default is ``1000``.
workers : int or map-like callable, optional
If ``workers`` is an int the population is subdivided into ``workers``
sections and evaluated in parallel (uses ``multiprocessing.Pool
<multiprocessing>``). Supply ``-1`` to use all cores available to the
Process. Alternatively supply a map-like callable, such as
``multiprocessing.Pool.map`` for evaluating the p-value in parallel.
This evaluation is carried out as ``workers(func, iterable)``.
Requires that `func` be pickleable. The default is ``1``.
is_twosamp : bool, optional
If `True`, a two sample test will be run. If ``x`` and ``y`` have
shapes ``(n, p)`` and ``(m, p)``, this optional will be overridden and
set to ``True``. Set to ``True`` if ``x`` and ``y`` both have shapes
``(n, p)`` and a two sample test is desired. The default is ``False``.
Note that this will not run if inputs are distance matrices.
random_state : {None, int, `numpy.random.Generator`,
`numpy.random.RandomState`}, optional
If `seed` is None (or `np.random`), the `numpy.random.RandomState`
singleton is used.
If `seed` is an int, a new ``RandomState`` instance is used,
seeded with `seed`.
If `seed` is already a ``Generator`` or ``RandomState`` instance then
that instance is used.
Returns
-------
res : MGCResult
An object containing attributes:
statistic : float
The sample MGC test statistic within `[-1, 1]`.
pvalue : float
The p-value obtained via permutation.
mgc_dict : dict
Contains additional useful results:
- mgc_map : ndarray
A 2D representation of the latent geometry of the
relationship.
- opt_scale : (int, int)
The estimated optimal scale as a `(x, y)` pair.
- null_dist : list
The null distribution derived from the permuted matrices.
See Also
--------
pearsonr : Pearson correlation coefficient and p-value for testing
non-correlation.
kendalltau : Calculates Kendall's tau.
spearmanr : Calculates a Spearman rank-order correlation coefficient.
Notes
-----
A description of the process of MGC and applications on neuroscience data
can be found in [1]_. It is performed using the following steps:
#. Two distance matrices :math:`D^X` and :math:`D^Y` are computed and
modified to be mean zero columnwise. This results in two
:math:`n \times n` distance matrices :math:`A` and :math:`B` (the
centering and unbiased modification) [3]_.
#. For all values :math:`k` and :math:`l` from :math:`1, ..., n`,
* The :math:`k`-nearest neighbor and :math:`l`-nearest neighbor graphs
are calculated for each property. Here, :math:`G_k (i, j)` indicates
the :math:`k`-smallest values of the :math:`i`-th row of :math:`A`
and :math:`H_l (i, j)` indicates the :math:`l` smallested values of
the :math:`i`-th row of :math:`B`
* Let :math:`\circ` denotes the entry-wise matrix product, then local
correlations are summed and normalized using the following statistic:
.. math::
c^{kl} = \frac{\sum_{ij} A G_k B H_l}
{\sqrt{\sum_{ij} A^2 G_k \times \sum_{ij} B^2 H_l}}
#. The MGC test statistic is the smoothed optimal local correlation of
:math:`\{ c^{kl} \}`. Denote the smoothing operation as :math:`R(\cdot)`
(which essentially set all isolated large correlations) as 0 and
connected large correlations the same as before, see [3]_.) MGC is,
.. math::
MGC_n (x, y) = \max_{(k, l)} R \left(c^{kl} \left( x_n, y_n \right)
\right)
The test statistic returns a value between :math:`(-1, 1)` since it is
normalized.
The p-value returned is calculated using a permutation test. This process
is completed by first randomly permuting :math:`y` to estimate the null
distribution and then calculating the probability of observing a test
statistic, under the null, at least as extreme as the observed test
statistic.
MGC requires at least 5 samples to run with reliable results. It can also
handle high-dimensional data sets.
In addition, by manipulating the input data matrices, the two-sample
testing problem can be reduced to the independence testing problem [4]_.
Given sample data :math:`U` and :math:`V` of sizes :math:`p \times n`
:math:`p \times m`, data matrix :math:`X` and :math:`Y` can be created as
follows:
.. math::
X = [U | V] \in \mathcal{R}^{p \times (n + m)}
Y = [0_{1 \times n} | 1_{1 \times m}] \in \mathcal{R}^{(n + m)}
Then, the MGC statistic can be calculated as normal. This methodology can
be extended to similar tests such as distance correlation [4]_.
.. versionadded:: 1.4.0
References
----------
.. [1] Vogelstein, J. T., Bridgeford, E. W., Wang, Q., Priebe, C. E.,
Maggioni, M., & Shen, C. (2019). Discovering and deciphering
relationships across disparate data modalities. ELife.
.. [2] Panda, S., Palaniappan, S., Xiong, J., Swaminathan, A.,
Ramachandran, S., Bridgeford, E. W., ... Vogelstein, J. T. (2019).
mgcpy: A Comprehensive High Dimensional Independence Testing Python
Package. :arXiv:`1907.02088`
.. [3] Shen, C., Priebe, C.E., & Vogelstein, J. T. (2019). From distance
correlation to multiscale graph correlation. Journal of the American
Statistical Association.
.. [4] Shen, C. & Vogelstein, J. T. (2018). The Exact Equivalence of
Distance and Kernel Methods for Hypothesis Testing.
:arXiv:`1806.05514`
Examples
--------
>>> import numpy as np
>>> from scipy.stats import multiscale_graphcorr
>>> x = np.arange(100)
>>> y = x
>>> res = multiscale_graphcorr(x, y)
>>> res.statistic, res.pvalue
(1.0, 0.001)
To run an unpaired two-sample test,
>>> x = np.arange(100)
>>> y = np.arange(79)
>>> res = multiscale_graphcorr(x, y)
>>> res.statistic, res.pvalue # doctest: +SKIP
(0.033258146255703246, 0.023)
or, if shape of the inputs are the same,
>>> x = np.arange(100)
>>> y = x
>>> res = multiscale_graphcorr(x, y, is_twosamp=True)
>>> res.statistic, res.pvalue # doctest: +SKIP
(-0.008021809890200488, 1.0)
zx and y must be ndarraysr Nr� z(Expected a 2-D array `x`, found shape {}z(Expected a 2-D array `y`, found shape {}r� r� r zInputs contain infinitiesTzZShape mismatch, x and y must have shape [n, p] and [n, q] or have shape [n, p] and [m, p].r� z;MGC requires at least 5 samples to give reasonable results.z$Compute_distance must be a function.z1Number of reps must be an integer greater than 0.r� z�The number of replications is low (under 1000), and p-value calculations may be unreliable. Use the p-value result, with caution!z*Cannot run if inputs are distance matrices� stat_mgc_map� opt_scale)rG rH rE )�mgc_maprS rK )r� rk r� r� rm �newaxisr1 rz r r� r r rB rE r� r� r� rH �_two_sample_transformr: rL rO rF )r� r� �compute_distancerG rH �
is_twosamprE �nx�px�ny�pyr� rF � stat_dictrR rS r� rK rP r s rr rS rS � s@ � �N �a��� $� $� 5�J�q�"�*�,E�,E� 5��3�4�4�4� �v��{�{�
�a�a�a���m� ���
��1���� � $�f�Q�W�o�o�/� /� /��v��{�{�
�a�a�a���m� ���
��1���� � $�f�Q�W�o�o�/� /� /� �W�F�B��
�W�F�B�� �!��(�(�(�(��!��(�(�(�(�
�v�b�h�q�k�k���Q� � �"�&���!���"5�"5��"9�"9��4�5�5�5� �R�x�x�
��8�8� �J�J� � K� L� L�
L�
�A�v�v��a���� $� %� %� %�
����� � �A� ����� � �A� �$� %� %� A�*:�*F��?�@�@�@� �d�C� � � +�D�1�H�H��L�M�M�M�
������ �
�c�>�*�*�*�� +� � #� � I�J�J� J�$�Q��*�*���1��#� � �Q� � �� � �Q� � �� ��1�o�o�O�D�)� �^�,�L��+�&�I� #�1�a��D�'�0<�>� >� >��F�I� (� &� &�(� (�H�
�D�&�(�
+�
+�C��C�H� �Jrt c � � t | |d�� � }|j \ }}|dk s|dk r||dz
|dz
}||z }n5t | � � dz
}t ||� � }t ||� � \ }}||d�} || fS )a� Helper function that calculates the MGC stat. See above for use.
Parameters
----------
distx, disty : ndarray
`distx` and `disty` have shapes `(n, p)` and `(n, q)` or
`(n, n)` and `(n, n)`
if distance matrices.
Returns
-------
stat : float
The sample MGC test statistic within `[-1, 1]`.
stat_dict : dict
Contains additional useful additional returns containing the following
keys:
- stat_mgc_map : ndarray
MGC-map of the statistics.
- opt_scale : (float, float)
The estimated optimal scale as a `(x, y)` pair.
�mgc)� global_corrr )rR rS )r rz r� �_threshold_mgc_map�_smooth_mgc_map)
�distx�distyrR r� rt rF rS � samp_size� sig_connectr] s
rr r: r: � s� � �2 '�u�e��G�G�G�L� � �D�A�q��A�v�v��a��� �A��E�"�1�q�5�)����E� � ���J�J��N� � )� �y�A�A� � *�+�|�D�D���i�!-� '�)� )�I� ��?�rt c �� � | j \ }}dd|z z
}||dz
z dz dz
}t j � |||� � dz dz
}t || |dz
|dz
� � }| |k }t j |� � dk rVt j |� � \ }}t j |d� � � \ }}t j
|dd
� � � dz } || k }nt j d gg� � }|S ) ar
Finds a connected region of significance in the MGC-map by thresholding.
Parameters
----------
stat_mgc_map : ndarray
All local correlations within `[-1,1]`.
samp_size : int
The sample size of original data.
Returns
-------
sig_connect : ndarray
A binary matrix with 1's indicating the significant region.
r �{�G�z�?rW r< r� r� r Tr� NF) rz r r� �ppfr� rk r� r
�labelr� r� r )
rR re rt r� �per_sigr� rf r� � label_counts� max_labels
rr ra ra s � �" � �D�A�q�
�4�)�#�$�G��Y��]�+�A�-��3�I� �"�&�&�w� �9�E�E��I�A�M�I� �I�|�A��E� 2�1�q�5� 9�:�:�I� ��*�K� �v�k���Q� � �&�,�[�9�9�� �Q� �)�K�t�D�D�D���<� �I�l�1�2�2� .�/�/�!�3� �!�Y�.� � ��h���y�)�)� � �rt c �& � |j \ }}||dz
|dz
}||g}t j � | � � dk r�t j | � � t j dt
||� � z � � t ||� � z k r}t
|| � � }t j ||k | z � � }||k rG|}|\ }} ||z | z }
t j |
� � |z }t j |
� � |z } |dz | dz g}||fS )aL Finds the smoothed maximal within the significant region R.
If area of R is too small it returns the last local correlation. Otherwise,
returns the maximum within significant_connected_region.
Parameters
----------
sig_connect : ndarray
A binary matrix with 1's indicating the significant region.
stat_mgc_map : ndarray
All local correlations within `[-1, 1]`.
Returns
-------
stat : float
The sample MGC statistic within `[-1, 1]`.
opt_scale: (float, float)
The estimated optimal scale as an `(x, y)` pair.
r r rh ) rz rk r r} r� r� r� rr r\ ) rf rR rt r� rF rS �max_corr�max_corr_indexr� r� �
one_d_indicess rr rb rb 6 s � �* � �D�A�q� ��A�� �q�1�u� %�D��A��I� �y�~�~�k�"�"�a�'�'� �6�+� � �"�'�$��Q����*:�";�";�c�!�Q�i�i�"G� G� G��<� �4�5�5�H� �X�|�x�'?�;�&N� O� O�N��4� � � ��%���1� !�A��� �
��F�=�)�)�Q�.���F�=�)�)�A�-�� �q�S�!�A�#�J� � ��?�rt c � � | j d }|j d }t j | |gd�� � }t j t j |� � t j |� � gd�� � � dd� � }||fS )a� Helper function that concatenates x and y for two sample MGC stat.
See above for use.
Parameters
----------
u, v : ndarray
`u` and `v` have shapes `(n, p)` and `(m, p)`.
Returns
-------
x : ndarray
Concatenate `u` and `v` along the `axis = 0`. `x` thus has shape
`(2n, p)`.
y : ndarray
Label matrix for `x` where 0 refers to samples that comes from `u` and
1 refers to samples that come from `v`. `y` thus has shape `(2n, 1)`.
r r r� r )rz rk ry rD rC r� )�uru rY r[ r� r� s rr rV rV i st � �(
����B�
����B�
���1�v�A�&�&�&�A�
����� � �b�g�b�k�k�2��;�;�;�C�C�B��J�J�A� �a�4�Krt �TtestResultBaser� c �* � � e Zd ZdZ� fd�Zdd�Z� xZS )� TtestResultau
Result of a t-test.
See the documentation of the particular t-test function for more
information about the definition of the statistic and meaning of
the confidence interval.
Attributes
----------
statistic : float or array
The t-statistic of the sample.
pvalue : float or array
The p-value associated with the given alternative.
df : float or array
The number of degrees of freedom used in calculation of the
t-statistic; this is one less than the size of the sample
(``a.shape[axis]-1`` if there are no masked elements or omitted NaNs).
Methods
-------
confidence_interval
Computes a confidence interval around the population statistic
for the given confidence level.
The confidence interval is returned in a ``namedtuple`` with
fields `low` and `high`.
c �z �� t � � � |||�� � || _ || _ || _ d S )Nr� )r� r� r� �_standard_error� _estimate)r� r� r� r� r� �standard_error�estimater� s �rr r� zTtestResult.__init__� s= �� �
������F�r��2�2�2� '��� -�� �!����rt r� c � � t | j | j || j � � \ }}|| j z | j z }|| j z | j z }t
||�� � S )av
Parameters
----------
confidence_level : float
The confidence level for the calculation of the population mean
confidence interval. Default is 0.95.
Returns
-------
ci : namedtuple
The confidence interval is returned in a ``namedtuple`` with
fields `low` and `high`.
r� )�_t_confidence_intervalr� r� r� rx ry r� )r� r� rN rO s rr r� z TtestResult.confidence_interval� sd � � +�4�7�D�N�+;�T�=N�P� P� ��T��D�(�(�4�>�9���d�*�*�T�^�;��!�c��5�5�5�5rt r� r� r� s @rr rv rv � sV �� � � � � �� �8"� "� "� "� "�6� 6� 6� 6� 6� 6� 6� 6rt rv c � � t j |� � � � � }|j r|d n t j }t | |||||�� � S )Nr �r� r� rz r{ )rk rn rl r� r rv )r� r� r� r� rz r{ s rr �pack_TtestResultr� � s^ � � �-� �,�,�2�2�4�4�K�$/�$4�@�+�a�.�.�"�&�K� �y�&�R�[�&4�x� I� I� I� Irt c �N � | j | j | j | j | j | j fS r� )r� r� r� r� rx ry )r s rr �unpack_TtestResultr� � s( � � �M�3�:�s�v�s�/?� � �� � 0� 0rt r� r� )r� r� r� r� c �v � t | |� � \ } }| j | }|dz
}t j | |� � } t j ||�� � }n"# t
$ r}t d� � |�d}~ww xY w||z
} t
| |d�� � }
t j |
|z � � } t j dd�� � 5 t j | | � � } ddd� � n # 1 swxY w Y t || |� � \ } }
t j || j � � d }d d
dd �| }t | |
||| |� � � S )
a� Calculate the T-test for the mean of ONE group of scores.
This is a test for the null hypothesis that the expected value
(mean) of a sample of independent observations `a` is equal to the given
population mean, `popmean`.
Parameters
----------
a : array_like
Sample observation.
popmean : float or array_like
Expected value in null hypothesis. If array_like, then its length along
`axis` must equal 1, and it must otherwise be broadcastable with `a`.
axis : int or None, optional
Axis along which to compute test; default is 0. If None, compute over
the whole array `a`.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan.
The following options are available (default is 'propagate'):
* 'propagate': returns nan
* 'raise': throws an error
* 'omit': performs the calculations ignoring nan values
alternative : {'two-sided', 'less', 'greater'}, optional
Defines the alternative hypothesis.
The following options are available (default is 'two-sided'):
* 'two-sided': the mean of the underlying distribution of the sample
is different than the given population mean (`popmean`)
* 'less': the mean of the underlying distribution of the sample is
less than the given population mean (`popmean`)
* 'greater': the mean of the underlying distribution of the sample is
greater than the given population mean (`popmean`)
Returns
-------
result : `~scipy.stats._result_classes.TtestResult`
An object with the following attributes:
statistic : float or array
The t-statistic.
pvalue : float or array
The p-value associated with the given alternative.
df : float or array
The number of degrees of freedom used in calculation of the
t-statistic; this is one less than the size of the sample
(``a.shape[axis]``).
.. versionadded:: 1.10.0
The object also has the following method:
confidence_interval(confidence_level=0.95)
Computes a confidence interval around the population
mean for the given confidence level.
The confidence interval is returned in a ``namedtuple`` with
fields `low` and `high`.
.. versionadded:: 1.10.0
Notes
-----
The statistic is calculated as ``(np.mean(a) - popmean)/se``, where
``se`` is the standard error. Therefore, the statistic will be positive
when the sample mean is greater than the population mean and negative when
the sample mean is less than the population mean.
Examples
--------
Suppose we wish to test the null hypothesis that the mean of a population
is equal to 0.5. We choose a confidence level of 99%; that is, we will
reject the null hypothesis in favor of the alternative if the p-value is
less than 0.01.
When testing random variates from the standard uniform distribution, which
has a mean of 0.5, we expect the data to be consistent with the null
hypothesis most of the time.
>>> import numpy as np
>>> from scipy import stats
>>> rng = np.random.default_rng()
>>> rvs = stats.uniform.rvs(size=50, random_state=rng)
>>> stats.ttest_1samp(rvs, popmean=0.5)
TtestResult(statistic=2.456308468440, pvalue=0.017628209047638, df=49)
As expected, the p-value of 0.017 is not below our threshold of 0.01, so
we cannot reject the null hypothesis.
When testing data from the standard *normal* distribution, which has a mean
of 0, we would expect the null hypothesis to be rejected.
>>> rvs = stats.norm.rvs(size=50, random_state=rng)
>>> stats.ttest_1samp(rvs, popmean=0.5)
TtestResult(statistic=-7.433605518875, pvalue=1.416760157221e-09, df=49)
Indeed, the p-value is lower than our threshold of 0.01, so we reject the
null hypothesis in favor of the default "two-sided" alternative: the mean
of the population is *not* equal to 0.5.
However, suppose we were to test the null hypothesis against the
one-sided alternative that the mean of the population is *greater* than
0.5. Since the mean of the standard normal is less than 0.5, we would not
expect the null hypothesis to be rejected.
>>> stats.ttest_1samp(rvs, popmean=0.5, alternative='greater')
TtestResult(statistic=-7.433605518875, pvalue=0.99999999929, df=49)
Unsurprisingly, with a p-value greater than our threshold, we would not
reject the null hypothesis.
Note that when working with a confidence level of 99%, a true null
hypothesis will be rejected approximately 1% of the time.
>>> rvs = stats.uniform.rvs(size=(100, 50), random_state=rng)
>>> res = stats.ttest_1samp(rvs, popmean=0.5, axis=1)
>>> np.sum(res.pvalue < 0.01)
1
Indeed, even though all 100 samples above were drawn from the standard
uniform distribution, which *does* have a population mean of 0.5, we would
mistakenly reject the null hypothesis for one of them.
`ttest_1samp` can also compute a confidence interval around the population
mean.
>>> rvs = stats.norm.rvs(size=50, random_state=rng)
>>> res = stats.ttest_1samp(rvs, popmean=0)
>>> ci = res.confidence_interval(confidence_level=0.95)
>>> ci
ConfidenceInterval(low=-0.3193887540880017, high=0.2898583388980972)
The bounds of the 95% confidence interval are the
minimum and maximum values of the parameter `popmean` for which the
p-value of the test would be 0.05.
>>> res = stats.ttest_1samp(rvs, popmean=ci.low)
>>> np.testing.assert_allclose(res.pvalue, 0.05)
>>> res = stats.ttest_1samp(rvs, popmean=ci.high)
>>> np.testing.assert_allclose(res.pvalue, 0.05)
Under certain assumptions about the population from which a sample
is drawn, the confidence interval with confidence level 95% is expected
to contain the true population mean in 95% of sample replications.
>>> rvs = stats.norm.rvs(size=(50, 1000), loc=1, random_state=rng)
>>> res = stats.ttest_1samp(rvs, popmean=0)
>>> ci = res.confidence_interval()
>>> contains_pop_mean = (ci.low < 1) & (ci.high > 1)
>>> contains_pop_mean.sum()
953
r r z#`popmean.shape[axis]` must equal 1.Nr! r� r9 r� r� r �ry r{ rz r )
rs rz rk r� r[ r� rQ r r� r� r� r rv )ro �popmeanrp r� r� r� r� r� r� r� ru r� r r� �alternative_nums rr rT rT � s� � �z �1�d�#�#�G�A�t� ���
�A�
�Q��B�
�7�1�d� � �D�G��*�W�4�0�0�0���� � G� G� G��>�?�?�Q�F�����G���� �w��A� �Q��1� � � �A� �G�A��E�N�N�E� ��H�h� 7� 7� 7� � � �I�a�� � �� � � � � � � � � � � ���� � � � ��B��;�/�/�G�A�t�
� ��Q�W� %� %�b� )�B� !��a�@�@��M�O� �q�$�2�?�&+�d� <� <� <� <s) �A �
A2� A-�-A2�9C�C �"C c �l � |dk s|dk rd}t |� � �|dk r9|}t j t j t j | |� � � � \ }}n�|dk r;d|z
}t j t j | |� � t j � � \ }}n�|dk r\d|z
dz }|d|z
f}t j |dgdgt j | � � j z z � � }t j | |� � \ }}n&t j |t j � � \ }} | | }}|d |d fS )Nr r z4`confidence_level` must be a number between 0 and 1.r� r� )
r� rk �broadcast_arraysr� r~ �stdtritr� r rm r )
r� r r� r� r� r� rN rO �tail_probability�nanss
rr r} r} � s> � � �!��� /�!� 3� 3�H����!�!�!��Q��� ���'����� ��Q�1G�1G�H�H� ��T�T� �q� � �
� � ���'����A�(>�(>���G�G� ��T�T� �� � � � 0� 0�!�3�� �a� 0� 0� 0�� �J�q�1�#���B�J�r�N�N�$7� 7�7� 8� 8���O�B��*�*� ��T�T��%�a���0�0���4��$�T�� �r�7�D��H� � rt c �J � |dk rt j | |� � }n^|dk rt j | | � � }nA|dk r,t j | t j |� � � � dz }nt d� � �|j dk r|d }|j dk r|d }||fS )z+Common code between all 3 t-test functions.ry rz r{ r� r| r r� )r~ �stdtrrk r> r� rm )r� r r� �pvals rr r� r� � s� � � �f� � ��}�R��#�#��� � � !� !��}�R�!��$�$��� � � #� #��}�R�"�&��)�)��,�,�Q�.���� <� =� =� =� �v��{�{�
�b�E�� �y�A�~�~��B�x�� �d�7�Nrt c �� � | |z
}t j dd�� � 5 t j ||� � }d d d � � n # 1 swxY w Y t |||� � \ }}||fS )Nr� r9 )rk r� r� r� )�mean1�mean2r� r� r� r� r r� s rr �_ttest_ind_from_statsr� � s� � �
��
�A� ��H�h� 7� 7� 7� � � �I�a�� � �� � � � � � � � � � � ���� � � � ��B��;�/�/�G�A�t�
�t�9�s �>�A�Ac �8 � | |z }||z }t j dd�� � 5 ||z dz |dz |dz
z |dz |dz
z z z }d d d � � n # 1 swxY w Y t j t j |� � d|� � }t j ||z � � }||fS )Nr� r9 r� r )rk r� r\ r� r )�v1r� �v2r� �vn1�vn2r� r� s rr �_unequal_var_ttest_denomr� � s� � �
�r�'�C�
�r�'�C� ��H�h� 7� 7� 7� F� F��C�i�!�^�s�A�v��a�� 0�3��6�R�!�V�3D� D�
E��F� F� F� F� F� F� F� F� F� F� F���� F� F� F� F�
��"�(�2�,�,��2� &� &�B� �G�C�#�I� � �E�
�u�9�s �!A�A�Ac � � ||z dz
}|dz
| z |dz
|z z |z }t j |d|z d|z z z � � }||fS )NrZ r r� )rk r )r� r� r� r� r� �svarr� s rr �_equal_var_ttest_denomr� � sY � � �b��3� �B�
�!�V�r�M�R�!�V�r�M� )�R� /�D� �G�D�C�"�H�s�R�x� /�0� 1� 1�E�
�u�9�rt �Ttest_indResultc �L � t j | � � } t j |� � }t j |� � }t j |� � }|r t |dz ||dz |� � \ }} nt |dz ||dz |� � \ }} t | || ||� � }
t |
� S )a"
T-test for means of two independent samples from descriptive statistics.
This is a test for the null hypothesis that two independent
samples have identical average (expected) values.
Parameters
----------
mean1 : array_like
The mean(s) of sample 1.
std1 : array_like
The corrected sample standard deviation of sample 1 (i.e. ``ddof=1``).
nobs1 : array_like
The number(s) of observations of sample 1.
mean2 : array_like
The mean(s) of sample 2.
std2 : array_like
The corrected sample standard deviation of sample 2 (i.e. ``ddof=1``).
nobs2 : array_like
The number(s) of observations of sample 2.
equal_var : bool, optional
If True (default), perform a standard independent 2 sample test
that assumes equal population variances [1]_.
If False, perform Welch's t-test, which does not assume equal
population variance [2]_.
alternative : {'two-sided', 'less', 'greater'}, optional
Defines the alternative hypothesis.
The following options are available (default is 'two-sided'):
* 'two-sided': the means of the distributions are unequal.
* 'less': the mean of the first distribution is less than the
mean of the second distribution.
* 'greater': the mean of the first distribution is greater than the
mean of the second distribution.
.. versionadded:: 1.6.0
Returns
-------
statistic : float or array
The calculated t-statistics.
pvalue : float or array
The two-tailed p-value.
See Also
--------
scipy.stats.ttest_ind
Notes
-----
The statistic is calculated as ``(mean1 - mean2)/se``, where ``se`` is the
standard error. Therefore, the statistic will be positive when `mean1` is
greater than `mean2` and negative when `mean1` is less than `mean2`.
References
----------
.. [1] https://en.wikipedia.org/wiki/T-test#Independent_two-sample_t-test
.. [2] https://en.wikipedia.org/wiki/Welch%27s_t-test
Examples
--------
Suppose we have the summary data for two samples, as follows (with the
Sample Variance being the corrected sample variance)::
Sample Sample
Size Mean Variance
Sample 1 13 15.0 87.5
Sample 2 11 12.0 39.0
Apply the t-test to this data (with the assumption that the population
variances are equal):
>>> import numpy as np
>>> from scipy.stats import ttest_ind_from_stats
>>> ttest_ind_from_stats(mean1=15.0, std1=np.sqrt(87.5), nobs1=13,
... mean2=12.0, std2=np.sqrt(39.0), nobs2=11)
Ttest_indResult(statistic=0.9051358093310269, pvalue=0.3751996797581487)
For comparison, here is the data from which those summary statistics
were taken. With this data, we can compute the same result using
`scipy.stats.ttest_ind`:
>>> a = np.array([1, 3, 4, 6, 11, 13, 15, 19, 22, 24, 25, 26, 26])
>>> b = np.array([2, 4, 6, 9, 11, 13, 14, 15, 18, 19, 21])
>>> from scipy.stats import ttest_ind
>>> ttest_ind(a, b)
Ttest_indResult(statistic=0.905135809331027, pvalue=0.3751996797581486)
Suppose we instead have binary data and would like to apply a t-test to
compare the proportion of 1s in two independent groups::
Number of Sample Sample
Size ones Mean Variance
Sample 1 150 30 0.2 0.161073
Sample 2 200 45 0.225 0.175251
The sample mean :math:`\hat{p}` is the proportion of ones in the sample
and the variance for a binary observation is estimated by
:math:`\hat{p}(1-\hat{p})`.
>>> ttest_ind_from_stats(mean1=0.2, std1=np.sqrt(0.161073), nobs1=150,
... mean2=0.225, std2=np.sqrt(0.175251), nobs2=200)
Ttest_indResult(statistic=-0.5627187905196761, pvalue=0.5739887114209541)
For comparison, we could compute the t statistic and p-value using
arrays of 0s and 1s and `scipy.stat.ttest_ind`, as above.
>>> group1 = np.array([1]*30 + [0]*(150-30))
>>> group2 = np.array([1]*45 + [0]*(200-45))
>>> ttest_ind(group1, group2)
Ttest_indResult(statistic=-0.5627179589855622, pvalue=0.573989277115258)
r� )rk r r� r� r� r� ) r� �std1�nobs1r� �std2�nobs2� equal_varr� r� r� r s rr rV rV � s� � �h
�J�u� � �E�
�:�d� � �D� �J�u� � �E�
�:�d� � �D�� =�*�4��7�E�4��7�E�J�J� ��E�E�,�T�1�W�e�-1�1�W�e�=� =� ��E� ��u�e�R��
E�
E�C� �C� � rt c � � t | ||� � }t |� � dk rt j }t j }n4t j |t j �� � }|� � � } |||� � S )a�
Generate an array of `nan`, with shape determined by `a`, `b` and `axis`.
This function is used by ttest_ind and ttest_rel to create the return
value when one of the inputs has size 0.
The shapes of the arrays are determined by dropping `axis` from the
shapes of `a` and `b` and broadcasting what is left.
The return value is a named tuple of the type given in `namedtuple_type`.
Examples
--------
>>> import numpy as np
>>> a = np.zeros((9, 2))
>>> b = np.zeros((5, 1))
>>> _ttest_nans(a, b, 0, Ttest_indResult)
Ttest_indResult(statistic=array([nan, nan]), pvalue=array([nan, nan]))
>>> a = np.zeros((3, 0, 9))
>>> b = np.zeros((1, 10))
>>> stat, p = _ttest_nans(a, b, -1, Ttest_indResult)
>>> stat
array([], shape=(3, 0), dtype=float64)
>>> p
array([], shape=(3, 0), dtype=float64)
>>> a = np.zeros(10)
>>> b = np.zeros(7)
>>> _ttest_nans(a, b, 0, Ttest_indResult)
Ttest_indResult(statistic=nan, pvalue=nan)
r r )r� r� rk r r� r� )ro rv rp �namedtuple_typer~ r r� s rr � _ttest_nansr� b sj � �D .�a��D�
9�
9�C�
�3�x�x�1�}�}� �F�� �F��� �G�C�B�F� +� +� +��
�F�F�H�H�� �?�1�a� � � rt c
� � d|cxk rdk sn t d� � �t | ||� � \ } }}t | |� � \ } }
t ||� � \ } } | p| }
|
dk s| dk rd}|
r]|dk rW|s|dk rt d� � �t j | � � } t j |� � }t j | ||||� � S | j dk s |j dk rt | ||t � � S |�o|dk ri|dk rt d� � �|dk s't j |� � r"t |� � |k rt d� � �t | |||||||� � � }n�| j | }|j | }|dk rOt | |d
� � � }t ||d
� � � }t j | |� � }t j ||� � }n*t# | ||� � \ }}}t# |||� � \ }}}|rt% ||||� � \ }}nt' ||||� � \ }}t) |||||� � }t |� S ) a�'
Calculate the T-test for the means of *two independent* samples of scores.
This is a test for the null hypothesis that 2 independent samples
have identical average (expected) values. This test assumes that the
populations have identical variances by default.
Parameters
----------
a, b : array_like
The arrays must have the same shape, except in the dimension
corresponding to `axis` (the first, by default).
axis : int or None, optional
Axis along which to compute test. If None, compute over the whole
arrays, `a`, and `b`.
equal_var : bool, optional
If True (default), perform a standard independent 2 sample test
that assumes equal population variances [1]_.
If False, perform Welch's t-test, which does not assume equal
population variance [2]_.
.. versionadded:: 0.11.0
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan.
The following options are available (default is 'propagate'):
* 'propagate': returns nan
* 'raise': throws an error
* 'omit': performs the calculations ignoring nan values
The 'omit' option is not currently available for permutation tests or
one-sided asympyotic tests.
permutations : non-negative int, np.inf, or None (default), optional
If 0 or None (default), use the t-distribution to calculate p-values.
Otherwise, `permutations` is the number of random permutations that
will be used to estimate p-values using a permutation test. If
`permutations` equals or exceeds the number of distinct partitions of
the pooled data, an exact test is performed instead (i.e. each
distinct partition is used exactly once). See Notes for details.
.. versionadded:: 1.7.0
random_state : {None, int, `numpy.random.Generator`,
`numpy.random.RandomState`}, optional
If `seed` is None (or `np.random`), the `numpy.random.RandomState`
singleton is used.
If `seed` is an int, a new ``RandomState`` instance is used,
seeded with `seed`.
If `seed` is already a ``Generator`` or ``RandomState`` instance then
that instance is used.
Pseudorandom number generator state used to generate permutations
(used only when `permutations` is not None).
.. versionadded:: 1.7.0
alternative : {'two-sided', 'less', 'greater'}, optional
Defines the alternative hypothesis.
The following options are available (default is 'two-sided'):
* 'two-sided': the means of the distributions underlying the samples
are unequal.
* 'less': the mean of the distribution underlying the first sample
is less than the mean of the distribution underlying the second
sample.
* 'greater': the mean of the distribution underlying the first
sample is greater than the mean of the distribution underlying
the second sample.
.. versionadded:: 1.6.0
trim : float, optional
If nonzero, performs a trimmed (Yuen's) t-test.
Defines the fraction of elements to be trimmed from each end of the
input samples. If 0 (default), no elements will be trimmed from either
side. The number of trimmed elements from each tail is the floor of the
trim times the number of elements. Valid range is [0, .5).
.. versionadded:: 1.7
Returns
-------
statistic : float or array
The calculated t-statistic.
pvalue : float or array
The p-value.
Notes
-----
Suppose we observe two independent samples, e.g. flower petal lengths, and
we are considering whether the two samples were drawn from the same
population (e.g. the same species of flower or two species with similar
petal characteristics) or two different populations.
The t-test quantifies the difference between the arithmetic means
of the two samples. The p-value quantifies the probability of observing
as or more extreme values assuming the null hypothesis, that the
samples are drawn from populations with the same population means, is true.
A p-value larger than a chosen threshold (e.g. 5% or 1%) indicates that
our observation is not so unlikely to have occurred by chance. Therefore,
we do not reject the null hypothesis of equal population means.
If the p-value is smaller than our threshold, then we have evidence
against the null hypothesis of equal population means.
By default, the p-value is determined by comparing the t-statistic of the
observed data against a theoretical t-distribution.
When ``1 < permutations < binom(n, k)``, where
* ``k`` is the number of observations in `a`,
* ``n`` is the total number of observations in `a` and `b`, and
* ``binom(n, k)`` is the binomial coefficient (``n`` choose ``k``),
the data are pooled (concatenated), randomly assigned to either group `a`
or `b`, and the t-statistic is calculated. This process is performed
repeatedly (`permutation` times), generating a distribution of the
t-statistic under the null hypothesis, and the t-statistic of the observed
data is compared to this distribution to determine the p-value.
Specifically, the p-value reported is the "achieved significance level"
(ASL) as defined in 4.4 of [3]_. Note that there are other ways of
estimating p-values using randomized permutation tests; for other
options, see the more general `permutation_test`.
When ``permutations >= binom(n, k)``, an exact test is performed: the data
are partitioned between the groups in each distinct way exactly once.
The permutation test can be computationally expensive and not necessarily
more accurate than the analytical test, but it does not make strong
assumptions about the shape of the underlying distribution.
Use of trimming is commonly referred to as the trimmed t-test. At times
called Yuen's t-test, this is an extension of Welch's t-test, with the
difference being the use of winsorized means in calculation of the variance
and the trimmed sample size in calculation of the statistic. Trimming is
recommended if the underlying distribution is long-tailed or contaminated
with outliers [4]_.
The statistic is calculated as ``(np.mean(a) - np.mean(b))/se``, where
``se`` is the standard error. Therefore, the statistic will be positive
when the sample mean of `a` is greater than the sample mean of `b` and
negative when the sample mean of `a` is less than the sample mean of
`b`.
References
----------
.. [1] https://en.wikipedia.org/wiki/T-test#Independent_two-sample_t-test
.. [2] https://en.wikipedia.org/wiki/Welch%27s_t-test
.. [3] B. Efron and T. Hastie. Computer Age Statistical Inference. (2016).
.. [4] Yuen, Karen K. "The Two-Sample Trimmed t for Unequal Population
Variances." Biometrika, vol. 61, no. 1, 1974, pp. 165-170. JSTOR,
www.jstor.org/stable/2334299. Accessed 30 Mar. 2021.
.. [5] Yuen, Karen K., and W. J. Dixon. "The Approximate Behaviour and
Performance of the Two-Sample Trimmed t." Biometrika, vol. 60,
no. 2, 1973, pp. 369-374. JSTOR, www.jstor.org/stable/2334550.
Accessed 30 Mar. 2021.
Examples
--------
>>> import numpy as np
>>> from scipy import stats
>>> rng = np.random.default_rng()
Test with sample with identical means:
>>> rvs1 = stats.norm.rvs(loc=5, scale=10, size=500, random_state=rng)
>>> rvs2 = stats.norm.rvs(loc=5, scale=10, size=500, random_state=rng)
>>> stats.ttest_ind(rvs1, rvs2)
Ttest_indResult(statistic=-0.4390847099199348, pvalue=0.6606952038870015)
>>> stats.ttest_ind(rvs1, rvs2, equal_var=False)
Ttest_indResult(statistic=-0.4390847099199348, pvalue=0.6606952553131064)
`ttest_ind` underestimates p for unequal variances:
>>> rvs3 = stats.norm.rvs(loc=5, scale=20, size=500, random_state=rng)
>>> stats.ttest_ind(rvs1, rvs3)
Ttest_indResult(statistic=-1.6370984482905417, pvalue=0.1019251574705033)
>>> stats.ttest_ind(rvs1, rvs3, equal_var=False)
Ttest_indResult(statistic=-1.637098448290542, pvalue=0.10202110497954867)
When ``n1 != n2``, the equal variance t-statistic is no longer equal to the
unequal variance t-statistic:
>>> rvs4 = stats.norm.rvs(loc=5, scale=20, size=100, random_state=rng)
>>> stats.ttest_ind(rvs1, rvs4)
Ttest_indResult(statistic=-1.9481646859513422, pvalue=0.05186270935842703)
>>> stats.ttest_ind(rvs1, rvs4, equal_var=False)
Ttest_indResult(statistic=-1.3146566100751664, pvalue=0.1913495266513811)
T-test with different means, variance, and n:
>>> rvs5 = stats.norm.rvs(loc=8, scale=20, size=100, random_state=rng)
>>> stats.ttest_ind(rvs1, rvs5)
Ttest_indResult(statistic=-2.8415950600298774, pvalue=0.0046418707568707885)
>>> stats.ttest_ind(rvs1, rvs5, equal_var=False)
Ttest_indResult(statistic=-1.8686598649188084, pvalue=0.06434714193919686)
When performing a permutation test, more permutations typically yields
more accurate results. Use a ``np.random.Generator`` to ensure
reproducibility:
>>> stats.ttest_ind(rvs1, rvs5, permutations=10000,
... random_state=rng)
Ttest_indResult(statistic=-2.8415950600298774, pvalue=0.0052994700529947)
Take these two samples, one of which has an extreme tail.
>>> a = (56, 128.6, 12, 123.8, 64.34, 78, 763.3)
>>> b = (1.1, 2.9, 4.2)
Use the `trim` keyword to perform a trimmed (Yuen) t-test. For example,
using 20% trimming, ``trim=.2``, the test will reduce the impact of one
(``np.floor(trim*len(a))``) element from each tail of sample `a`. It will
have no effect on sample `b` because ``np.floor(trim*len(b))`` is 0.
>>> stats.ttest_ind(a, b, trim=.2)
Ttest_indResult(statistic=3.4463884028073513,
pvalue=0.01369338726499547)
r r� z/Trimming percentage should be 0 <= `trim` < .5.r� zvnan-containing/masked inputs with nan_policy='omit' are currently not supported by permutation tests or trimmed tests.Nz7Permutations are currently not supported with trimming.z,Permutations must be a non-negative integer.)� permutationsrp r� r� rE r� r r! )r� rw r r r� r� rU r� r� r� rk �isfiniter� �_permutation_ttestrz rQ r� �_ttest_trim_var_mean_lenr� r� r� )ro rv rp r� r� r� rE r� �trimr� r� �cnb�npbr� r r� r� r� r� �m1r` r� r� s rr rU rU � s� � �F
��N�N�N�N��N�N�N�N��J�K�K�K� �q�!�T�*�*�J�A�q�$� �Q�
�+�+�H�C�� �Q�
�+�+�H�C���:�#�L�
�f�}�}��v�
�
��
�� J�
�f�,�,� � /�4�1�9�9� � .� /� /�
/�
� �a� � �� � �a� � ���%�a��D�)�[�I�I�I��v��{�{�a�f��k�k��1�a���7�7�7�� �L�A�$5�$5� �1�9�9� � .� /� /�
/� �!� � �� �L� 9� 9� � #�L� 1� 1�\� A� A� � K�L�L� L� ��A�L�&*�i�,6�.:�-8� :� :� :��� �W�T�]��
�W�T�]�� �1�9�9��a��A�&�&�&�B��a��A�&�&�&�B����D�!�!�B����D�!�!�B�B�1�!�T�4�@�@�J�B��B�1�!�T�4�@�@�J�B��B� � A�.�r�2�r�2�>�>�I�B���0��R��R�@�@�I�B��#�B��E�2�{�C�C�� �C� � rt c �� � t j | |�� � } | j | }t ||z � � }t | ||� � }|d|z z }t | ||�� � }|||fS )zCVariance, mean, and length of winsorized input along specified axisr r� )rk r� rz r� � _calculate_winsorized_variancerK )ro r� rp r� �gru rt s rr r� r� � sw � �
���� � � �A�
���
�A� �A��H�
�
�A� '�q�!�T�2�2�A� ��Q��J�A� �!�T��%�%�%�A� �a��7�Nrt c �v � |dk rt | d|�� � S t j | |d� � }t j t j |� � d�� � }|d|gf |dd|�f< |d| dz
gf |d| d�f< t j t |d|z dz d�� � � � }t j ||< |S ) z;Calculates g-times winsorized variance along specified axisr r r r� r .Nr� )rQ rk r� rG r� r r )ro r� rp �a_win� nans_indices�var_wins rr r� r� � s� � � �A�v�v��A�A�D�)�)�)�)� �K��4�� $� $�E� �6�"�(�5�/�/��3�3�3�L� �3���8�_�E�#�r��r�'�N��C�1�"�q�&��M�*�E�#��r�s�s�(�O� �j��e�1�q�5�1�9�B�?�?�?�@�@�G�
�F�G�L�� �Nrt c �. �� � t �� � �| j d � t j � |� � }||k r �� fd�t |� � D � � }n |}d� t |� |z
� � D � � }g }t
|d�� � D ]r}t j |� � }| d|f } t j | dd� � } | dd |�f }
| d|d �f } |�
t |
| |� � � � �st j |d�
� � }|||fS ) z2Generation permutation distribution of t statisticr� c 3 �B �K � | ]}�� �� � V � �d S r� )r9 )r0 r1 rE r� s ��rr rD z._permutation_distribution_t.<locals>.<genexpr>� sE �� � � � 8� 8� � '�2�2�4�8�8� 8� 8� 8� 8� 8� 8rt c 3 �> K � | ]}t j |� � V � �d S r� )rk ry )r0 r� s rr rD z._permutation_distribution_t.<locals>.<genexpr>� sH � � � � I� I� � �.��+�+� I� I� I� I� I� Irt �2 )�batch.r= r Nr )
r rz r~ �combr� r r" rk r r� r� � _calc_t_statry )
r r� �size_ar� rE �n_max�perm_generator�t_stat�indices� data_permro rv r� s
` @rr �_permutation_distribution_tr� � sf ��� � &�l�3�3�L� �:�b�>�D� �L��v� &� &�E��e���8� 8� 8� 8� 8�#(� �#6�#6�8� 8� 8��� � �I� I�#2�6�4��;�#G�#G�I� I� I�� �F�#�N�"�=�=�=� 5� 5���(�7�#�#����g� �&� � �K� �2�q�1�1� � �c�7�F�7�l� #�� �c�6�7�7�l� #���
�
�l�1�a��3�3�4�4�4�4�
�^�F��
+�
+�
+�F� �<�� &�&rt c �L � | j | }|j | }t j | |�� � }t j ||�� � }t | |d�� � }t ||d�� � } |st ||| |� � d }
nt ||| |� � d }
||z
|
z S )z4Calculate the t statistic along the given dimension.r r rq )rz rk r� rQ r� r� ) ro rv r� rp �na�nb�avg_a�avg_b�var_a�var_br� s rr r� r� s� � �
��� �B�
��� �B� �G�A�D� !� !� !�E� �G�A�D� !� !� !�E� ���A� &� &� &�E� ���A� &� &� &�E� � @�(���E�2�>�>�q�A���&�u�b�%��<�<�Q�?�� �%�K�� � rt c � � t |� � }t | |||�� � }| j | } t | |f|�� � }
t j |
|d� � }
t
|
|| ||�� � \ } }} t j t j d� d�}
|
| | |� � }| |k rdnd}|� d�� � |z ||z z }|dk r~t j
|� � � � � rXt j |� � dk r t j
t j � � }n!t j |t j
|� � < ||fS ) a�
Calculates the T-test for the means of TWO INDEPENDENT samples of scores
using permutation methods.
This test is similar to `stats.ttest_ind`, except it doesn't rely on an
approximate normality assumption since it uses a permutation test.
This function is only called from ttest_ind when permutations is not None.
Parameters
----------
a, b : array_like
The arrays must be broadcastable, except along the dimension
corresponding to `axis` (the zeroth, by default).
axis : int, optional
The axis over which to operate on a and b.
permutations : int, optional
Number of permutations used to calculate p-value. If greater than or
equal to the number of distinct permutations, perform an exact test.
equal_var : bool, optional
If False, an equal variance (Welch's) t-test is conducted. Otherwise,
an ordinary t-test is conducted.
random_state : {None, int, `numpy.random.Generator`}, optional
If `seed` is None the `numpy.random.Generator` singleton is used.
If `seed` is an int, a new ``Generator`` instance is used,
seeded with `seed`.
If `seed` is already a ``Generator`` instance then that instance is
used.
Pseudorandom number generator state used for generating random
permutations.
Returns
-------
statistic : float or array
The calculated t-statistic.
pvalue : float or array
The p-value.
r r� )r� r� rE c �f � | t j |� � k | t j |� � k z S r� )rk r> r
s rr r� z$_permutation_ttest.<locals>.<lambda>V s% � �!���q� � �z�/�a�2�6�!�9�9�n�)M� rt )ry rz r{ r r r� )r r� rz r$ rk r� r� r �
greater_equalr� r� rG rm rB r )ro rv r� rp r� r� rE r� �t_stat_observedr� �matr� r� r �cmps�
adjustment�pvaluess rr r� r� sd � �R &�l�3�3�L�"�1�a���>�>�>�O�
��� �B�
�!�Q��d�
3�
3�
3�C�
�+�c�4��
$�
$�C�"=� �\�"� �!�##� ##� ##� �F�L�%� �}� �*� M� M�O� O�G�
�7�;� ��� 8� 8�D� �l�*�*����J��x�x�Q�x� � �*�,� �
�1J�K�G� �[� � �R�X�o�%>�%>�%B�%B�%D�%D� �
�7�7� � �q� � ��j���(�(�G�G�13��G�B�H�_�-�-� .� �W� %�%rt c �x � | j | }n*# t $ r t j || j |� � d �w xY w|S r� )rz r{ rk r| rm )ro rp r� r� s rr �_get_lenr� j sL � �8�
�G�D�M���� � 8� 8� 8��l�4����-�-�4�7�8���� �Hs �
�'7)r� r� r� r� r� c �h � t | ||� � \ } }}t | |d� � }t ||d� � }||k rt d� � �|dk s|dk rQt t j t j t j t j t j t j �� � S | j | }|dz
}| |z
� t j � � } t | |d�� � }
t j
| |� � } t j |
|z � � } t j dd� � � 5 t j
| | � � }
d
d
d
� � n # 1 swxY w Y t ||
|� � \ }
}t j ||
j � � d }d ddd
�| }t |
|||| | �� � S )a� Calculate the t-test on TWO RELATED samples of scores, a and b.
This is a test for the null hypothesis that two related or
repeated samples have identical average (expected) values.
Parameters
----------
a, b : array_like
The arrays must have the same shape.
axis : int or None, optional
Axis along which to compute test. If None, compute over the whole
arrays, `a`, and `b`.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan.
The following options are available (default is 'propagate'):
* 'propagate': returns nan
* 'raise': throws an error
* 'omit': performs the calculations ignoring nan values
alternative : {'two-sided', 'less', 'greater'}, optional
Defines the alternative hypothesis.
The following options are available (default is 'two-sided'):
* 'two-sided': the means of the distributions underlying the samples
are unequal.
* 'less': the mean of the distribution underlying the first sample
is less than the mean of the distribution underlying the second
sample.
* 'greater': the mean of the distribution underlying the first
sample is greater than the mean of the distribution underlying
the second sample.
.. versionadded:: 1.6.0
Returns
-------
result : `~scipy.stats._result_classes.TtestResult`
An object with the following attributes:
statistic : float or array
The t-statistic.
pvalue : float or array
The p-value associated with the given alternative.
df : float or array
The number of degrees of freedom used in calculation of the
t-statistic; this is one less than the size of the sample
(``a.shape[axis]``).
.. versionadded:: 1.10.0
The object also has the following method:
confidence_interval(confidence_level=0.95)
Computes a confidence interval around the difference in
population means for the given confidence level.
The confidence interval is returned in a ``namedtuple`` with
fields `low` and `high`.
.. versionadded:: 1.10.0
Notes
-----
Examples for use are scores of the same set of student in
different exams, or repeated sampling from the same units. The
test measures whether the average score differs significantly
across samples (e.g. exams). If we observe a large p-value, for
example greater than 0.05 or 0.1 then we cannot reject the null
hypothesis of identical average scores. If the p-value is smaller
than the threshold, e.g. 1%, 5% or 10%, then we reject the null
hypothesis of equal averages. Small p-values are associated with
large t-statistics.
The t-statistic is calculated as ``np.mean(a - b)/se``, where ``se`` is the
standard error. Therefore, the t-statistic will be positive when the sample
mean of ``a - b`` is greater than zero and negative when the sample mean of
``a - b`` is less than zero.
References
----------
https://en.wikipedia.org/wiki/T-test#Dependent_t-test_for_paired_samples
Examples
--------
>>> import numpy as np
>>> from scipy import stats
>>> rng = np.random.default_rng()
>>> rvs1 = stats.norm.rvs(loc=5, scale=10, size=500, random_state=rng)
>>> rvs2 = (stats.norm.rvs(loc=5, scale=10, size=500, random_state=rng)
... + stats.norm.rvs(scale=0.2, size=500, random_state=rng))
>>> stats.ttest_rel(rvs1, rvs2)
TtestResult(statistic=-0.4549717054410304, pvalue=0.6493274702088672, df=499) # noqa
>>> rvs3 = (stats.norm.rvs(loc=8, scale=10, size=500, random_state=rng)
... + stats.norm.rvs(scale=0.2, size=500, random_state=rng))
>>> stats.ttest_rel(rvs1, rvs3)
TtestResult(statistic=-5.879467544540889, pvalue=7.540777129099917e-09, df=499) # noqa
zfirst argumentzsecond argumentzunequal length arraysr r r r! r� r9 Nr� r� r� )rw r� r� rv rk r rz r rB rQ r� r r� r� r� r )ro rv rp r� r� r� r� r� r� r� ru �dmr� r r� r� s rr rW rW r s� � �L �q�!�T�*�*�J�A�q�$� �!�T�+� ,� ,�B� �!�T�,� -� -�B� �R�x�x��0�1�1�1� �Q�w�w�"��'�'��2�6�2�6�b�f�"�&�*,�&�2�6�C� C� C� C�
���
�A�
�Q��B�
�Q����r�z�"�"�A� �Q��1� � � �A� ���D� � �B� �G�A��E�N�N�E� ��H�h� 7� 7� 7� !� !� �I�b�%� � ��!� !� !� !� !� !� !� !� !� !� !���� !� !� !� !��B��;�/�/�G�A�t�
� ��Q�W� %� %�b� )�B� "��a�@�@��M�O� �q�$�2�?�&+�b� :� :� :� :s �2E�E�Eg �r= gUUUUUU�?)�pearsonzlog-likelihoodz
freeman-tukeyzmod-log-likelihood�neymanz cressie-readc �� � t | d� � rK| � |�� � }t |t j � � r|j dk rt
|� � }n|�| j }n
| j | }|S )z�Count the number of non-masked elements of an array.
This function behaves like `np.ma.count`, but is much faster
for ndarrays.
r� r r ) �hasattrr� r� rk r� rm r� r� rz )ro rp �nums rr �_countr� ss � � �q�'���
��g�g�4�g� � �� �c�2�:� &� &� �3�8�q�=�=� �c�(�(�C�� �<��&�C�C��'�$�-�C� �Jrt c � � t j � | � � rLt j � t j | |� � t j | j |� � �� � S t j | |d�� � S )N)�maskT)�subok)rk r �
isMaskedArray� masked_arrayr r� )ro rz s rr �_m_broadcast_tor� ss � � �u���1� � � G��u�!�!�"�/�!�U�";�";�')��q�v�u�'E�'E� "� G� G� G�
�?�1�e�4� 0� 0� 0�0rt �Power_divergenceResultc �� � t |t � � ru|t vr^t t t � � � � � � � dd� }t
d� ||� � � � �t | }n|�d}t j | � � } | �
t j � � }|��t j |� � }t |j
|j
� � }t ||� � }t ||� � }d}t j d�� � 5 |� |�� � } |� |�� � }
t j | |
z
� � t j | |
� � z } | |k � � � } ddd� � n # 1 swxY w Y | rd |� d
| � �}
t
|
� � �nDt j d�� � 5 | � |d � � � }ddd� � n # 1 swxY w Y |dk r ||z
d
z |z }n`|dk r dt+ j | | |z � � z }n>|dk r dt+ j ||| z � � z }n | | |z |z dz
z }|d|z |dz z z }|� |�� � }t/ ||�� � }t1 |� � }t2 j � ||dz
|z
� � }t9 ||� � S )a Cressie-Read power divergence statistic and goodness of fit test.
This function tests the null hypothesis that the categorical data
has the given frequencies, using the Cressie-Read power divergence
statistic.
Parameters
----------
f_obs : array_like
Observed frequencies in each category.
f_exp : array_like, optional
Expected frequencies in each category. By default the categories are
assumed to be equally likely.
ddof : int, optional
"Delta degrees of freedom": adjustment to the degrees of freedom
for the p-value. The p-value is computed using a chi-squared
distribution with ``k - 1 - ddof`` degrees of freedom, where `k`
is the number of observed frequencies. The default value of `ddof`
is 0.
axis : int or None, optional
The axis of the broadcast result of `f_obs` and `f_exp` along which to
apply the test. If axis is None, all values in `f_obs` are treated
as a single data set. Default is 0.
lambda_ : float or str, optional
The power in the Cressie-Read power divergence statistic. The default
is 1. For convenience, `lambda_` may be assigned one of the following
strings, in which case the corresponding numerical value is used:
* ``"pearson"`` (value 1)
Pearson's chi-squared statistic. In this case, the function is
equivalent to `chisquare`.
* ``"log-likelihood"`` (value 0)
Log-likelihood ratio. Also known as the G-test [3]_.
* ``"freeman-tukey"`` (value -1/2)
Freeman-Tukey statistic.
* ``"mod-log-likelihood"`` (value -1)
Modified log-likelihood ratio.
* ``"neyman"`` (value -2)
Neyman's statistic.
* ``"cressie-read"`` (value 2/3)
The power recommended in [5]_.
Returns
-------
statistic : float or ndarray
The Cressie-Read power divergence test statistic. The value is
a float if `axis` is None or if` `f_obs` and `f_exp` are 1-D.
pvalue : float or ndarray
The p-value of the test. The value is a float if `ddof` and the
return value `stat` are scalars.
See Also
--------
chisquare
Notes
-----
This test is invalid when the observed or expected frequencies in each
category are too small. A typical rule is that all of the observed
and expected frequencies should be at least 5.
Also, the sum of the observed and expected frequencies must be the same
for the test to be valid; `power_divergence` raises an error if the sums
do not agree within a relative tolerance of ``1e-8``.
When `lambda_` is less than zero, the formula for the statistic involves
dividing by `f_obs`, so a warning or error may be generated if any value
in `f_obs` is 0.
Similarly, a warning or error may be generated if any value in `f_exp` is
zero when `lambda_` >= 0.
The default degrees of freedom, k-1, are for the case when no parameters
of the distribution are estimated. If p parameters are estimated by
efficient maximum likelihood then the correct degrees of freedom are
k-1-p. If the parameters are estimated in a different way, then the
dof can be between k-1-p and k-1. However, it is also possible that
the asymptotic distribution is not a chisquare, in which case this
test is not appropriate.
This function handles masked arrays. If an element of `f_obs` or `f_exp`
is masked, then data at that position is ignored, and does not count
towards the size of the data set.
.. versionadded:: 0.13.0
References
----------
.. [1] Lowry, Richard. "Concepts and Applications of Inferential
Statistics". Chapter 8.
https://web.archive.org/web/20171015035606/http://faculty.vassar.edu/lowry/ch8pt1.html
.. [2] "Chi-squared test", https://en.wikipedia.org/wiki/Chi-squared_test
.. [3] "G-test", https://en.wikipedia.org/wiki/G-test
.. [4] Sokal, R. R. and Rohlf, F. J. "Biometry: the principles and
practice of statistics in biological research", New York: Freeman
(1981)
.. [5] Cressie, N. and Read, T. R. C., "Multinomial Goodness-of-Fit
Tests", J. Royal Stat. Soc. Series B, Vol. 46, No. 3 (1984),
pp. 440-464.
Examples
--------
(See `chisquare` for more examples.)
When just `f_obs` is given, it is assumed that the expected frequencies
are uniform and given by the mean of the observed frequencies. Here we
perform a G-test (i.e. use the log-likelihood ratio statistic):
>>> import numpy as np
>>> from scipy.stats import power_divergence
>>> power_divergence([16, 18, 16, 14, 12, 12], lambda_='log-likelihood')
(2.006573162632538, 0.84823476779463769)
The expected frequencies can be given with the `f_exp` argument:
>>> power_divergence([16, 18, 16, 14, 12, 12],
... f_exp=[16, 16, 16, 16, 16, 8],
... lambda_='log-likelihood')
(3.3281031458963746, 0.6495419288047497)
When `f_obs` is 2-D, by default the test is applied to each column.
>>> obs = np.array([[16, 18, 16, 14, 12, 12], [32, 24, 16, 28, 20, 24]]).T
>>> obs.shape
(6, 2)
>>> power_divergence(obs, lambda_="log-likelihood")
(array([ 2.00657316, 6.77634498]), array([ 0.84823477, 0.23781225]))
By setting ``axis=None``, the test is applied to all data in the array,
which is equivalent to applying the test to the flattened array.
>>> power_divergence(obs, axis=None)
(23.31034482758621, 0.015975692534127565)
>>> power_divergence(obs.ravel())
(23.31034482758621, 0.015975692534127565)
`ddof` is the change to make to the default degrees of freedom.
>>> power_divergence([16, 18, 16, 14, 12, 12], ddof=1)
(2.0, 0.73575888234288467)
The calculation of the p-values is done by broadcasting the
test statistic with `ddof`.
>>> power_divergence([16, 18, 16, 14, 12, 12], ddof=[0,1,2])
(2.0, array([ 0.84914504, 0.73575888, 0.5724067 ]))
`f_obs` and `f_exp` are also broadcast. In the following, `f_obs` has
shape (6,) and `f_exp` has shape (2, 6), so the result of broadcasting
`f_obs` and `f_exp` has shape (2, 6). To compute the desired chi-squared
statistics, we must use ``axis=1``:
>>> power_divergence([16, 18, 16, 14, 12, 12],
... f_exp=[[16, 16, 16, 16, 16, 8],
... [8, 20, 20, 16, 12, 12]],
... axis=1)
(array([ 3.5 , 9.25]), array([ 0.62338763, 0.09949846]))
r r� z8invalid string for lambda_: {0!r}. Valid strings are {1}Ng:�0�yE>r� r; r z�For each axis slice, the sum of the observed frequencies must agree with the sum of the expected frequencies to a relative tolerance of z#, but the percent differences are:
Tr� r� r rZ r� ) r� r" �_power_div_lambda_namesrF ry �keysr� r1 rk r� r rB r� rz r� r� r� r> r rG r� r~ �xlogyr� r r r� r r� )�f_obs�f_expr rp �lambda_�names� f_obs_float�bshape�rtol� f_obs_sum� f_exp_sum�
relative_diff� diff_gt_tolr� �termsrF �num_obsr� s rr r\ r\ # s� � �B �'�3� � � � �1� 1� 1��� 5� :� :� <� <�=�=�>�>�q��t�D�E� � 5�5;�V�G�U�5K�5K�M� M�
M�)�'�2��� � ��� �M�%� � �E��,�,�r�z�*�*�K� ���
�e�$�$��"�;�#4�e�k�B�B��%�k�6�:�:� � ��v�.�.����
�[��
*�
*�
*� 7� 7�#���T��2�2�I� � � �t� �,�,�I� �V�I� �$9� :� :� �Z� �9� =� =� >�M�(�4�/�4�4�6�6�K� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7���� 7� 7� 7� 7� � "�&� �&� &� $� &� &�C�
�S�/�/� !�
"� �[��
*�
*�
*� 9� 9��J�J�D�4�J�8�8�E� 9� 9� 9� 9� 9� 9� 9� 9� 9� 9� 9���� 9� 9� 9� 9� �!�|�|� �u�$�q�(�5�0��� �A� � ��g�m�E�5�5�=�9�9�9��� �B� � ��g�m�E�5�5�=�9�9�9��� �%�%�-�'�1�A�5�6��
��w� �'�A�+�.�.�� �9�9�$�9� � �D��U��&�&�&�G� �4�=�=�D��� � �d�G�a�K�$�$6�7�7�A� !�$�� *� *�*s% �*A2F(�(F,�/F,�"H�H
�
H
c �* � t | |||d�� � S )a4 Calculate a one-way chi-square test.
The chi-square test tests the null hypothesis that the categorical data
has the given frequencies.
Parameters
----------
f_obs : array_like
Observed frequencies in each category.
f_exp : array_like, optional
Expected frequencies in each category. By default the categories are
assumed to be equally likely.
ddof : int, optional
"Delta degrees of freedom": adjustment to the degrees of freedom
for the p-value. The p-value is computed using a chi-squared
distribution with ``k - 1 - ddof`` degrees of freedom, where `k`
is the number of observed frequencies. The default value of `ddof`
is 0.
axis : int or None, optional
The axis of the broadcast result of `f_obs` and `f_exp` along which to
apply the test. If axis is None, all values in `f_obs` are treated
as a single data set. Default is 0.
Returns
-------
chisq : float or ndarray
The chi-squared test statistic. The value is a float if `axis` is
None or `f_obs` and `f_exp` are 1-D.
p : float or ndarray
The p-value of the test. The value is a float if `ddof` and the
return value `chisq` are scalars.
See Also
--------
scipy.stats.power_divergence
scipy.stats.fisher_exact : Fisher exact test on a 2x2 contingency table.
scipy.stats.barnard_exact : An unconditional exact test. An alternative
to chi-squared test for small sample sizes.
Notes
-----
This test is invalid when the observed or expected frequencies in each
category are too small. A typical rule is that all of the observed
and expected frequencies should be at least 5. According to [3]_, the
total number of samples is recommended to be greater than 13,
otherwise exact tests (such as Barnard's Exact test) should be used
because they do not overreject.
Also, the sum of the observed and expected frequencies must be the same
for the test to be valid; `chisquare` raises an error if the sums do not
agree within a relative tolerance of ``1e-8``.
The default degrees of freedom, k-1, are for the case when no parameters
of the distribution are estimated. If p parameters are estimated by
efficient maximum likelihood then the correct degrees of freedom are
k-1-p. If the parameters are estimated in a different way, then the
dof can be between k-1-p and k-1. However, it is also possible that
the asymptotic distribution is not chi-square, in which case this test
is not appropriate.
References
----------
.. [1] Lowry, Richard. "Concepts and Applications of Inferential
Statistics". Chapter 8.
https://web.archive.org/web/20171022032306/http://vassarstats.net:80/textbook/ch8pt1.html
.. [2] "Chi-squared test", https://en.wikipedia.org/wiki/Chi-squared_test
.. [3] Pearson, Karl. "On the criterion that a given system of deviations from the probable
in the case of a correlated system of variables is such that it can be reasonably
supposed to have arisen from random sampling", Philosophical Magazine. Series 5. 50
(1900), pp. 157-175.
Examples
--------
When just `f_obs` is given, it is assumed that the expected frequencies
are uniform and given by the mean of the observed frequencies.
>>> import numpy as np
>>> from scipy.stats import chisquare
>>> chisquare([16, 18, 16, 14, 12, 12])
(2.0, 0.84914503608460956)
With `f_exp` the expected frequencies can be given.
>>> chisquare([16, 18, 16, 14, 12, 12], f_exp=[16, 16, 16, 16, 16, 8])
(3.5, 0.62338762774958223)
When `f_obs` is 2-D, by default the test is applied to each column.
>>> obs = np.array([[16, 18, 16, 14, 12, 12], [32, 24, 16, 28, 20, 24]]).T
>>> obs.shape
(6, 2)
>>> chisquare(obs)
(array([ 2. , 6.66666667]), array([ 0.84914504, 0.24663415]))
By setting ``axis=None``, the test is applied to all data in the array,
which is equivalent to applying the test to the flattened array.
>>> chisquare(obs, axis=None)
(23.31034482758621, 0.015975692534127565)
>>> chisquare(obs.ravel())
(23.31034482758621, 0.015975692534127565)
`ddof` is the change to make to the default degrees of freedom.
>>> chisquare([16, 18, 16, 14, 12, 12], ddof=1)
(2.0, 0.73575888234288467)
The calculation of the p-values is done by broadcasting the
chi-squared statistic with `ddof`.
>>> chisquare([16, 18, 16, 14, 12, 12], ddof=[0,1,2])
(2.0, array([ 0.84914504, 0.73575888, 0.5724067 ]))
`f_obs` and `f_exp` are also broadcast. In the following, `f_obs` has
shape (6,) and `f_exp` has shape (2, 6), so the result of broadcasting
`f_obs` and `f_exp` has shape (2, 6). To compute the desired chi-squared
statistics, we use ``axis=1``:
>>> chisquare([16, 18, 16, 14, 12, 12],
... f_exp=[[16, 16, 16, 16, 16, 8], [8, 20, 20, 16, 12, 12]],
... axis=1)
(array([ 3.5 , 9.25]), array([ 0.62338763, 0.09949846]))
r� )r� r rp r� )r\ )r� r� r rp s rr r[ r[ s' � �z �E��T��$-� /� /� /� /rt � KstestResult�statistic_location�statistic_signc � � t | � � }t j d|dz � � |z | z
}|� � � }|| }|| |fS )a� Computes D+ as used in the Kolmogorov-Smirnov test.
Parameters
----------
cdfvals : array_like
Sorted array of CDF values between 0 and 1
x: array_like
Sorted array of the stochastic variable itself
Returns
-------
res: Pair with the following elements:
- The maximum distance of the CDF values below Uniform(0, 1).
- The location at which the maximum is reached.
r� r �r� rk r0 r� )�cdfvalsr� r� �dplus�amax�loc_maxs rr �_compute_dplusr� � sS � �" �G� � �A�
�Y�s�A��E�
"�
"�Q�
&��
0�E� �<�<�>�>�D���g�G� �$�K�� !�!rt c � � t | � � }| t j d|� � |z z
}|� � � }|| }|| |fS )a� Computes D- as used in the Kolmogorov-Smirnov test.
Parameters
----------
cdfvals : array_like
Sorted array of CDF values between 0 and 1
x: array_like
Sorted array of the stochastic variable itself
Returns
-------
res: Pair with the following elements:
- Maximum distance of the CDF values above Uniform(0, 1)
- The location at which the maximum is reached.
r7 r� )r� r� r� �dminusr� r� s rr �_compute_dminusr � sO � � �G� � �A��� �#�q�)�)�!�+�+�F� �=�=�?�?�D���g�G� �4�L�'� "�"rt r- r. c �Z � |}dddd�� |� � � d |� � }|dvrt d|z � � �t j � | � � r| � � � } t | � � }t j | � � } || g|�R � }|dk rDt || � � \ }} t |t j �
||� � | d� � � S |dk rDt || � � \ }
} t |
t j �
|
|� � | d
� � � S t || � � \ }} t || � � \ }
} ||
k r|}
| } d}n|
}
| } d
}|d k rd }|d k r!t j �
|
|� � }n^|d
k r5t j �
|
t j |� � z � � }n#dt j �
|
|� � z }t j |dd� � }t |
|| |� � � S )a�
Performs the one-sample Kolmogorov-Smirnov test for goodness of fit.
This test compares the underlying distribution F(x) of a sample
against a given continuous distribution G(x). See Notes for a description
of the available null and alternative hypotheses.
Parameters
----------
x : array_like
a 1-D array of observations of iid random variables.
cdf : callable
callable used to calculate the cdf.
args : tuple, sequence, optional
Distribution parameters, used with `cdf`.
alternative : {'two-sided', 'less', 'greater'}, optional
Defines the null and alternative hypotheses. Default is 'two-sided'.
Please see explanations in the Notes below.
method : {'auto', 'exact', 'approx', 'asymp'}, optional
Defines the distribution used for calculating the p-value.
The following options are available (default is 'auto'):
* 'auto' : selects one of the other options.
* 'exact' : uses the exact distribution of test statistic.
* 'approx' : approximates the two-sided probability with twice
the one-sided probability
* 'asymp': uses asymptotic distribution of test statistic
Returns
-------
res: KstestResult
An object containing attributes:
statistic : float
KS test statistic, either D+, D-, or D (the maximum of the two)
pvalue : float
One-tailed or two-tailed p-value.
statistic_location : float
Value of `x` corresponding with the KS statistic; i.e., the
distance between the empirical distribution function and the
hypothesized cumulative distribution function is measured at this
observation.
statistic_sign : int
+1 if the KS statistic is the maximum positive difference between
the empirical distribution function and the hypothesized cumulative
distribution function (D+); -1 if the KS statistic is the maximum
negative difference (D-).
See Also
--------
ks_2samp, kstest
Notes
-----
There are three options for the null and corresponding alternative
hypothesis that can be selected using the `alternative` parameter.
- `two-sided`: The null hypothesis is that the two distributions are
identical, F(x)=G(x) for all x; the alternative is that they are not
identical.
- `less`: The null hypothesis is that F(x) >= G(x) for all x; the
alternative is that F(x) < G(x) for at least one x.
- `greater`: The null hypothesis is that F(x) <= G(x) for all x; the
alternative is that F(x) > G(x) for at least one x.
Note that the alternative hypotheses describe the *CDFs* of the
underlying distributions, not the observed values. For example,
suppose x1 ~ F and x2 ~ G. If F(x) > G(x) for all x, the values in
x1 tend to be less than those in x2.
Examples
--------
Suppose we wish to test the null hypothesis that a sample is distributed
according to the standard normal.
We choose a confidence level of 95%; that is, we will reject the null
hypothesis in favor of the alternative if the p-value is less than 0.05.
When testing uniformly distributed data, we would expect the
null hypothesis to be rejected.
>>> import numpy as np
>>> from scipy import stats
>>> rng = np.random.default_rng()
>>> stats.ks_1samp(stats.uniform.rvs(size=100, random_state=rng),
... stats.norm.cdf)
KstestResult(statistic=0.5001899973268688, pvalue=1.1616392184763533e-23)
Indeed, the p-value is lower than our threshold of 0.05, so we reject the
null hypothesis in favor of the default "two-sided" alternative: the data
are *not* distributed according to the standard normal.
When testing random variates from the standard normal distribution, we
expect the data to be consistent with the null hypothesis most of the time.
>>> x = stats.norm.rvs(size=100, random_state=rng)
>>> stats.ks_1samp(x, stats.norm.cdf)
KstestResult(statistic=0.05345882212970396, pvalue=0.9227159037744717)
As expected, the p-value of 0.92 is not below our threshold of 0.05, so
we cannot reject the null hypothesis.
Suppose, however, that the random variates are distributed according to
a normal distribution that is shifted toward greater values. In this case,
the cumulative density function (CDF) of the underlying distribution tends
to be *less* than the CDF of the standard normal. Therefore, we would
expect the null hypothesis to be rejected with ``alternative='less'``:
>>> x = stats.norm.rvs(size=100, loc=0.5, random_state=rng)
>>> stats.ks_1samp(x, stats.norm.cdf, alternative='less')
KstestResult(statistic=0.17482387821055168, pvalue=0.001913921057766743)
and indeed, with p-value smaller than our threshold, we reject the null
hypothesis in favor of the alternative.
r{ rz ry �r r� r� r �r{ rz ry �Unexpected alternative %sr �r� r� r� r r �asympr� )r% r� r� rk r � is_masked�
compressedr� r� r� r� r �ksoner r �kstwo� kstwobignr r� )r� r~ r) r� r. r- �Nr� �Dplus�
d_location�Dminus�dplus_location�dminus_location�D�d_signr� s rr rY rY � sY � �p �D�#�)�&�A�A�E�E������A� � �-� -�K��:�:�:��4�{�B�C�C�C� �u���q��� �
�L�L�N�N�� �A���A�
���
�
�A��c�!�m�d�m�m�m�G��i� � � *�7�A� 6� 6���z��E�=�#6�#9�#9�%��#C�#C�/9�+,�.� .� .� .� �f� � � ,�W�a� 8� 8���
��F�M�$7�$:�$:�6�1�$E�$E�/9�+-�/� /� /� /�
+�7�A� 6� 6��E�>� -�g�q� 9� 9��F�O� �v�~�~� ��#�
���� ��$�
��� �v�~�~��� �w��� �"�%�%�a��+�+���
�� � � �&�)�)�!�b�g�a�j�j�.�9�9��� �=�&�)�)�!�Q�/�/�/��
�7�4��A� � �D� ��4�+5�'-� /� /� /� /rt c �� � d}t t j | |z � � � � }|dk rDd}t |� � D ] }| ||z z
|z
|z | ||z z |z dz z }� |d|z
z }|dz }|dk �Dd|z S )a$
Compute the proportion of paths that pass outside the two diagonal lines.
Parameters
----------
n : integer
n > 0
h : integer
0 <= h <= n
Returns
-------
p : float
The proportion of paths that pass outside the lines x-y = +/-h.
r7 r r� r r� )r� rk r� r� )r� r� �Pr� �p1r� s rr � _compute_prob_outside_squarer g s� � �2 �A� �B�H�Q��U�O�O� � �A�
�q�&�&�
�� �q��� <� <�A��a�!�e�)�a�-�2�%��Q��U��Q� ��):�;�B�B� �#��'�N�� �Q��� �q�&�&�
�q�5�Lrt c � ��
�� | |k r|| }} | |z �
||z �|�
�z
�
z z }��
�fd�t |� � D � � }|dk rt j | |z |� � S t j |� � }d|d< t d|� � D ]r}t j || |z |� � }t |� � D ]=} t j || || z
|z | z
|| z
� � }
||
|| z z }�>|||< �sd} t |� � D ]9}t j | || z
||z
z ||z
� � }
|| |
z } | | z
} �:| S )ak Count the number of paths that pass outside the specified diagonal.
Parameters
----------
m : integer
m > 0
n : integer
n > 0
g : integer
g is greatest common divisor of m and n
h : integer
0 <= h <= lcm(m,n)
Returns
-------
p : float
The number of paths that go low.
The calculation may overflow - check for a finite answer.
Notes
-----
Count the integer lattice paths from (0, 0) to (m, n), which at some
point (x, y) along the path, satisfy:
m*y <= n*x - h*g
The paths make steps of size +1 in either positive x or positive y
directions.
We generally follow Hodges' treatment of Drion/Gnedenko/Korolyuk.
Hodges, J.L. Jr.,
"The Significance Probability of the Smirnov Two-Sample Test,"
Arkiv fiur Matematik, 3, No. 43 (1958), 469-86.
c �2 �� g | ]}��|z z �z d z
�z ��S r� r� )r0 r� r� �mg�ngs ���rr r2 z/_count_paths_outside_method.<locals>.<listcomp>� s/ �� � 6� 6� 6�a�1�r�A�v�:��?�1� �r�
!� 6� 6� 6rt r r )r� r~ �binomrk rD )rt r� r� r� �lxj�xj�Br� �Bjr1 �bin� num_paths�termr r s ` @@rr �_count_paths_outside_methodr& � s� ���� �T �1�u�u��!�1��
�a��B�
�a��B�
�r�!�t�b�j�.�C� 6� 6� 6� 6� 6� 6�5��:�:� 6� 6� 6�B� �a�x�x��}�Q��U�A�&�&�&�
���
�
�A� �A�a�D�
�1�c�]�]� � ��
�]�2�a�5�1�9�a�
(�
(���q��� � �A��-��1���1��
�� 1�A� 5�q��s�;�;�C� �#��!��*� �B�B���!����I�
�3�Z�Z� � ���m�Q�r�!�u�W��Q�� /��1��5�5����t�c�z���T�� � � �rt c �J � | |z |z }t t j ||z � � � � }|dz |z }|dk rd|dfS dt j }} t j dd�� � 5 |dk r*| |k rt | |� � }n�t
| |||� � }n�| |k r5t j |� � } t j | | z
| | z dz z � � }nyt j d�� � 5 t | |||� � }
d d d � � n # 1 swxY w Y t j | |z | � � } |
| k st j | � � rd}n|
| z }d d d � � n # 1 swxY w Y n# t t f$ r d}Y nw xY w|rd|t j fS d|cxk rd
k sn d||fS d||fS ) z�Attempts to compute the exact 2sample probability.
n1, n2 are the sample sizes
g is the gcd(n1, n2)
d is the computed max difference in ECDFs
Returns (success, d, probability)
r� r TFr� )r: �overr{ )r( Nr )r� rk r? r r� r r! r0 �prodr& r~ r r �FloatingPointError�
OverflowError) r� r� r� r� r� �lcmr� � saw_fp_errorr� �jranger$ r# s rr �_attempt_exact_2kssampr/ � sw � � ��7�b�.�C� �B�H�Q��W� � � � �A� �C��#�
�A��A�v�v��Q��|�� ���$�L� �
�[��w�
7�
7�
7� /� /��k�)�)���8�8�7��A�>�>�D�D�<�R��Q��J�J�D�D���8�8� �Y�q�\�\�F� �7�B��K�B��K�#�4E�#F�G�G�D�D���'�2�2�2� N� N�$?��B��1�$M�$M� �N� N� N� N� N� N� N� N� N� N� N���� N� N� N� N�!�-��R���4�4�C� �3���"�(�3�-�-��'+� � � (�3���) /� /� /� /� /� /� /� /� /� /� /���� /� /� /� /���,
�
� .� � � �� � � � ���� � ��a��� � �
��N�N�N�N��N�N�N�N��a��~� � ��D�=�s[ �E" �%BE�&D�9 E�D � E� D �
=E�
E" �E�E" � E� E" �"E8�7E8c � � |}|dvrt d|� �� � �dddd�� |� � � d |� � }|dvrt d |� �� � �d
}t j � | � � r| � � � } t j � |� � r|� � � }t j | � � } t j |� � }| j d }|j d }t ||� � dk rt d � � �t j
| |g� � }t j | |d �
� � |z } t j ||d �
� � |z }
| |
z
} t j | � � } t j
| � � }
|| }||
}t j | | dd� � }| |
}|dk s |dk r
||k r|}|}d}n|}|}d}t ||� � }||z }||z }t j }|dk rt# ||� � |k rdnd}nU|dk rO|t j t j � � j |z k r%d}t) j d|� d|� d�t, d�� � |dk r;t/ |||||� � \ }}}|s"d}t) j d|� d�t, d�� � |dk r�t1 t3 |� � t3 |� � gd�� � \ }}||z ||z z } |dk r3t4 j � |t j | � � � � }nct j | � � |z } d | d z z d | z |d |z z z t j ||z ||z z � � z d z z
} t j | � � }t j |dd� � }tA ||||� � � S ) a$
Performs the two-sample Kolmogorov-Smirnov test for goodness of fit.
This test compares the underlying continuous distributions F(x) and G(x)
of two independent samples. See Notes for a description of the available
null and alternative hypotheses.
Parameters
----------
data1, data2 : array_like, 1-Dimensional
Two arrays of sample observations assumed to be drawn from a continuous
distribution, sample sizes can be different.
alternative : {'two-sided', 'less', 'greater'}, optional
Defines the null and alternative hypotheses. Default is 'two-sided'.
Please see explanations in the Notes below.
method : {'auto', 'exact', 'asymp'}, optional
Defines the method used for calculating the p-value.
The following options are available (default is 'auto'):
* 'auto' : use 'exact' for small size arrays, 'asymp' for large
* 'exact' : use exact distribution of test statistic
* 'asymp' : use asymptotic distribution of test statistic
Returns
-------
res: KstestResult
An object containing attributes:
statistic : float
KS test statistic.
pvalue : float
One-tailed or two-tailed p-value.
statistic_location : float
Value from `data1` or `data2` corresponding with the KS statistic;
i.e., the distance between the empirical distribution functions is
measured at this observation.
statistic_sign : int
+1 if the empirical distribution function of `data1` exceeds
the empirical distribution function of `data2` at
`statistic_location`, otherwise -1.
See Also
--------
kstest, ks_1samp, epps_singleton_2samp, anderson_ksamp
Notes
-----
There are three options for the null and corresponding alternative
hypothesis that can be selected using the `alternative` parameter.
- `less`: The null hypothesis is that F(x) >= G(x) for all x; the
alternative is that F(x) < G(x) for at least one x. The statistic
is the magnitude of the minimum (most negative) difference between the
empirical distribution functions of the samples.
- `greater`: The null hypothesis is that F(x) <= G(x) for all x; the
alternative is that F(x) > G(x) for at least one x. The statistic
is the maximum (most positive) difference between the empirical
distribution functions of the samples.
- `two-sided`: The null hypothesis is that the two distributions are
identical, F(x)=G(x) for all x; the alternative is that they are not
identical. The statistic is the maximum absolute difference between the
empirical distribution functions of the samples.
Note that the alternative hypotheses describe the *CDFs* of the
underlying distributions, not the observed values of the data. For example,
suppose x1 ~ F and x2 ~ G. If F(x) > G(x) for all x, the values in
x1 tend to be less than those in x2.
If the KS statistic is large, then the p-value will be small, and this may
be taken as evidence against the null hypothesis in favor of the
alternative.
If ``method='exact'``, `ks_2samp` attempts to compute an exact p-value,
that is, the probability under the null hypothesis of obtaining a test
statistic value as extreme as the value computed from the data.
If ``method='asymp'``, the asymptotic Kolmogorov-Smirnov distribution is
used to compute an approximate p-value.
If ``method='auto'``, an exact p-value computation is attempted if both
sample sizes are less than 10000; otherwise, the asymptotic method is used.
In any case, if an exact p-value calculation is attempted and fails, a
warning will be emitted, and the asymptotic p-value will be returned.
The 'two-sided' 'exact' computation computes the complementary probability
and then subtracts from 1. As such, the minimum probability it can return
is about 1e-16. While the algorithm itself is exact, numerical
errors may accumulate for large sample sizes. It is most suited to
situations in which one of the sample sizes is only a few thousand.
We generally follow Hodges' treatment of Drion/Gnedenko/Korolyuk [1]_.
References
----------
.. [1] Hodges, J.L. Jr., "The Significance Probability of the Smirnov
Two-Sample Test," Arkiv fiur Matematik, 3, No. 43 (1958), 469-86.
Examples
--------
Suppose we wish to test the null hypothesis that two samples were drawn
from the same distribution.
We choose a confidence level of 95%; that is, we will reject the null
hypothesis in favor of the alternative if the p-value is less than 0.05.
If the first sample were drawn from a uniform distribution and the second
were drawn from the standard normal, we would expect the null hypothesis
to be rejected.
>>> import numpy as np
>>> from scipy import stats
>>> rng = np.random.default_rng()
>>> sample1 = stats.uniform.rvs(size=100, random_state=rng)
>>> sample2 = stats.norm.rvs(size=110, random_state=rng)
>>> stats.ks_2samp(sample1, sample2)
KstestResult(statistic=0.5454545454545454, pvalue=7.37417839555191e-15)
Indeed, the p-value is lower than our threshold of 0.05, so we reject the
null hypothesis in favor of the default "two-sided" alternative: the data
were *not* drawn from the same distribution.
When both samples are drawn from the same distribution, we expect the data
to be consistent with the null hypothesis most of the time.
>>> sample1 = stats.norm.rvs(size=105, random_state=rng)
>>> sample2 = stats.norm.rvs(size=95, random_state=rng)
>>> stats.ks_2samp(sample1, sample2)
KstestResult(statistic=0.10927318295739348, pvalue=0.5438289009927495)
As expected, the p-value of 0.54 is not below our threshold of 0.05, so
we cannot reject the null hypothesis.
Suppose, however, that the first sample were drawn from
a normal distribution shifted toward greater values. In this case,
the cumulative density function (CDF) of the underlying distribution tends
to be *less* than the CDF underlying the second sample. Therefore, we would
expect the null hypothesis to be rejected with ``alternative='less'``:
>>> sample1 = stats.norm.rvs(size=105, loc=0.5, random_state=rng)
>>> stats.ks_2samp(sample1, sample2, alternative='less')
KstestResult(statistic=0.4055137844611529, pvalue=3.5474563068855554e-08)
and indeed, with p-value smaller than our threshold, we reject the null
hypothesis in favor of the alternative.
)r r r zInvalid value for mode: r{ rz ry r r )r{ ry rz z Invalid value for alternative: i' z)Data passed to ks_2samp must not be emptyr� )�sider r� r r r z;Exact ks_2samp calculation not possible with samples sizes r� z. Switching to 'asymp'.rW r� z>ks_2samp: Exact calculation unsuccessful. Switching to method=rl T)�reverser= r� rh r )!r� r% r� rk r r r
r� rz rr ry � searchsorted�argminr� r� r r� r� �iinfor. r� r� rH r/ r4 r� r r r r? r r� r� ) �data1�data2r� r. r- �
MAX_AUTO_Nr� r� �data_all�cdf1�cdf2�cddiffs�argminS�argmaxS�loc_minS�loc_maxS�minS�maxSr� r r r� �n1g�n2gr� �successrt r� �enr� �expts rr rZ rZ sD � �f �D� �-�-�-��:�D�:�:�;�;�;�#�)�&�A�A�E�E������A� � �-� -�K��:�:�:��H�;�H�H�I�I�I��J� �u���u� � � #�� � �"�"�� �u���u� � � #�� � �"�"�� �G�E�N�N�E� �G�E�N�N�E� ��Q� �B� ��Q� �B�
�2�r�{�{�a����D�E�E�E��~�u�e�n�-�-�H�
�?�5�(�� 9� 9� 9�B� >�D�
�?�5�(�� 9� 9� 9�B� >�D��T�k�G� �i�� � �G��i�� � �G��� �H��� �H� �7�G�G�$�$�a�� +� +�D� �7� �D��f� � �� �!;�!;��t� � � �� �
���� �� �
��� �B�� � �A�
��'�C�
��'�C� �F�7�D� �v�~�~� �b�"�+�+��3�3�w�w����
�� � � �"�(�2�8�$�$�(�3�.� .� .��D� �M�8��8� 8� �8� 8� 8�9G� �
�
�
�
�
�w���1�"�b�!�Q� �L�L����D�� (��D� �M� 9�15�9� 9� 9�:H�%&�
(�
(�
(�
(� �w��� �u�R�y�y�%��)�)�,�d�;�;�;���1�
��U�a�!�e�_�� �+� %� %� �&�)�)�!�R�X�b�\�\�:�:�D�D���� � �a��A� ��1��9�q�1�u��A�a�C�� 0����1��a��c��1C�1C� C�C� G�G�D��6�$�<�<�D�
�7�4��A� � �D� ��4�J�'-� /� /� /� /rt c �^ � d\ }}t | t � � rt t | � � j }nt | � � r| }t |t � � r t t |� � j }d }nt |� � r|}d }t j |r ||d|i�n| � � } | ||fS )N�NNr� ) r� r" �getattrr �rvsrE r~ rk r� )r6 r7 r) r �rvsfuncr~ s rr �_parse_kstest_argsrM � s� � � �L�G�S��%�� � � ��-��/�/�3��� �%� � � ����%�� � � ��m�U�+�+�/����� �%� � � ����� �G�g�@�G�G�T�*��*�*�*�5� A� A�E� �%�� � rt r� c � � |dk rd}|dvrt d|z � � �t | |||� � \ }}}|rt |||||�� � S t ||||�� � S )a�
Performs the (one-sample or two-sample) Kolmogorov-Smirnov test for
goodness of fit.
The one-sample test compares the underlying distribution F(x) of a sample
against a given distribution G(x). The two-sample test compares the
underlying distributions of two independent samples. Both tests are valid
only for continuous distributions.
Parameters
----------
rvs : str, array_like, or callable
If an array, it should be a 1-D array of observations of random
variables.
If a callable, it should be a function to generate random variables;
it is required to have a keyword argument `size`.
If a string, it should be the name of a distribution in `scipy.stats`,
which will be used to generate random variables.
cdf : str, array_like or callable
If array_like, it should be a 1-D array of observations of random
variables, and the two-sample test is performed
(and rvs must be array_like).
If a callable, that callable is used to calculate the cdf.
If a string, it should be the name of a distribution in `scipy.stats`,
which will be used as the cdf function.
args : tuple, sequence, optional
Distribution parameters, used if `rvs` or `cdf` are strings or
callables.
N : int, optional
Sample size if `rvs` is string or callable. Default is 20.
alternative : {'two-sided', 'less', 'greater'}, optional
Defines the null and alternative hypotheses. Default is 'two-sided'.
Please see explanations in the Notes below.
method : {'auto', 'exact', 'approx', 'asymp'}, optional
Defines the distribution used for calculating the p-value.
The following options are available (default is 'auto'):
* 'auto' : selects one of the other options.
* 'exact' : uses the exact distribution of test statistic.
* 'approx' : approximates the two-sided probability with twice the
one-sided probability
* 'asymp': uses asymptotic distribution of test statistic
Returns
-------
res: KstestResult
An object containing attributes:
statistic : float
KS test statistic, either D+, D-, or D (the maximum of the two)
pvalue : float
One-tailed or two-tailed p-value.
statistic_location : float
In a one-sample test, this is the value of `rvs`
corresponding with the KS statistic; i.e., the distance between
the empirical distribution function and the hypothesized cumulative
distribution function is measured at this observation.
In a two-sample test, this is the value from `rvs` or `cdf`
corresponding with the KS statistic; i.e., the distance between
the empirical distribution functions is measured at this
observation.
statistic_sign : int
In a one-sample test, this is +1 if the KS statistic is the
maximum positive difference between the empirical distribution
function and the hypothesized cumulative distribution function
(D+); it is -1 if the KS statistic is the maximum negative
difference (D-).
In a two-sample test, this is +1 if the empirical distribution
function of `rvs` exceeds the empirical distribution
function of `cdf` at `statistic_location`, otherwise -1.
See Also
--------
ks_1samp, ks_2samp
Notes
-----
There are three options for the null and corresponding alternative
hypothesis that can be selected using the `alternative` parameter.
- `two-sided`: The null hypothesis is that the two distributions are
identical, F(x)=G(x) for all x; the alternative is that they are not
identical.
- `less`: The null hypothesis is that F(x) >= G(x) for all x; the
alternative is that F(x) < G(x) for at least one x.
- `greater`: The null hypothesis is that F(x) <= G(x) for all x; the
alternative is that F(x) > G(x) for at least one x.
Note that the alternative hypotheses describe the *CDFs* of the
underlying distributions, not the observed values. For example,
suppose x1 ~ F and x2 ~ G. If F(x) > G(x) for all x, the values in
x1 tend to be less than those in x2.
Examples
--------
Suppose we wish to test the null hypothesis that a sample is distributed
according to the standard normal.
We choose a confidence level of 95%; that is, we will reject the null
hypothesis in favor of the alternative if the p-value is less than 0.05.
When testing uniformly distributed data, we would expect the
null hypothesis to be rejected.
>>> import numpy as np
>>> from scipy import stats
>>> rng = np.random.default_rng()
>>> stats.kstest(stats.uniform.rvs(size=100, random_state=rng),
... stats.norm.cdf)
KstestResult(statistic=0.5001899973268688, pvalue=1.1616392184763533e-23)
Indeed, the p-value is lower than our threshold of 0.05, so we reject the
null hypothesis in favor of the default "two-sided" alternative: the data
are *not* distributed according to the standard normal.
When testing random variates from the standard normal distribution, we
expect the data to be consistent with the null hypothesis most of the time.
>>> x = stats.norm.rvs(size=100, random_state=rng)
>>> stats.kstest(x, stats.norm.cdf)
KstestResult(statistic=0.05345882212970396, pvalue=0.9227159037744717)
As expected, the p-value of 0.92 is not below our threshold of 0.05, so
we cannot reject the null hypothesis.
Suppose, however, that the random variates are distributed according to
a normal distribution that is shifted toward greater values. In this case,
the cumulative density function (CDF) of the underlying distribution tends
to be *less* than the CDF of the standard normal. Therefore, we would
expect the null hypothesis to be rejected with ``alternative='less'``:
>>> x = stats.norm.rvs(size=100, loc=0.5, random_state=rng)
>>> stats.kstest(x, stats.norm.cdf, alternative='less')
KstestResult(statistic=0.17482387821055168, pvalue=0.001913921057766743)
and indeed, with p-value smaller than our threshold, we reject the null
hypothesis in favor of the alternative.
For convenience, the previous test can be performed using the name of the
distribution as the second argument.
>>> stats.kstest(x, "norm", alternative='less')
KstestResult(statistic=0.17482387821055168, pvalue=0.001913921057766743)
The examples above have all been one-sample tests identical to those
performed by `ks_1samp`. Note that `kstest` can also perform two-sample
tests identical to those performed by `ks_2samp`. For example, when two
samples are drawn from the same distribution, we expect the data to be
consistent with the null hypothesis most of the time.
>>> sample1 = stats.laplace.rvs(size=105, random_state=rng)
>>> sample2 = stats.laplace.rvs(size=95, random_state=rng)
>>> stats.kstest(sample1, sample2)
KstestResult(statistic=0.11779448621553884, pvalue=0.4494256912629795)
As expected, the p-value of 0.45 is not below our threshold of 0.05, so
we cannot reject the null hypothesis.
� two_sidedr{ r r )r) r� r. )r� r. )r� rM rY rZ )rK r~ r) r r� r. �xvals�yvalss rr rX rX s� � �L �k�!�!�!� ��:�:�:��4�{�B�C�C�C�*�3��T�1�=�=��E�5�#�
� '���s��;� %�'� '� '� '� �E�5�k�&� I� I� I�Irt c � � t j | � � }t j t j d|dd� |dd� k df � � d }t j |� � � t j � � }t j |j � � }|dk rdn%d|dz |z
� � � |dz |z
z z
S ) a� Tie correction factor for Mann-Whitney U and Kruskal-Wallis H tests.
Parameters
----------
rankvals : array_like
A 1-D sequence of ranks. Typically this will be the array
returned by `~scipy.stats.rankdata`.
Returns
-------
factor : float
Correction factor for U or H.
See Also
--------
rankdata : Assign ranks to the data
mannwhitneyu : Mann-Whitney rank test
kruskal : Kruskal-Wallis H test
References
----------
.. [1] Siegel, S. (1956) Nonparametric Statistics for the Behavioral
Sciences. New York: McGraw-Hill.
Examples
--------
>>> from scipy.stats import tiecorrect, rankdata
>>> tiecorrect([1, 2.5, 2.5, 4])
0.9
>>> ranks = rankdata([1, 3, 2, 4, 5, 7, 2, 8, 4])
>>> ranks
array([ 1. , 4. , 2.5, 5.5, 7. , 8. , 2.5, 9. , 5.5])
>>> tiecorrect(ranks)
0.9833333333333333
Tr Nr� r r� r� rW ) rk r� r r r r rB r� r� )�rankvalsr r� r r� s rr r] r] � s� � �J
�'�(�
�
�C�
�*�R�U�4��Q�R�R��C����H�!4�d�:�;�
<�
<�Q�
?�C�
�'�#�,�,�
�
�b�j�
)�
)�C�
�:�c�h� � �D���(�(�3�3��s�A�v��|�&8�&8�&:�&:�d�A�g��n�&M� M�Mrt �RanksumsResult)r� c � � t t j | |f� � \ } }t | � � }t |� � }t j | |f� � }t |� � }|d|� } t j | d�� � }|||z dz z dz }||z
t j ||z ||z dz z dz � � z } t | |� � \ } }
t | |
� � S )a� Compute the Wilcoxon rank-sum statistic for two samples.
The Wilcoxon rank-sum test tests the null hypothesis that two sets
of measurements are drawn from the same distribution. The alternative
hypothesis is that values in one sample are more likely to be
larger than the values in the other sample.
This test should be used to compare two samples from continuous
distributions. It does not handle ties between measurements
in x and y. For tie-handling and an optional continuity correction
see `scipy.stats.mannwhitneyu`.
Parameters
----------
x,y : array_like
The data from the two samples.
alternative : {'two-sided', 'less', 'greater'}, optional
Defines the alternative hypothesis. Default is 'two-sided'.
The following options are available:
* 'two-sided': one of the distributions (underlying `x` or `y`) is
stochastically greater than the other.
* 'less': the distribution underlying `x` is stochastically less
than the distribution underlying `y`.
* 'greater': the distribution underlying `x` is stochastically greater
than the distribution underlying `y`.
.. versionadded:: 1.7.0
Returns
-------
statistic : float
The test statistic under the large-sample approximation that the
rank sum statistic is normally distributed.
pvalue : float
The p-value of the test.
References
----------
.. [1] https://en.wikipedia.org/wiki/Wilcoxon_rank-sum_test
Examples
--------
We can test the hypothesis that two independent unequal-sized samples are
drawn from the same distribution with computing the Wilcoxon rank-sum
statistic.
>>> import numpy as np
>>> from scipy.stats import ranksums
>>> rng = np.random.default_rng()
>>> sample1 = rng.uniform(-1, 1, 200)
>>> sample2 = rng.uniform(-0.5, 1.5, 300) # a shifted distribution
>>> ranksums(sample1, sample2)
RanksumsResult(statistic=-7.887059, pvalue=3.09390448e-15) # may vary
>>> ranksums(sample1, sample2, alternative='less')
RanksumsResult(statistic=-7.750585297581713, pvalue=4.573497606342543e-15) # may vary
>>> ranksums(sample1, sample2, alternative='greater')
RanksumsResult(statistic=-7.750585297581713, pvalue=0.9999999999999954) # may vary
The p-value of less than ``0.05`` indicates that this test rejects the
hypothesis at the 5% significance level.
Nr r r rZ � (@)
�maprk r r� ry ra r� r r� rT ) r� r� r� r� r� r� �rankedrO �expectedr� r� s rr r^ r^ � s� � �B �r�z�A�q�6� "� "�D�A�q� �Q���B� �Q���B��n�a��V�$�$�G�
�g�
�
�F��s��s� �A�
��q�q����A��R��U�1�W�~��#�H�
�X� ����B���2��a�� ��!5�6�6�6�A� �q�+�.�.�G�A�t� �!�T� "� "�"rt �
KruskalResultc � � t t t j |� � � � }t |� � }|dk rt d� � �|D ]M}|j dk r&t t j t j � � c S |j dk rt d� � ��Nt j t t t |� � � � � � }| dvrt d� � �d}|D ] }t || � � }|d rd } n� |r-| d
k r'|D ]}t j |� � }�t j |� S |r*| d k r$t t j t j � � S t j |� � }t! |� � }t# |� � } | dk rt d � � �t j t j |� � dd� � }
d} t) |� � D ]4} | t+ ||
| |
| dz � � � || z z
} �5t j |t. �
� � }
d|
|
dz z z | z d|
dz z z
}|dz
}|| z }t |t0 j � ||� � � � S )a{ Compute the Kruskal-Wallis H-test for independent samples.
The Kruskal-Wallis H-test tests the null hypothesis that the population
median of all of the groups are equal. It is a non-parametric version of
ANOVA. The test works on 2 or more independent samples, which may have
different sizes. Note that rejecting the null hypothesis does not
indicate which of the groups differs. Post hoc comparisons between
groups are required to determine which groups are different.
Parameters
----------
sample1, sample2, ... : array_like
Two or more arrays with the sample measurements can be given as
arguments. Samples must be one-dimensional.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan.
The following options are available (default is 'propagate'):
* 'propagate': returns nan
* 'raise': throws an error
* 'omit': performs the calculations ignoring nan values
Returns
-------
statistic : float
The Kruskal-Wallis H statistic, corrected for ties.
pvalue : float
The p-value for the test using the assumption that H has a chi
square distribution. The p-value returned is the survival function of
the chi square distribution evaluated at H.
See Also
--------
f_oneway : 1-way ANOVA.
mannwhitneyu : Mann-Whitney rank test on two samples.
friedmanchisquare : Friedman test for repeated measurements.
Notes
-----
Due to the assumption that H has a chi square distribution, the number
of samples in each group must not be too small. A typical rule is
that each sample must have at least 5 measurements.
References
----------
.. [1] W. H. Kruskal & W. W. Wallis, "Use of Ranks in
One-Criterion Variance Analysis", Journal of the American Statistical
Association, Vol. 47, Issue 260, pp. 583-621, 1952.
.. [2] https://en.wikipedia.org/wiki/Kruskal-Wallis_one-way_analysis_of_variance
Examples
--------
>>> from scipy import stats
>>> x = [1, 3, 5, 7, 9]
>>> y = [2, 4, 6, 8, 10]
>>> stats.kruskal(x, y)
KruskalResult(statistic=0.2727272727272734, pvalue=0.6015081344405895)
>>> x = [1, 1, 1]
>>> y = [2, 2, 2]
>>> z = [2, 2]
>>> stats.kruskal(x, y, z)
KruskalResult(statistic=7.0, pvalue=0.0301973834223185)
r� z+Need at least two groups in stats.kruskal()r r z Samples must be one-dimensional.)r� r� r� z1nan_policy must be 'propagate', 'raise' or 'omit'FTr� r� z$All numbers are identical in kruskalr� rV rW )ry rW rk r r� r� r� rZ r rm r r r� r� r_ ry ra r] �insertr� r� r| r� r� r r� r )r� r� r� r r� r� �cnr� rX �tiesr� r� r1 �totalnr� r� s rr r_ r_ A! s� � �F �3�r�z�7�+�+�,�,�G��W� � �J��A�~�~��F�G�G�G�� A� A�� �;�!� � � �����0�0� 0� 0� 0�
�[�A�
�
� � ?�@�@� @� � �
�4��C��)�)�*�*�+�+�A��7�7�7��L�M�M�M��L�� � ��
�6�:�
.�
.��
�a�5� � �L� �E� � � .�
�f�,�,� � /� /�F��&�v�.�.�F�F��#�W�-�-�� -�
�k�1�1� �R�V�R�V�,�,�,��n�W�%�%�G�
�g�
�
�F� �f� � �D� �q�y�y��?�@�@�@� � �"�)�A�,�,��1�%�%�A� �D�
�:�
�
� <� <�� ���q��t�A�a��c�F�{� 3�4�4�q��t�;�;���
�V�A�U�
#�
#�
#�F� ��&�1�*�%�&��-��V�a�Z�0@�@�A� �a� �B���I�A� ��M� .� 1� 1�!�R� 8� 8� 9� 9�9rt �FriedmanchisquareResultc �v � t | � � }|dk r"t d� |� � � � �t | d � � }t d|� � D ]*}t | | � � |k rt d� � ��+t j | � � j }|� t � � }t t |� � � � D ]}t || � � ||< �d}|D ]4}t t |� � � � \ }}|D ]} || | | z dz
z z
}��5d||||z dz
z |z z z
}
t j |� d�� � dz � � } d||z |dz z z | z d|z |dz z z
|
z } t | t j � | |dz
� � � � S ) a� Compute the Friedman test for repeated samples.
The Friedman test tests the null hypothesis that repeated samples of
the same individuals have the same distribution. It is often used
to test for consistency among samples obtained in different ways.
For example, if two sampling techniques are used on the same set of
individuals, the Friedman test can be used to determine if the two
sampling techniques are consistent.
Parameters
----------
sample1, sample2, sample3... : array_like
Arrays of observations. All of the arrays must have the same number
of elements. At least three samples must be given.
Returns
-------
statistic : float
The test statistic, correcting for ties.
pvalue : float
The associated p-value assuming that the test statistic has a chi
squared distribution.
Notes
-----
Due to the assumption that the test statistic has a chi squared
distribution, the p-value is only reliable for n > 10 and more than
6 repeated samples.
References
----------
.. [1] https://en.wikipedia.org/wiki/Friedman_test
rW zCAt least 3 sets of samples must be given for Friedman test, got {}.r r z*Unequal N in friedmanchisquare. Aborting.r r� rV )r� r� r1 r� rk �vstack�Tr r� ra r) r r� r` r r� r )
r� r� r� r1 r r^ r� �replist�repnumr rP r� �chisqs
rr r` r` �! s� � �F �G� � �A��1�u�u�� 6�6<�f�Q�i�i�A� A� A� �G�A�J���A�
�1�a�[�[� K� K�� �w�q�z�?�?�a� � � � I�J�J� J� � �9�W� � � �D� �;�;�u� � �D�
�3�t�9�9�
�
� $� $���4��7�#�#��Q���
�D�
� "� "��&�u�Q�x�x�0�0����� "� "�A� �A��1��q��M� !�D�D� "� �D�A�q��s�Q�w�K��M� "�"�A�
�6�$�(�(��(�"�"�A�%� &� &�D�
�Q�q�S�!�A�#�Y�
�$�
&��1��a��c��
2�a� 7�E� "�5�-�*<�*?�*?��q�1�u�*M�*M� N� N�Nrt �BrunnerMunzelResultr c �L � t j | � � } t j |� � }t | |� � \ }}t ||� � \ }}|p|} |dk s|dk rd}| r*|dk r$t t j t j � � S | rE|dk r?t j | � � } t j |� � }t j | |||� � S t | � � }
t |� � } |
dk s| dk r$t t j t j � � S t t j | |f� � � � } | d|
� }
| |
|
| z � }t j |
� � }t j |� � }t | � � }t |� � }t j |� � }t j |� � }t j
t j |
|z
|z
|z d� � � � }||
dz
z }t j
t j ||z
|z
|z d� � � � }|| dz
z }|
| z ||z
z }||
| z t j |
|z | |z z � � z z }|dk r�t j |
|z | |z z d� � }t j |
|z d� � |
dz
z }|t j | |z d� � | dz
z z
}||z }|dk r"|dk r d}t! j |t$ � � t& j � ||� � } n5|dk r t& j � |� � } nt/ d � � �|d
k rn>|d k rd| z
} n2|d k r d
t j | d| z
g� � z } nt/ d� � �t || � � S )a�
Compute the Brunner-Munzel test on samples x and y.
The Brunner-Munzel test is a nonparametric test of the null hypothesis that
when values are taken one by one from each group, the probabilities of
getting large values in both groups are equal.
Unlike the Wilcoxon-Mann-Whitney's U test, this does not require the
assumption of equivariance of two groups. Note that this does not assume
the distributions are same. This test works on two independent samples,
which may have different sizes.
Parameters
----------
x, y : array_like
Array of samples, should be one-dimensional.
alternative : {'two-sided', 'less', 'greater'}, optional
Defines the alternative hypothesis.
The following options are available (default is 'two-sided'):
* 'two-sided'
* 'less': one-sided
* 'greater': one-sided
distribution : {'t', 'normal'}, optional
Defines how to get the p-value.
The following options are available (default is 't'):
* 't': get the p-value by t-distribution
* 'normal': get the p-value by standard normal distribution.
nan_policy : {'propagate', 'raise', 'omit'}, optional
Defines how to handle when input contains nan.
The following options are available (default is 'propagate'):
* 'propagate': returns nan
* 'raise': throws an error
* 'omit': performs the calculations ignoring nan values
Returns
-------
statistic : float
The Brunner-Munzer W statistic.
pvalue : float
p-value assuming an t distribution. One-sided or
two-sided, depending on the choice of `alternative` and `distribution`.
See Also
--------
mannwhitneyu : Mann-Whitney rank test on two samples.
Notes
-----
Brunner and Munzel recommended to estimate the p-value by t-distribution
when the size of data is 50 or less. If the size is lower than 10, it would
be better to use permuted Brunner Munzel test (see [2]_).
References
----------
.. [1] Brunner, E. and Munzel, U. "The nonparametric Benhrens-Fisher
problem: Asymptotic theory and a small-sample approximation".
Biometrical Journal. Vol. 42(2000): 17-25.
.. [2] Neubert, K. and Brunner, E. "A studentized permutation test for the
non-parametric Behrens-Fisher problem". Computational Statistics and
Data Analysis. Vol. 51(2007): 5192-5204.
Examples
--------
>>> from scipy import stats
>>> x1 = [1,2,1,1,1,1,1,1,1,1,2,4,1,1]
>>> x2 = [3,3,4,3,1,2,3,1,1,5,4]
>>> w, p_value = stats.brunnermunzel(x1, x2)
>>> w
3.1374674823029505
>>> p_value
0.0057862086661515377
r� r� r rZ r r z�p-value cannot be estimated with `distribution='t' because degrees of freedom parameter is undefined (0/0). Try using `distribution='normal'r( z&distribution should be 't' or 'normal'rz ry r{ r� z6alternative should be 'less', 'greater' or 'two-sided')rk r r rg r r r� r� re r� ra ry r� r� r� r r� r� rH r r r~ r} r� rr ) r� r� r� � distributionr� r r r r r� rY r[ �rankc�rankcx�rankcy� rankcx_mean� rankcy_mean�rankx�ranky�
rankx_mean�
ranky_mean�Sx�Sy�wbfn�df_numer�df_denomr� r� r� s rr re re " s� � �X �
�1�
�
�A�
�
�1�
�
�A� �Q�
�+�+�H�C�� �Q�
�+�+�H�C���:�#�L�
�f�}�}��v�
�
��
�� K�
�k�1�1�"�2�6�2�6�2�2�2� � K�*��.�.� � �a� � �� � �a� � ���)�!�Q� �\�J�J�J� �Q���B� �Q���B� �Q�w�w�"��'�'�"�2�6�2�6�2�2�2� �R�^�Q��F�+�+� ,� ,�E�
�1�R�4�[�F�
�2�b��e�8�_�F��'�&�/�/�K��'�&�/�/�K� �Q�K�K�E� �Q�K�K�E���� � �J���� � �J� �����%� �+�5�
�B�C�H�H� I� I�B��"�q�&�L�B� �����%� �+�5�
�B�C�H�H� I� I�B��"�q�&�L�B�
��7�k�K�/� 0�D��R�"�W����R��"�r�'� 1�2�2� 2�2�D��s����8�B��G�b�2�g� -�s�3�3���8�B��G�S�)�)�R�!�V�4���B�H�R�"�W�c�*�*�b�1�f�5�5��
��
�� ��M�M��A�
�
�A�G�
�M�'�>� 2� 2� 2� �O� � ��b� )� )��� �� !� !� � � "� "�4� (� (���� 4�6� 6� 6� �i� � � � �� � �
��E��� � � #� #�
����1�Q�3�x� � � ���� D�F� F� F� �t�Q� '� '�'rt ri c �V � t j | � � } | j dk rt d� � �|dk r[dt j t j | � � � � z }t j � |dt | � � z � � }�n�|dk r]dt j t j
| � � � � z }t j � | dt | � � z � � }�n(|dk r�t j dt | � � z � � t j
z }t j t j | � � � � t j t j
| � � � � z }d t | � � z d
z }t j ||dz
z � � }t j � ||z |z |� � }�nK|d k rDt j | � � }t j � |dt | � � � � }�n|d k r�|�t j | � � }n/t |� � t | � � k rt d� � �t j |� � }|j dk rt d� � �t j � | � � }t j ||� � t j � |� � z }t j � |� � }nt d|�d�� � �t- ||� � S )a
Combine p-values from independent tests that bear upon the same hypothesis.
These methods are intended only for combining p-values from hypothesis
tests based upon continuous distributions.
Each method assumes that under the null hypothesis, the p-values are
sampled independently and uniformly from the interval [0, 1]. A test
statistic (different for each method) is computed and a combined
p-value is calculated based upon the distribution of this test statistic
under the null hypothesis.
Parameters
----------
pvalues : array_like, 1-D
Array of p-values assumed to come from independent tests based on
continuous distributions.
method : {'fisher', 'pearson', 'tippett', 'stouffer', 'mudholkar_george'}
Name of method to use to combine p-values.
The available methods are (see Notes for details):
* 'fisher': Fisher's method (Fisher's combined probability test)
* 'pearson': Pearson's method
* 'mudholkar_george': Mudholkar's and George's method
* 'tippett': Tippett's method
* 'stouffer': Stouffer's Z-score method
weights : array_like, 1-D, optional
Optional array of weights used only for Stouffer's Z-score method.
Returns
-------
res : SignificanceResult
An object containing attributes:
statistic : float
The statistic calculated by the specified method.
pvalue : float
The combined p-value.
Notes
-----
If this function is applied to tests with a discrete statistics such as
any rank test or contingency-table test, it will yield systematically
wrong results, e.g. Fisher's method will systematically overestimate the
p-value [1]_. This problem becomes less severe for large sample sizes
when the discrete distributions become approximately continuous.
The differences between the methods can be best illustrated by their
statistics and what aspects of a combination of p-values they emphasise
when considering significance [2]_. For example, methods emphasising large
p-values are more sensitive to strong false and true negatives; conversely
methods focussing on small p-values are sensitive to positives.
* The statistics of Fisher's method (also known as Fisher's combined
probability test) [3]_ is :math:`-2\sum_i \log(p_i)`, which is
equivalent (as a test statistics) to the product of individual p-values:
:math:`\prod_i p_i`. Under the null hypothesis, this statistics follows
a :math:`\chi^2` distribution. This method emphasises small p-values.
* Pearson's method uses :math:`-2\sum_i\log(1-p_i)`, which is equivalent
to :math:`\prod_i \frac{1}{1-p_i}` [2]_.
It thus emphasises large p-values.
* Mudholkar and George compromise between Fisher's and Pearson's method by
averaging their statistics [4]_. Their method emphasises extreme
p-values, both close to 1 and 0.
* Stouffer's method [5]_ uses Z-scores and the statistic:
:math:`\sum_i \Phi^{-1} (p_i)`, where :math:`\Phi` is the CDF of the
standard normal distribution. The advantage of this method is that it is
straightforward to introduce weights, which can make Stouffer's method
more powerful than Fisher's method when the p-values are from studies
of different size [6]_ [7]_.
* Tippett's method uses the smallest p-value as a statistic.
(Mind that this minimum is not the combined p-value.)
Fisher's method may be extended to combine p-values from dependent tests
[8]_. Extensions such as Brown's method and Kost's method are not currently
implemented.
.. versionadded:: 0.15.0
References
----------
.. [1] Kincaid, W. M., "The Combination of Tests Based on Discrete
Distributions." Journal of the American Statistical Association 57,
no. 297 (1962), 10-19.
.. [2] Heard, N. and Rubin-Delanchey, P. "Choosing between methods of
combining p-values." Biometrika 105.1 (2018): 239-246.
.. [3] https://en.wikipedia.org/wiki/Fisher%27s_method
.. [4] George, E. O., and G. S. Mudholkar. "On the convolution of logistic
random variables." Metrika 30.1 (1983): 1-13.
.. [5] https://en.wikipedia.org/wiki/Fisher%27s_method#Relation_to_Stouffer.27s_Z-score_method
.. [6] Whitlock, M. C. "Combining probability from independent tests: the
weighted Z-method is superior to Fisher's approach." Journal of
Evolutionary Biology 18, no. 5 (2005): 1368-1373.
.. [7] Zaykin, Dmitri V. "Optimally weighted Z-test is a powerful method
for combining probabilities in meta-analysis." Journal of
Evolutionary Biology 24, no. 8 (2011): 1836-1841.
.. [8] https://en.wikipedia.org/wiki/Extensions_of_Fisher%27s_method
r zpvalues is not 1-Dri r= r� r� �mudholkar_georgerW r� r< �tippett�stoufferNz-pvalues and weights must be of the same size.zweights is not 1-DzInvalid method zV. Valid methods are 'fisher', 'pearson', 'mudholkar_george', 'tippett', and 'stouffer')rk r rm r� r� r� r r� r r� �log1pr~ r �pir rr r� � ones_liker} �isfr� r r� ) r� r. r� r� r� �normalizing_factor�nu�
approx_factor�Zis rr rb rb �" s� � �L �j��!�!�G��|�q����-�.�.�.�
���������w���0�0�0� � �!�$�$�Y��C��L�L�0@�A�A��� �9� � ����r�x��� 1� 1�2�2�2� � �!�%�%�y�j�!�c�'�l�l�2B�C�C��� �%� %� %� �W�Q�s�7�|�|�^� 4� 4�R�U� :���V�B�F�7�O�O�,�,�,�r�v�b�h��x�6H�6H�/I�/I�I� �
��W� � �
��
!�����b�1�f�
�.�.�
� ��!�!�)�.@�"@�$1�#2�35�7� 7��� �9� � ��F�7�O�O� � �!�%�%�i��C��L�L�A�A��� �:� � � �?��l�7�+�+�G�G�
��\�\�S��\�\�
)�
)� � L�M�M� M��*�W�%�%�� �<�1� � � � 1�2�2� 2�
�
�
#�
#�G�
,�
,���F�7�B�'�'�"�)�.�.��*A�*A�A� � �!�$�$�Y�/�/��� �
G�f�
G�
G�
G�
�
�
�
�i�� .� .�.rt c �( � t d| |||� � S )a^
Compute the first Wasserstein distance between two 1D distributions.
This distance is also known as the earth mover's distance, since it can be
seen as the minimum amount of "work" required to transform :math:`u` into
:math:`v`, where "work" is measured as the amount of distribution weight
that must be moved, multiplied by the distance it has to be moved.
.. versionadded:: 1.0.0
Parameters
----------
u_values, v_values : array_like
Values observed in the (empirical) distribution.
u_weights, v_weights : array_like, optional
Weight for each value. If unspecified, each value is assigned the same
weight.
`u_weights` (resp. `v_weights`) must have the same length as
`u_values` (resp. `v_values`). If the weight sum differs from 1, it
must still be positive and finite so that the weights can be normalized
to sum to 1.
Returns
-------
distance : float
The computed distance between the distributions.
Notes
-----
The first Wasserstein distance between the distributions :math:`u` and
:math:`v` is:
.. math::
l_1 (u, v) = \inf_{\pi \in \Gamma (u, v)} \int_{\mathbb{R} \times
\mathbb{R}} |x-y| \mathrm{d} \pi (x, y)
where :math:`\Gamma (u, v)` is the set of (probability) distributions on
:math:`\mathbb{R} \times \mathbb{R}` whose marginals are :math:`u` and
:math:`v` on the first and second factors respectively.
If :math:`U` and :math:`V` are the respective CDFs of :math:`u` and
:math:`v`, this distance also equals to:
.. math::
l_1(u, v) = \int_{-\infty}^{+\infty} |U-V|
See [2]_ for a proof of the equivalence of both definitions.
The input distributions can be empirical, therefore coming from samples
whose values are effectively inputs of the function, or they can be seen as
generalized functions, in which case they are weighted sums of Dirac delta
functions located at the specified values.
References
----------
.. [1] "Wasserstein metric", https://en.wikipedia.org/wiki/Wasserstein_metric
.. [2] Ramdas, Garcia, Cuturi "On Wasserstein Two Sample Testing and Related
Families of Nonparametric Tests" (2015). :arXiv:`1509.02237`.
Examples
--------
>>> from scipy.stats import wasserstein_distance
>>> wasserstein_distance([0, 1, 3], [5, 6, 8])
5.0
>>> wasserstein_distance([0, 1], [0, 1], [3, 1], [2, 2])
0.25
>>> wasserstein_distance([3.4, 3.9, 7.5, 7.8], [4.5, 1.4],
... [1.4, 0.9, 3.1, 7.2], [3.2, 3.5])
4.0781331438047861
r )�
_cdf_distance��u_values�v_values� u_weights� v_weightss rr rc rc *# s � �T ��H�h� �9� E� E�Ert c �R � t j d� � t d| |||� � z S )uI Compute the energy distance between two 1D distributions.
.. versionadded:: 1.0.0
Parameters
----------
u_values, v_values : array_like
Values observed in the (empirical) distribution.
u_weights, v_weights : array_like, optional
Weight for each value. If unspecified, each value is assigned the same
weight.
`u_weights` (resp. `v_weights`) must have the same length as
`u_values` (resp. `v_values`). If the weight sum differs from 1, it
must still be positive and finite so that the weights can be normalized
to sum to 1.
Returns
-------
distance : float
The computed distance between the distributions.
Notes
-----
The energy distance between two distributions :math:`u` and :math:`v`, whose
respective CDFs are :math:`U` and :math:`V`, equals to:
.. math::
D(u, v) = \left( 2\mathbb E|X - Y| - \mathbb E|X - X'| -
\mathbb E|Y - Y'| \right)^{1/2}
where :math:`X` and :math:`X'` (resp. :math:`Y` and :math:`Y'`) are
independent random variables whose probability distribution is :math:`u`
(resp. :math:`v`).
Sometimes the square of this quantity is referred to as the "energy
distance" (e.g. in [2]_, [4]_), but as noted in [1]_ and [3]_, only the
definition above satisfies the axioms of a distance function (metric).
As shown in [2]_, for one-dimensional real-valued variables, the energy
distance is linked to the non-distribution-free version of the Cramér-von
Mises distance:
.. math::
D(u, v) = \sqrt{2} l_2(u, v) = \left( 2 \int_{-\infty}^{+\infty} (U-V)^2
\right)^{1/2}
Note that the common Cramér-von Mises criterion uses the distribution-free
version of the distance. See [2]_ (section 2), for more details about both
versions of the distance.
The input distributions can be empirical, therefore coming from samples
whose values are effectively inputs of the function, or they can be seen as
generalized functions, in which case they are weighted sums of Dirac delta
functions located at the specified values.
References
----------
.. [1] Rizzo, Szekely "Energy distance." Wiley Interdisciplinary Reviews:
Computational Statistics, 8(1):27-38 (2015).
.. [2] Szekely "E-statistics: The energy of statistical samples." Bowling
Green State University, Department of Mathematics and Statistics,
Technical Report 02-16 (2002).
.. [3] "Energy distance", https://en.wikipedia.org/wiki/Energy_distance
.. [4] Bellemare, Danihelka, Dabney, Mohamed, Lakshminarayanan, Hoyer,
Munos "The Cramer Distance as a Solution to Biased Wasserstein
Gradients" (2017). :arXiv:`1705.10743`.
Examples
--------
>>> from scipy.stats import energy_distance
>>> energy_distance([0], [2])
2.0000000000000004
>>> energy_distance([0, 8], [0, 8], [3, 1], [2, 2])
1.0000000000000002
>>> energy_distance([0.7, 7.4, 2.4, 6.8], [1.4, 8. ],
... [2.1, 4.2, 7.4, 8. ], [7.6, 8.8])
0.88003340976158217
r� )rk r r� r� s rr rd rd w# s1 � �d �7�1�:�:�
�a��8�&/��<� <� <� <rt c �� � t ||� � \ }}t ||� � \ }}t j |� � }t j |� � }t j ||f� � }|� d�� � t j |� � }|| � |dd� d� � } || � |dd� d� � }
|� | |j z } n@t j dgt j || � � f� � } | | | d z } |� |
|j z }
n@t j dgt j || � � f� � }||
|d z }
| dk r<t j t j
t j | |
z
� � |� � � � S | dk rNt j t j t j
t j
| |
z
� � |� � � � � � S t j t j t j
t j t j | |
z
� � | � � |� � � � d| z � � S ) a
Compute, between two one-dimensional distributions :math:`u` and
:math:`v`, whose respective CDFs are :math:`U` and :math:`V`, the
statistical distance that is defined as:
.. math::
l_p(u, v) = \left( \int_{-\infty}^{+\infty} |U-V|^p \right)^{1/p}
p is a positive parameter; p = 1 gives the Wasserstein distance, p = 2
gives the energy distance.
Parameters
----------
u_values, v_values : array_like
Values observed in the (empirical) distribution.
u_weights, v_weights : array_like, optional
Weight for each value. If unspecified, each value is assigned the same
weight.
`u_weights` (resp. `v_weights`) must have the same length as
`u_values` (resp. `v_values`). If the weight sum differs from 1, it
must still be positive and finite so that the weights can be normalized
to sum to 1.
Returns
-------
distance : float
The computed distance between the distributions.
Notes
-----
The input distributions can be empirical, therefore coming from samples
whose values are effectively inputs of the function, or they can be seen as
generalized functions, in which case they are weighted sums of Dirac delta
functions located at the specified values.
References
----------
.. [1] Bellemare, Danihelka, Dabney, Mohamed, Lakshminarayanan, Hoyer,
Munos "The Cramer Distance as a Solution to Biased Wasserstein
Gradients" (2017). :arXiv:`1705.10743`.
r
r Nr� r� r r r� )�_validate_distributionrk r ry r� r r3 r� r� r� �multiplyr> r r� r� )r� r� r� r� r� �u_sorter�v_sorter�
all_values�deltas�
u_cdf_indices�
v_cdf_indices�u_cdf�u_sorted_cumweights�v_cdf�v_sorted_cumweightss rr r� r� �# sF � �X 1��9�E�E��H�i�0��9�E�E��H�i��z�(�#�#�H��z�(�#�#�H�� ��8� 4�5�5�J��O�O��O�%�%�%� �W�Z�
�
�F� �X�&�3�3�J�s��s�O�W�M�M�M� �X�&�3�3�J�s��s�O�W�M�M�M� �� ��
�-��� �n�q�c�.0�i� �(�8K�.L�.L�.N� O� O��#�M�2�5H��5L�L���� ��
�-��� �n�q�c�.0�i� �(�8K�.L�.L�.N� O� O��#�M�2�5H��5L�L��
�A�v�v��v�b�k�"�&��� �"7�"7��@�@�A�A�A��A�v�v��w�r�v�b�k�"�)�E�E�M�*B�*B�F� K� K�L�L�M�M�M�
�8�B�F�2�;�r�x���u�u�}�0E�0E�q�'I�'I�'-� /� /� 0� 0�12�1�� 6� 6� 6rt c �� � t j | t �� � } t | � � dk rt d� � �|��t j |t �� � }t |� � t | � � k rt d� � �t j |dk � � rt d� � �dt j |� � cxk rt j k sn t d� � �| |fS | dfS )a�
Validate the values and weights from a distribution input of `cdf_distance`
and return them as ndarray objects.
Parameters
----------
values : array_like
Values observed in the (empirical) distribution.
weights : array_like
Weight for each value.
Returns
-------
values : ndarray
Values as ndarray.
weights : ndarray
Weights as ndarray.
r� r z Distribution can't be empty.NzZValue and weight array-likes for the same empirical distribution must be of the same size.z!All weights must be non-negative.zcWeight array-like sum must be positive and finite. Set as None for an equal distribution of weight.)rk r r� r� r� rG r� r� )�valuesr� s rr r� r� $$ s � �* �Z��e�
,�
,�
,�F�
�6�{�{�a����7�8�8�8� ���*�W�E�2�2�2�� �w�<�<�3�v�;�;� &� &� � P� Q� Q�
Q�
�6�'�A�+� � � B� � @�A�A� A��2�6�'�?�?�+�+�+�+�R�V�+�+�+�+� � '� (� (�
(� �w�� � �4�<�rt �RepeatedResults)r� r� c �j � t t t j | t j �� � � � � S )a Find repeats and repeat counts.
Parameters
----------
arr : array_like
Input array. This is cast to float64.
Returns
-------
values : ndarray
The unique values from the (flattened) input that are repeated.
counts : ndarray
Number of times the corresponding 'value' is repeated.
Notes
-----
In numpy >= 1.9 `numpy.unique` provides similar functionality. The main
difference is that `find_repeats` only returns repeated values.
Examples
--------
>>> from scipy import stats
>>> stats.find_repeats([2, 1, 2, 3, 2, 2, 5])
RepeatedResults(values=array([2.]), counts=array([4]))
>>> stats.find_repeats([[10, 20, 1, 2], [5, 5, 4, 4]])
RepeatedResults(values=array([4., 5.]), counts=array([2, 2]))
r� )r� r rk r rB )r s rr r) r) V$ s) � �@ �M�"�(�3�b�j�*I�*I�*I� J� J� K�Krt c �X � t | |� � \ } }t j | | z |� � S )a� Square each element of the input array, and return the sum(s) of that.
Parameters
----------
a : array_like
Input array.
axis : int or None, optional
Axis along which to calculate. Default is 0. If None, compute over
the whole array `a`.
Returns
-------
sum_of_squares : ndarray
The sum along the given axis for (a**2).
See Also
--------
_square_of_sums : The square(s) of the sum(s) (the opposite of
`_sum_of_squares`).
)rs rk r� )ro rp s rr r} r} y$ s- � �, �1�d�#�#�G�A�t�
�6�!�A�#�t� � � rt c �� � t | |� � \ } }t j | |� � }t j |� � s |� t
� � |z S t |� � |z S )a� Sum elements of the input array, and return the square(s) of that sum.
Parameters
----------
a : array_like
Input array.
axis : int or None, optional
Axis along which to calculate. Default is 0. If None, compute over
the whole array `a`.
Returns
-------
square_of_sums : float or ndarray
The square of the sum over `axis`.
See Also
--------
_sum_of_squares : The sum of squares (the opposite of `square_of_sums`).
)rs rk r� r3 r r� )ro rp rO s rr r| r| �$ s[ � �* �1�d�#�#�G�A�t�
��q�$���A�
�;�q�>�>� ��x�x�����"�"��Q�x�x�!�|�rt r� )rp r� c �@ � |dvr"t d� |� � � � �t j | � � } |��| j dk rct j j � || j � � |dk r t j n t j
}t j | j |�� � S t j
t || ||�� � S t j | � � }t! ||� � \ }}d}|r?|dk rt j |� � }|d k r t j |t j � � S |d
k rd nd }t j ||�
� � } t j | j t j �� � }
t j | j t j �� � |
| < |d
k r|
dz } || }t j d|dd� |dd� k f } | � � � |
}
|dk r|
} t j t j | � � d t5 | � � f }|dk r||
} |dk r||
dz
dz } |dk rd||
||
dz
z dz z } |�$| � d� � } t j | |< | S )a�
Assign ranks to data, dealing with ties appropriately.
By default (``axis=None``), the data array is first flattened, and a flat
array of ranks is returned. Separately reshape the rank array to the
shape of the data array if desired (see Examples).
Ranks begin at 1. The `method` argument controls how ranks are assigned
to equal values. See [1]_ for further discussion of ranking methods.
Parameters
----------
a : array_like
The array of values to be ranked.
method : {'average', 'min', 'max', 'dense', 'ordinal'}, optional
The method used to assign ranks to tied elements.
The following methods are available (default is 'average'):
* 'average': The average of the ranks that would have been assigned to
all the tied values is assigned to each value.
* 'min': The minimum of the ranks that would have been assigned to all
the tied values is assigned to each value. (This is also
referred to as "competition" ranking.)
* 'max': The maximum of the ranks that would have been assigned to all
the tied values is assigned to each value.
* 'dense': Like 'min', but the rank of the next highest element is
assigned the rank immediately after those assigned to the tied
elements.
* 'ordinal': All values are given a distinct rank, corresponding to
the order that the values occur in `a`.
axis : {None, int}, optional
Axis along which to perform the ranking. If ``None``, the data array
is first flattened.
nan_policy : {'propagate', 'omit', 'raise'}, optional
Defines how to handle when input contains nan.
The following options are available (default is 'propagate'):
* 'propagate': propagates nans through the rank calculation
* 'omit': performs the calculations ignoring nan values
* 'raise': raises an error
.. note::
When `nan_policy` is 'propagate', the output is an array of *all*
nans because ranks relative to nans in the input are undefined.
When `nan_policy` is 'omit', nans in `a` are ignored when ranking
the other values, and the corresponding locations of the output
are nan.
.. versionadded:: 1.10
Returns
-------
ranks : ndarray
An array of size equal to the size of `a`, containing rank
scores.
References
----------
.. [1] "Ranking", https://en.wikipedia.org/wiki/Ranking
Examples
--------
>>> import numpy as np
>>> from scipy.stats import rankdata
>>> rankdata([0, 2, 3, 2])
array([ 1. , 2.5, 4. , 2.5])
>>> rankdata([0, 2, 3, 2], method='min')
array([ 1, 2, 4, 2])
>>> rankdata([0, 2, 3, 2], method='max')
array([ 1, 3, 4, 3])
>>> rankdata([0, 2, 3, 2], method='dense')
array([ 1, 2, 3, 2])
>>> rankdata([0, 2, 3, 2], method='ordinal')
array([ 1, 2, 4, 3])
>>> rankdata([[0, 2], [3, 2]]).reshape(2,2)
array([[1. , 2.5],
[4. , 2.5]])
>>> rankdata([[0, 2, 2], [3, 2, 5]], axis=1)
array([[1. , 2.5, 2.5],
[2. , 1. , 3. ]])
>>> rankdata([0, 2, 3, np.nan, -2, np.nan], nan_policy="propagate")
array([nan, nan, nan, nan, nan, nan])
>>> rankdata([0, 2, 3, np.nan, -2, np.nan], nan_policy="omit")
array([ 2., 3., 4., nan, 1., nan])
)r� rr r� �dense�ordinalzunknown method "{0}"Nr r� r� r� r� r� r� r
� quicksortr r Tr� r� r� rr r� rB ) r� r1 rk r r� rc rd re rm rB r� r� rz r ra rl r r� r� r r r r0 r r� r r� r )ro r. rp r� �dtr r� � nan_indexes�algo�sorter�invr� r! r� r� s rr ra ra �$ s� � �n �B�B�B��/�6�6�v�>�>�?�?�?�
�
�1�
�
�A� �� �6�Q�;�;�
�G� � 3� 3�D�!�&� A� A� A� %�� 2� 2������B��8�A�G�2�.�.�.� .��"�8�T�1�f�.8�:� :� :� :�
�(�1�+�+�C� ,�S�*� =� =� �L�*��K�� -� �� � � �(�3�-�-�K� �� $� $��<��R�V�,�,� ,� �I�-�-�;�;�;�D�
�Z��$�
'�
'�
'�F�
�(�6�;�b�g�
.�
.�
.�C��)�F�K�r�w�7�7�7�C��K�
�����q���
�f�+�C�
�%��c�!�"�"�g��S�b�S��)�)�
*�C� �J�J�L�L�� �E�
������
�E�"�*�S�/�/�!�$�c�#�h�h�.� /�E�
�����u� ��
�����u�q�y�!�A�%��
�����u�U�|�e�E�A�I�&6�6��:�;��� �� � �y�)�)�� �f��{�� �Mrt c � � ��� �dk s�dk rt d� � �t j � � � � ��t j �� j � � �� ��fd�}�dk r+t j � ��� � }t j � � � }n*t j � ��� � }t j � � � }||k r|S t |||�� � }|j S ) a� Compute the expectile at the specified level.
Expectiles are a generalization of the expectation in the same way as
quantiles are a generalization of the median. The expectile at level
`alpha = 0.5` is the mean (average). See Notes for more details.
Parameters
----------
a : array_like
Array containing numbers whose expectile is desired.
alpha : float, default: 0.5
The level of the expectile; e.g., `alpha=0.5` gives the mean.
weights : array_like, optional
An array of weights associated with the values in `a`.
The `weights` must be broadcastable to the same shape as `a`.
Default is None, which gives each value a weight of 1.0.
An integer valued weight element acts like repeating the corresponding
observation in `a` that many times. See Notes for more details.
Returns
-------
expectile : ndarray
The empirical expectile at level `alpha`.
See Also
--------
numpy.mean : Arithmetic average
numpy.quantile : Quantile
Notes
-----
In general, the expectile at level :math:`\alpha` of a random variable
:math:`X` with cumulative distribution function (CDF) :math:`F` is given
by the unique solution :math:`t` of:
.. math::
\alpha E((X - t)_+) = (1 - \alpha) E((t - X)_+) \,.
Here, :math:`(x)_+ = \max(0, x)` is the positive part of :math:`x`.
This equation can be equivalently written as:
.. math::
\alpha \int_t^\infty (x - t)\mathrm{d}F(x)
= (1 - \alpha) \int_{-\infty}^t (t - x)\mathrm{d}F(x) \,.
The empirical expectile at level :math:`\alpha` (`alpha`) of a sample
:math:`a_i` (the array `a`) is defined by plugging in the empirical CDF of
`a`. Given sample or case weights :math:`w` (the array `weights`), it
reads :math:`F_a(x) = \frac{1}{\sum_i a_i} \sum_i w_i 1_{a_i \leq x}`
with indicator function :math:`1_{A}`. This leads to the definition of the
empirical expectile at level `alpha` as the unique solution :math:`t` of:
.. math::
\alpha \sum_{i=1}^n w_i (a_i - t)_+ =
(1 - \alpha) \sum_{i=1}^n w_i (t - a_i)_+ \,.
For :math:`\alpha=0.5`, this simplifies to the weighted average.
Furthermore, the larger :math:`\alpha`, the larger the value of the
expectile.
As a final remark, the expectile at level :math:`\alpha` can also be
written as a minimization problem. One often used choice is
.. math::
\operatorname{argmin}_t
E(\lvert 1_{t\geq X} - \alpha\rvert(t - X)^2) \,.
References
----------
.. [1] W. K. Newey and J. L. Powell (1987), "Asymmetric Least Squares
Estimation and Testing," Econometrica, 55, 819-847.
.. [2] T. Gneiting (2009). "Making and Evaluating Point Forecasts,"
Journal of the American Statistical Association, 106, 746 - 762.
:doi:`10.48550/arXiv.0912.0902`
Examples
--------
>>> import numpy as np
>>> from scipy.stats import expectile
>>> a = [1, 4, 2, -1]
>>> expectile(a, alpha=0.5) == np.mean(a)
True
>>> expectile(a, alpha=0.2)
0.42857142857142855
>>> expectile(a, alpha=0.8)
2.5714285714285716
>>> weights = [1, 3, 1, 1]
r r z6The expectile level alpha must be in the range [0, 1].Nc �n �� t j t j �| k �z
� � | �z
z ��� � S )Nr� )rk r� r> )r ro r� r� s ���rr � first_orderz expectile.<locals>.first_order�% s4 �� ��z�"�&�!�q�&�E�!1�2�2�a�!�e�<�g�N�N�N�Nrt r� r� )r$ r% )
r� rk r r rz r� r� �aminr( �root)ro r� r� r� r$ r% r s ``` rr rg rg C% s� ���� �|
�q�y�y�E�A�I�I�� D�
�
�
� �
�1�
�
�A����/�'�1�7�3�3��
O� O� O� O� O� O� O�
��|�|�
�Z��7�
+�
+�
+��
�W�Q�Z�Z���
�Z��7�
+�
+�
+��
�W�Q�Z�Z�� �R�x�x�� � �k�b�R�
0�
0�
0�C� �8�Ort )r NNrs )r r� N)Nr N)Nr r r )Nr Tr� )r r r� )r r N)r Tr� )r TTr� )r r Tr� )r r� r{ )r r� )r� r� N)r� r� )r8 NNF)r8 NN)r r r� r� )r r r� r� )Nr) r� r� r, F)r� r� )r� r )r{ )Nr r� r{ )Nr� r rv r{ )TNT)r� r� N)Tr{ )r Tr� NNr{ r r� )r� )r Tr� Nr{ )Nr r N)Nr r )r� r{ r )r{ r )r� r� r{ r )r{ r r� )ri NrI )r� )r� )�r� r� r� r � collectionsr r �numpyrk r r r � numpy.libr �
numpy.testingr
�scipy.spatial.distancer �
scipy.ndimager
�scipy._lib._utilr r r r r �
scipy.specialr~ �scipyr � r r r� �_stats_mstats_commonr r r r �_statsr r r r � dataclassesr �
_hypotestsr �_stats_pythranr! � _resamplingr" �_axis_nan_policyr# r$ �
_binomtestr% r� �scipy._lib._bunchr& r' �scipy.optimizer( �__all__rs rw r r� r� r� r* r+ r, r� r- r r. r/ r0 r1 r2 r3 r' r* r4 r/ rQ r5 r6 rk r7 r� r� r8 r� r9 r� r: r; r< r� r= r� r� r� r> r� r? r@ rA r r
r rC rD rB rF �erfinvr r0 rE rA r= rG rJ rH rI rJ rK ra rg r rL rf r� r� r� r� r� r� rM rN rO rP rQ rR r4 rL rN rO rS r: ra rb rV rt rv r� r� rT r} r� r� r� r� r� rV r� rU r� r� r� r� r� r� rW r� r� r� r� r\ r[ r� r� r rY �Ks_2sampResultr r& r/ rZ rM rX r] rT r^ rZ r_ r` r` rg re rb rc rd r� r� r� r) r} r| ra rg r� rt rr �<module>r� s� ��& � � ���� � � � � � � � � � � +� +� +� +� +� +� +� +� � � � � $� $� $� $� $� $� $� $� $� $� "� "� "� "� "� "� +� +� +� +� +� +� (� (� (� (� (� (� '� '� '� '� '� '�N� N� N� N� N� N� N� N� N� N� N� N� N� N� � � � � � � � � � � � � � � � � � � +� +� +� +� +� +�1� 1� 1� 1� 1� 1� 1� 1� 1� 1� 1� 1�*� *� *� *� *� *� *� *� *� *� *� *� &� &� &� &� &� &� '� '� '� '� '� '� =� =� =� =� =� =� )� )� )� )� )� )�7� 7� 7� 7� 7� 7� 7� 7� F� F� F� F� F� F� /� /� /� /� /� /� � � � � � � &� &� &� &� &� &� � � ��. � � � � � �$� � �( � � �>� � �. '�&�';�(3�X�'>��D� D� �
��� �q�A��4�&��Y�K�A� A� A�CA� CA� CA�A� A�CA�L ��� �q�A��4�&��Y�K�A� A� A�Y2�D� Y2� Y2� Y2� Y2�A� A�Y2�x ��� �q�A��4�&��Y�K�A� A� A� ��t� x2� x2� x2� x2�A� A�x2�v �Z� �&7�
8�
8�
�P1� P1� P1� P1�f+� +� +�\/2� /2� /2� /2�d42� 42� 42� 42�n<� <� <� <�~;� ;� ;� ;�|.;� .;� .;� .;�b4$� 4$� 4$� 4$�x� � � � � �8 ���Q��� �� � �M(� M(� M(� � �M(�b &*� 9 � 9 � 9 � 9 � 9 �x� � � � ���K� � �1�� � �d� d� d�� �d�N ���K� � �1�� � �l(� l(� l(�� �l(�^ �� ,� )�*� *��
R1� R1� R1� R1�r� � �$ �� ,�.E�F�F��_=� _=� _=� _=�D �Z� 4�6M�N�N� �jA� jA� jA� jA�Z �:� 0�2I�J�J� �G>� G>� G>� G>�T ��,�4�@�@�@� � C1� C1� C1� C1� A�@�C1�V >H� �MM� MM� MM� MM�b(P� (P� (P�V`� `� `� `�F �*� .� N�P� P�� ;?� �KI� KI� KI� KI�\ �
�?� +�,� ,�
�
J+� J+� J+� J+�Z �
�?� +�,� ,�
�
I%� I%� I%� I%�`P � P � P �f>
� >
� >
� >
�B
.�
.�
.� )� )� )� 3� 3� 3� 3� EC� EC� EC� EC�P �q�[� VG� VG� VG� VG� VG�rO
� O
� O
� O
�dJ<� J<� J<� J<�^ !� .���s� 3� 3�c� 9�I�D�I�c�N�N� J�L� L� � ;F�).�[� [� [� [�|� � �, "#�2�9�C�$/�W� W� W� W�~ �*� .�0M�N�N��B4� B4� B4� B4�JS� S� S� S�lT� T� T� T�nC/� C/� C/� C/�L �� ,�.E�F�F��#� #� #�"F� F� F�
� h#� h#� h#� h#� h#�V *5� E'� E'� E'� E'� E'�P� � �, '��'>� AK� L� L� �$1� $1� $1�N �Z� 4�u�f�o�F�F� �&�&�';�(3�X�'>��D� D� �;6� ;6� ;6� ;6� ;6�'� ;6� ;6� ;6�| #.� K3� K3� K3� K3� K3�\o1� o1� o1� o1�d -8�%�n� n� n� n�bZ� Z� Z�z 7B�7B�a� a� a� a�Hy� y� y� y�~� � � � � � � �$4 � 4 � 4 � 4 �n� � �
� �k� A� A� A�2�
G�
G� � 1@�d�!"�u�4�Z� Z� Z� Z�z.� .� .�b*� *� *�Z0� 0� 0�f� � �> $�#�$5�%0�(�$;�d�V�E� E��76� 76� 76� 76� 76�/� 76� 76� 76�tI� I� I�0� 0� 0�
��*��a�*<��K� K� K�/:� '�r<� r<� r<�K� K�r<�j � � �4� � �2� � �
�
�
�� � � �*� .�0G�H�H�� 6A�!� !� !� !�D)!� )!� )!�X 8C�@K��\!� \!� \!� \!�~� � �0 � � �H .2�#'� #'� #'� #'�L � � � �" >B�<@�#.�H&� H&� H&� H&�V
�
�
� ��*��a�*<��!%�'� '� '�A:� A:� A:�'� '�A:�L ��� ���
� � �� � � �(1� 1� 1� $��$<�$;�=� =� �^+� ^+� ^+� ^+�B~/� ~/� ~/� ~/�B !� � �+�x�1H�"6�8H�!I�K� K� �"� "� "�0#� #� #�. ��6�8�$�$�h/� h/� h/� %�$�h/�V ��#� #� #�LG� G� G�T-� -� -�` ��6�8�$�$�f/� f/� f/� %�$�f/�R � � �: ��6�8�$�$�mJ� mJ� mJ� %�$�mJ�`*N� *N� *N�Z �� ,�.E�F�F�� ��.�A�6�6�6�K#� K#� K#� 7�6�K#�\ �
�?�,C�D�D�
� ��-�4�8�8�8�!,� s:� s:� s:� s:� 9�8�s:�l %�*�%>�%<�>� >� �>O� >O� >O�B !�j�!6�!8�:� :� � ?B� (�P(� P(� P(� P(�fN/� N/� N/� N/�lJF� JF� JF� JF�ZS<� S<� S<� S<�lT6� T6� T6� T6�n(� (� (�^ �*� .�0D�E�E�� L� L� L�F � � � �4 � � � �:P�$�;� P� P� P� P� P�f{�t� {� {� {� {� {� {� {rt