a aJ@s dZddlZddlZddlmZddlmZddlZddlmZm Z m Z ddl m Z ddl mZddlmZmZmZmZddlmZdd lmZd d lmZd d lmZd d lmZmZmZmZd dl m!Z!m"Z"m#Z#m$Z$ddl%m&Z&d dl'm(Z(gdZ)dJddZ*ddZ+ddZ,ddZ-ddZ.ddZ/dKdd Z0dLd!d"Z1ed#d$Z2dMd%d&Z3d'd(Z4dNd*d+Z5dOd,d-Z6dPd/d0Z7dQd1d2Z8dRd3d4Z9dSd5d6Z:dTd7d8Z;dd9d:d;Z<dUdd?Z>dWd@dAZ?edBdCZ@dXdDdEZAdFdGZBedHdIZCdYdKdLZDedMdIZEdZdNdOZFedPdIZGd[dQdRZHedSdIZIdTdUZJejKdVdWdXdYZLd\d\d]ZMd^d_ZNd]dadbZOedcddZPd^dgdhZQedidjZRd_dkdlZSedmdnZTd`dodpZUdqdrZVdadsdtZWdudvZXdwdxZYdbdydzZZdcd{d|Z[ddd}d~Z\deddZ]de^dde_ddZ`dfddZaddZbdejcddfddZddZeejKddeeddejcddfddZfeddZgdgddZhdhddZididdZjdjddZkeddIZlGdddemZnGdddemZoddZpddZqddddZrddddZsddZte&ddIZuGdddemZvGdddemZwGdddemZxddZydkddZzGdddemZ{eddZ|dlddZ}eddZ~dd„ZeddZdmddDŽZeddZdnddʄZGdd̄d̃ZdoddЄZdd҄ZeddԃZedd dfdfddքZdd؄ZddڄZdd܄ZddބZeddIZdpddZddZddZddZddZeddIZdqddZddZdrddZddZddZddZdsddZdtddZduddZddZeddIZdvddZd dddΐdddZdwddZdd Zed dIZdxd d Zdyd dZeddIZddZddZdzddZeZddZddZddZddZd{ddZd d!Zd|d#d$Zd%d&Zed'dIZd}d(d)Zed*dIZddd+d,Zed-dIZd.d/Zed0dIZd~d2d3Zdd5d6Zdd7d8Zdd9d:Zdd;d<Zd=d>Zed?d@ZdAdBZddCdDZddEdFZÐddddHdIZdS(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)arrayasarraymacdist) measurements)check_random_state MapWrapper rng_integersfloat_factorial)linalg) distributions) mstats_basic) _find_repeats linregress theilslopes siegelslopes) _kendall_dis_toint64_weightedrankedtau_local_correlations)make_dataclass)_all_partitions)G find_repeatsgmeanhmeanmodetmeantvartmintmaxtstdtsemmoment variationskewkurtosisdescribeskewtest kurtosistest normaltest jarque_beraitemfreqscoreatpercentilepercentileofscorecumfreqrelfreqobrientransformsemzmapzscoreiqrgstdmedian_absolute_deviationmedian_abs_deviation sigmacliptrimbothtrim1 trim_meanf_onewayF_onewayConstantInputWarningF_onewayBadInputSizesWarningPearsonRConstantInputWarning PearsonRNearConstantInputWarningpearsonr fisher_exactSpearmanRConstantInputWarning spearmanrpointbiserialr kendalltau weightedtaumultiscale_graphcorrrrr ttest_1samp ttest_indttest_ind_from_stats ttest_relkstestks_1sampks_2samp chisquarepower_divergence tiecorrectranksumskruskalfriedmanchisquarerankdatacombine_pvalueswasserstein_distanceenergy_distance brunnermunzelalexandergovern propagatec Csgd}||vr,tdddd|Dz@tjdd tt|}Wdn1s`0YWnPtyztjt| v}Wn&tyd}d }t d t Yn0Yn0|r|d krtd ||fS) Nr`raiseomitznan_policy must be one of {%s}z, css|]}d|VqdS)z'%s'N).0srdrda/Users/vegardjervell/Documents/master/model/venv/lib/python3.9/site-packages/scipy/stats/stats.py Sz _contains_nan..ignoreinvalidFrczYThe input array could not be properly checked for nan values. nan values will be ignored.rbzThe input contains nan values) ValueErrorjoinnperrstateisnansum TypeErrornansetravelwarningswarnRuntimeWarning)a nan_policyZpolicies contains_nanrdrdrg _contains_nanOs(2   r}cCsB|durt|}d}nt|}|}|jdkr:t|}||fSNrrorvrndimZ atleast_1d)rzaxisoutaxisrdrdrg _chk_asarrayms    rcCsl|dur"t|}t|}d}nt|}t|}|}|jdkrNt|}|jdkrbt|}|||fSr~r)rzbrrrdrdrg _chk2_asarray{s        rcCs@t|j}z ||=Wn"ty6t||jdYn0t|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)listshape IndexErrorro AxisErrorrtuple)rzrshprdrdrg_shape_with_dropped_axiss   rc Cst|t|}|dkr,d| |}|}n|}d||}g}t||D]L\}}|dkr`|}n,|dksp||krv|}ntd|d|d||qJt|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) rrrzshapes  and could not be broadcast together)lenziprmappendr) Zshape1Zshape2dshp1shp2rn1n2nrdrdrg_broadcast_shapess   rc CsRt||}t||}zt||}Wn*tyLtd|d|ddYn0|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 rrN)rrrm)rzrrrrrrdrdrg#_broadcast_shapes_with_dropped_axiss   rcCst|tjs"ttj||d}nJ|rbt|tjjrLttjj||d}qlttj||d}n t|}|durtj||d}t tj |||dS)aCompute the geometric mean along the specified axis. Return the geometric average of the array elements. That is: n-th root of (x1 * x2 * ... * xn) 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 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 ------- gmean : ndarray See `dtype` parameter above. See Also -------- numpy.mean : Arithmetic average numpy.average : Weighted average hmean : Harmonic mean Notes ----- The geometric average 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. Use masked arrays to ignore any non-finite values in the input or that arise in the calculations such as Not a Number and infinity because masked arrays automatically mask any non-finite values. 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 dtypeN)rweights) isinstancerondarraylogrr MaskedArrayr asanyarrayexpaverage)rzrrrZlog_ardrdrgrs:  rcCst|tjstj||d}t|dkrt|tjjrB||}n&|dur^|}|j d}n |j |}tj dd(|tj d|||dWdS1s0Ynt ddS) aCalculate the harmonic mean along the specified axis. That is: n / (1/x1 + 1/x2 + ... + 1/xn) 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. 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. Use masked arrays to ignore any non-finite values in the input or that arise in the calculations such as Not a Number and infinity. Examples -------- >>> from scipy.stats import hmean >>> hmean([1, 4]) 1.6000000000000001 >>> hmean([1, 2, 3, 4, 5, 6, 7]) 2.6997245179063363 rrNrjdivide?)rrzHHarmonic mean only defined if all elements greater than or equal to zero) rrorrallrrcountrvrrprrrm)rzrrsizerdrdrgr#s0    8r ModeResult)rrcCst||\}}|jdkr.ttgtgSt||\}}|r^|dkr^t|}t ||S|j t kr tj t |vr t t|}t|j}d||<tj||j d}tj|td}|D]>}||k} tj| |dd} t| |k||} t| |}| }qt| |Sdd} tt|j} t|| d || |dd |g}t|jd d }tj|jd d |j d}tj|jd d tjd} |D]}| ||\||<| |<qt|j}d||<t||| |S) a_Return an array of the modal (most common) value in the passed array. If there is more than one such value, only the smallest 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': returns nan * 'raise': throws an error * 'omit': performs the calculations ignoring nan values Returns ------- mode : ndarray Array of modal values. count : ndarray Array of counts for each mode. Examples -------- >>> a = np.array([[6, 8, 3, 0], ... [3, 2, 1, 7], ... [8, 1, 8, 4], ... [5, 3, 0, 5], ... [4, 7, 5, 9]]) >>> from scipy import stats >>> stats.mode(a) ModeResult(mode=array([[3, 1, 0, 0]]), count=array([[1, 1, 1, 1]])) To get mode of whole array, specify ``axis=None``: >>> stats.mode(a, axis=None) ModeResult(mode=array([3]), count=array([3])) rrcrrTkeepdimscSs&tj|dd\}}|||fS)NTZ return_counts)rouniqueargmaxmax)rzvalsZcntsrdrdrg_mode1Dszmode.._mode1DN)rrrrorr}rmasked_invalidrrrobjectrtrurvrrzerosintrrwheremaximumrangerZ transposeZndindexemptyint_reshape)rzrr{r|scoresZ testshapeZ oldmostfreqZ oldcountsscoretemplatecountsZ mostfrequentrZin_dimsZa_viewZindsmodesindZnewshaperdrdrgris>-        * rcCs~|\}}|\}}t|}|dur@|r4t||}n t||}|durf|rZt||}n t||}|dkrztd|S)aMask 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. Nrz#No array values within given limits)rrZ masked_lessZmasked_less_equalZmasked_greaterZmasked_greater_equalrrm)rzlimits inclusiveZ lower_limitZ upper_limitZ lower_includeZ upper_includeamrdrdrg_mask_to_limitss    rTTcCs8t|}|durt|dSt|||}|j|dS)aCompute 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 : float Trimmed mean. See Also -------- trim_mean : Returns mean after trimming a proportion from both tails. Examples -------- >>> from scipy import stats >>> x = np.arange(20) >>> stats.tmean(x) 9.5 >>> stats.tmean(x, (3,17)) 10.0 Nr)rromeanrrv)rzrrrrrdrdrgr s ) r cCsRt|}|t}|dur(|j||dSt|||}|jtjd}tj|||dS)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 -------- >>> from scipy import stats >>> x = np.arange(20) >>> stats.tvar(x) 35.0 >>> stats.tvar(x, (3,17)) 20.0 NddofrZ fill_value) rastypefloatvarrZfilledrortZnanvar)rzrrrrrZamnanrdrdrgr!%s-  r!TcCslt||\}}t||df|df}t||\}}|rF|dkrFt|}tj||j}|jdkrh|dS|S)akCompute 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 -------- >>> from scipy import stats >>> x = np.arange(20) >>> stats.tmin(x) 0 >>> stats.tmin(x, 13) 13 >>> stats.tmin(x, 13, inclusive=False) 14 NFrcrrd) rrr}rrminimumreducedatar)rz lowerlimitrrr{rr|resrdrdrgr"[s0   r"cCslt||\}}t|d|fd|f}t||\}}|rF|dkrFt|}tj||j}|jdkrh|dS|S)a]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 -------- >>> from scipy import stats >>> x = np.arange(20) >>> stats.tmax(x) 19 >>> stats.tmax(x, 13) 13 >>> stats.tmax(x, 13, inclusive=False) 12 NFrcrrd) rrr}rrrrrr)rzZ upperlimitrrr{rr|rrdrdrgr#s/   r#cCstt|||||S)aCompute 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 -------- >>> from scipy import stats >>> x = np.arange(20) >>> stats.tstd(x) 5.9160797830996161 >>> stats.tstd(x, (3,17)) 4.4721359549995796 )rosqrtr!)rzrrrrrdrdrgr$s-r$cCsdt|}|dur.|j|dt|jSt|||}ttjj|||d}|t| S)aCompute 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 -------- >>> from scipy import stats >>> x = np.arange(20) >>> stats.tsem(x) 1.3228756555322954 >>> stats.tsem(x, (3,17)) 1.1547005383792515 Nrr) rorrvstdrrrrrr)rzrrrrrsdrdrdrgr%s - r%c st\t|\}}|r@|dkr@tt|Sjdkrtj}|=j j dvrnj j nt j }t |r|n t|g|}t|dkr|t jSt j|t j|dSt |sjddfdd|D}t |St|Sd 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. 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 rcrfcrTrcsg|]}t|dqS)r)_momentreirzrrrdrg rizmoment..N)rr}rrrr&rrrrkindtyperofloat64isscalarrrtfullrrr) rzr&rr{r|Z moment_shaperZ out_shapeZmmntrdrrgr&As(;         r&rc Cs^t|t|dkr td|dks0|dkrt|j}||=|jjdvrT|jjntj }t |dkrz||dkrtdndS|dkrtj ||dStj ||dSn|g}|}|dkr|dr|dd}n|d}| |q|dur|j|d d n|}||}|d dkr|} n|d} |d dd D] } | d} | dr,| |9} q,t| |SdS) Nrz&All moment parameters must be integersrrrrTrr)roabsroundrmrrrrrrronesrrrcopy) rzr&rrrrZn_listZ current_nZ a_zero_meanrfrrdrdrgrs8       rcCsXt||\}}t||\}}|r@|dkr@t|}t|||S|j||d||S)aCompute the coefficient of variation. The coefficient of variation is the standard deviation divided by the mean. This function is equivalent to:: np.std(x, axis=axis, ddof=ddof) / np.mean(x) The default for ``ddof`` is 0, but many definitions of the coefficient of variation use the square root of the unbiased sample variance for the sample standard deviation, which corresponds to ``ddof=1``. Parameters ---------- a : array_like Input array. axis : int or None, optional Axis along which to calculate the coefficient of variation. 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 ddof : int, optional Delta degrees of freedom. Default is 0. Returns ------- variation : ndarray The calculated variation along the requested axis. References ---------- .. [1] Zwillinger, D. and Kokoska, S. (2000). CRC Standard Probability and Statistics Tables and Formulae. Chapman & Hall: New York. 2000. Examples -------- >>> from scipy.stats import variation >>> variation([1, 2, 3, 4, 5]) 0.47140452079103173 rcr)rr}rrrr'rr)rzrr{rr|rdrdrgr's 0  r'c Cs\t||\}}|j|}t||\}}|rJ|dkrJt|}t|||S|j|dd}t|d||d}t|d||d}t j ddF|t |j j ||dk} t | d ||d } Wd n1s0Y|sD| |dk@} | rDt | |}t | |}t |d ||d ||d } t | | | | jd krX| S| S)aCompute 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 0 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 rcTrrrrjrr?Nr@)rrr}rrrr(rrrorpfinfor resolutionsqueezeranyextractrplaceritem) rzrbiasr{rr|rm2Zm3zeror can_correctnvalrdrdrgr(s,J    4   & r(cCst||\}}t||\}}|rB|dkrBt|}t||||S|j|}|j|dd}t|d||d}t|d||d} t j ddF|t |j j ||dk} t | d | |d } Wd n1s0Y|s`| |d k@} | r`t | |}t | | } d |d|d |dd | |d d |dd } t | | | d| jd krt| } |r| d S| 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. If all values are equal, return -3 for Fisher's definition and 0 for Pearson's definition. 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. >>> 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. rcTrrrrjrrrNrrr@)rr}rrrr)rrrrorprrrrrrrrrr)rzrfisherrr{r|rrrZm4rrrrrdrdrgr)gs,P    4   < r)DescribeResult)nobsZminmaxrZvarianceskewnessr)c Cst||\}}t||\}}|rB|dkrBt|}t||||S|jdkrTtd|j|}t j ||dt j ||df}t j ||d}t j |||d} t|||d} t|||d} t|||| | | S)a\ 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 -------- >>> 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.])) rcrzThe input must not be empty.rrr)r)rr}rrrr*rrmrrominrrrr(r)r) rzrrrr{r|rmmmvskZkurtrdrdrgr*s@    r*cCsn|dkrtj|}n>|dkr,tj|}n(|dkrLdtjt|}ntd|jdkrf|d}||fS)z5Common code between all the normality-test functions.lessgreater two-sidedr4alternative must be 'less', 'greater' or 'two-sided'rrd)rnormcdfsfrorrmr)z alternativeprobrdrdrg_normtest_finish2s rSkewtestResult) statisticpvaluer c Cst||\}}t||\}}|rN|dkrN|dkr8tdt|}t||S|durdt|}d}t ||}|j |}|dkrtdt ||t |d|d d |d }d |d d |d|d|d |d|d|d|d}dt d |d} dt dt | } t d| d} t|dkd|}| t|| t || d d} tt| |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) rcr jnan-containing/masked inputs with nan_policy='omit' are currently not supported by one-sided alternatives.NrzFskewtest is not valid with less than 8 samples; %i samples were given.rr@rrFr r?)rr}rmrrrr+rorvr(rrmathrrrrr) rzrr{rr|b2ryZbeta2ZW2deltaalphaZrdrdrgr+Gs8E      &&(r+KurtosistestResultc Cs t||\}}t||\}}|rN|dkrN|dkr8tdt|}t||S|j|}|dkrptdt||dkrt dt|t ||dd }d |d |d }d ||d |d|d |d|d|d}||t |} d||d|d |d|dt d|d|d||d |d} dd| d| t d d| d } d d d| } d | t d | d} t | t | dkt jt d d| t | d}t | dkrd}t |t| |t d d| }tt||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 -------- >>> 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) rcr rrzJkurtosistest requires at least 5 observations; %i observations were given.z=kurtosistest only valid for n>=20 ... continuing anyway, n=%iF)rrrg8@rrrrrrg @r@g"@rgUUUUUU?rz\Test statistic not defined in some cases due to division by zero. Return nan in that case...)rr}rmrrrr,rrrwrxr)rorsignrrtpowerrrryr'r)rzrr{rr|rr"EZvarb2xZ sqrtbeta1AZterm1denomZterm2msgr&rdrdrgr,sHC    8<* r,NormaltestResultcCs~t||\}}t||\}}|r>|dkr>t|}t||St||\}}t||\}}||||}t|t j |dS)aTest 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 -------- >>> 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 rcr) rr}rrrr-r+r,r1rchi2r)rzrr{r|rf_kZk2rdrdrgr-#s:   r-Jarque_beraResultcCst|}|j}|dkr td|}||}d|t|dd|t|dd}d|t|dd|t|dd}|d|d|ddd}dtj|d}t ||S) aPerform 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. Returns ------- jb_value : float The test statistic. p : 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 -------- >>> 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 rz%At least one observation is required.rrrrr) rorrrmrrrrr2rr5)r-rmuZdiffxrr)Zjb_valueprdrdrgr.os* 00 r.zr`itemfreq` is deprecated and will be removed in a future version. Use instead `np.unique(..., return_counts=True)`)messagecCs,tj|dd\}}t|}t||gjS)a Return a 2-D array of item frequencies. Parameters ---------- a : (N,) array_like Input array. Returns ------- itemfreq : (K, 2) ndarray A 2-D frequency table. Column 1 contains sorted, unique values from `a`, column 2 contains their respective counts. Examples -------- >>> from scipy import stats >>> a = np.array([1, 1, 5, 0, 1, 2, 2, 0, 1, 4]) >>> stats.itemfreq(a) array([[ 0., 2.], [ 1., 4.], [ 2., 2.], [ 4., 1.], [ 5., 1.]]) >>> np.bincount(a) array([2, 4, 2, 0, 1, 1]) >>> stats.itemfreq(a/10.) array([[ 0. , 2. ], [ 0.1, 4. ], [ 0.2, 2. ], [ 0.4, 1. ], [ 0.5, 1. ]]) T)Zreturn_inverse)rorbincountrT)rzitemsinvfreqrdrdrgr/s' r/rdfractioncCst|}|jdkr@t|r$tjStjt|jtjtjdS|r`||d|k||dk@}tj||d}|durzd}t ||||S)aCalculate 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 -------- >>> from scipy import stats >>> a = np.arange(100) >>> stats.scoreatpercentile(a, 50) 49.5 rrrrN) rorrrrtrrrsort_compute_qth_percentile)rzperlimitinterpolation_methodrsorted_rdrdrgr0s=   r0c s^t|s*fdd|D}t|Sd|kr>dksHntdtdgj}|djd}t||krdkrtt|}n*d krtt |}nd krntd t|}||krt||d|<td}d } nRt||d |<|d} t| |||gt }dgj} d | <| |_| } tj j t||d| S)Ncsg|]}t|qSrd)rArrrDrErdrgr+sz+_compute_qth_percentile..rdz(percentile must be in the range [0, 100]Y@rlowerZhigherr?z@interpolation_method can only be 'fraction', 'lower' or 'higher'rrr)rorrrmslicerrrfloorceilrrraddrr) rErBrDrrZindexeridxrrZsumvaljZwshaperdrFrgrA)s<    rArankcCst|rtjSt|}t|}|dkr.dS|dkrvt||k}t||k}||||krddndd|}|S|dkrt||k|dS|dkrt||k|dS|d krt||kt||k|d }|Std d S) aCompute 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 of scores to which `score` is compared. score : int or float Score that is compared to the elements in `a`. 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 Returns ------- pcos : float Percentile-position of score (0-100) relative to `a`. See Also -------- numpy.percentile Examples -------- Three-quarters of the given values lie below a given score: >>> 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 rrHrPrgI@strictrGZweakr2z3kind can only be 'rank', 'strict', 'weak' or 'mean'N)rorqrtrrZ count_nonzerorm)rzrrrleftrightpctrdrdrgr1Ts2B     r1HistogramResult)rrbinsize extrapoints Fc st|}durV|jdkr"dn4|}|}||d|d}||||ftj|||d\}} tj|td}| d| d} tfd d |D} | dkr|rt d | t |d| | S) aCreate 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. Nrrrrr)Zbinsrrrrcs(g|] }d|ks |dkr|qSrZrd)rer defaultlimitsrdrgrsz_histogram..z)Points outside given histogram range = %s) rorvrrrZ histogramrrrrwrxrV) rznumbinsr\rZ printextrasZdata_minZdata_maxrfhistZ bin_edgesrWrXrdr[rg _histograms&/     r_ CumfreqResult)ZcumcountrrWrXc Cs8t||||d\}}}}tj|ddd}t||||S)aReturn 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 matplotlib.pyplot as plt >>> from numpy.random import default_rng >>> from scipy import stats >>> rng = 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() rrrr)r_rocumsumr`) rzr]defaultreallimitsrhlreZcumhistrdrdrgr2sHr2 RelfreqResult)Z frequencyrrWrXcCs>t|}t||||d\}}}}||jd}t||||S)aReturn 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 matplotlib.pyplot as plt >>> from numpy.random import default_rng >>> from scipy import stats >>> rng = 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() rar)rorr_rrg)rzr]rcrrdrerrfrdrdrgr3WsE r3c Gstttj}g}d}|D]}t|}t|}t|}||d}|} |d||d| |d|d} | |d} t | t| |krt d| | |j }q|r|ddD] } || j krtj |tdSqt |S) amCompute 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 ``*args`` 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 ---------- args : tuple of 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. Nrrr rz'Lack of convergence in obrientransform.rr)rorrrZepsrrrrrrrmrrrr) argsZTINYZarraysZsLastargrzrr7sqZsumsqtrarrrdrdrgr4s(3   (   r4cCsht||\}}t||\}}|r@|dkr@t|}t|||S|j|}tj|||dt |}|S)aGCompute 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: >>> 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 rcr) rr}rrrr5rrorr)rzrrr{r|rrfrdrdrgr5s3   r5cCs>|t|}|jdkr&tdgS|d|kjddSdS)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. rTrN)rorqrrrr-r#rdrdrg_isconst: s   rncCs:|t|}|jdkr(ttjgStj|ddSdS)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. rTrN)rorqrrrtrrmrdrdrg_quiet_nanmeanJ s rocCs<|t|}|jdkr(ttjgStj|d|dSdS)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. rT)rrN)rorqrrrtr)r-rr#rdrdrg _quiet_nanstdX s rpcCst|||||dS)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 -------- >>> 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 ]]) )rrr{)r6)rzrrr{rdrdrgr7f sDr7c Cst|}|jdkr t|jSt||\}}|r|dkr|durlt|}t||d}t |} qt t||}tj t|||d}t t ||} nR|j |dd}|j ||dd}|dur| d|k} nt|||kj|dd} d|| <|||} tj| t| | 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]) rrcNrTrr)rrrr)rorrrrr}rorvrprnapply_along_axisrrrr_firstrt broadcast_to) rcomparerrr{rzr|mnrZisconstrrdrdrgr6 s*2      r6c Csvt|}t|tjrtjntj}zTt8tdt t tj ||||dWdWS1sj0YWnt yB}zt | rtd|t|}| }|rtt|ds|st|d rtd|nFdt|krt||n,t tj |||d||dWYd}~SWYd}~n8d}~0typ}ztd |WYd}~n d}~00dS) 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. 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``. 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)``. >>> 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) errorrNzjInfinite value encountered. The geometric standard deviation is defined for strictly positive values only.rznNon positive value encountered. The geometric standard deviation is defined for strictly positive values only.z!Degrees of freedom <= 0 for slice)rzRInvalid array input. The inputs could not be safely coerced to any supported types)rorrrrrrwcatch_warnings simplefilterryrrisinfrrmrq less_equalZnanminstrrs)rzrrrwZa_nanZ a_nan_anyrfrdrdrgr9 sD`   >  @r9rr r)rawnormalKlinearc Cst|}|jstjSt|trZ|}|tvr>> 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~7use of scale='raw' is deprecated, use scale=1.0 insteadrcrz+quantile range must be two element sequencezrange must not contain NaNs)r interpolationrrrr)rrrortrr|rI_scale_conversionsrmformatrwrxVisibleDeprecationWarningr}Z nanpercentileZ percentilerrsrqrsortedsubtract) r-rrngscaler{rrZ scale_keyr|Zpercentile_funcrUoutrdrdrgr8 s:    r8cCsZt|}|r*|dkr tjS||}|jdkr:tjS||}tt||}|S)Nr`r)rorqrrtrmedianr)r-centerr{rqmedmadrdrdrg_mad_1d3 s   rc s:t|stdt|dt|trF|dkr8d}nt|dt|}|jsdurbt j St fddt |j D}|d krt j St |t j St||\}}|rڈdurt|||}nt t|||}nXdur||dd }t t ||}n,t ||d }t jt ||d }||S) a= 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: >>> 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.rgIRk?z is not a valid scale value.Nc3s|]\}}|kr|VqdSNrd)rerrrrdrgrh riz'median_abs_deviation..rdr)callablersreprrr|rIrmrrrortr enumeraterrr}rrvrrrrZ expand_dims) r-rrrr{Z nan_shaper|rrrdrrgr;I s6m     r;a To preserve the existing default behavior, use `scipy.stats.median_abs_deviation(..., scale=1/1.4826)`. The value 1.4826 is not numerically precise for scaling with a normal distribution. For a numerically precise value, use `scipy.stats.median_abs_deviation(..., scale='normal')`. r:)Zold_namenew_namer9g)Ǻ?cCsLt|tr(|dkr(tdtjd}t|ts:d|}t|||||dS)a[ 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.3.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 : int, optional The scaling factor applied to the MAD. The default scale (1.4826) ensures consistency with the standard deviation for normally distributed data. 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. 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_absolute_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: >>> from scipy import stats >>> x = stats.norm.rvs(size=100, scale=1, random_state=123456) >>> x.std() 0.9973906394005013 >>> stats.median_absolute_deviation(x) 1.2280762773108278 >>> x[0] = 345.6 >>> x.std() 34.42304872314415 >>> stats.median_absolute_deviation(x) 1.2340335571164334 Axis handling example: >>> x = np.array([[10, 7, 4], [3, 2, 1]]) >>> x array([[10, 7, 4], [ 3, 2, 1]]) >>> stats.median_absolute_deviation(x) array([5.1891, 3.7065, 2.2239]) >>> stats.median_absolute_deviation(x, axis=None) 2.9652 r~rrr)rrrr{)rr|rIrwrxrorr;)r-rrrr{rdrdrgr: s`    SigmaclipResult)ZclippedrIupperr)c Cspt|}d}|rd|}|}|j}|||}|||} |||k|| k@}||j}qt||| S)aPerform 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 -------- >>> 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)rorrvrrrr) rzlowhighcr$Zc_stdZc_meanrZ critlowerZ critupperrdrdrgr<c s6   r<cCst|}|jdkr|S|dur,|}d}|j|}t||}||}||krZtdt|||df|}tdg|j }t||||<|t |S)a$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 -------- >>> from scipy import stats >>> a = np.arange(20) >>> b = stats.trimboth(a, 0.1) >>> b.shape (16,) rNProportion too big.r) rorrrvrrrm partitionrJrrrzproportiontocutrrlowercutuppercutatmpslrdrdrgr= s'    r=rTcCst|}|dur|}d}|j|}|dkr4gS|dkrVd}|t||}n|dkrrt||}|}t|||df|}|||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 -------- >>> from scipy import stats >>> a = np.arange(20) >>> b = stats.trim1(a, 0.5, 'left') >>> b array([10, 11, 12, 13, 14, 16, 15, 17, 18, 19]) NrrrTrS)rorrvrrIrr)rzrtailrrrrrrdrdrgr> s$     r>cCst|}|jdkrtjS|dur.|}d}|j|}t||}||}||kr\tdt|||df|}t dg|j }t ||||<tj |t ||dS)aReturn 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 -------- >>> 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]) rNrrr) rorrrtrvrrrmrrJrrrrrdrdrgr? s/    r?F_onewayResultc@seZdZdZdddZdS)rAz Warning generated by `f_oneway` when an input is constant, e.g. each of the samples provided is a constant array. NcCs|dur d}|f|_dS)NzOEach of the input arrays is constant;the F statistic is not defined or infiniterhselfr0rdrdrg__init__n sz%F_onewayConstantInputWarning.__init__)N__name__ __module__ __qualname____doc__rrdrdrdrgrAh srAc@seZdZdZdS)rBzm Warning generated by `f_oneway` when an input has length 0, or if all the inputs have length 1. N)rrrrrdrdrdrgrBu srBcCshtjj|t|}|d|||dd}|dkrFtj}tj}ntj|tjd}|}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`. Nrrdr) rocore multiarraynormalize_axis_indexrrtrrr)rrrfrrdrdrg_create_f_oneway_nan_result} srcCst|tjd|jd|S)z>Return arr[..., 0:1, ...] where 0:1 is in the `axis` position.r)Zndmin)roZtake_along_axisrr)rlrrdrdrgrs srsrcs@t|dkr tdt|ddd|D}t|}tj|d}|j}tfdd|Dr~ttd t |jSt fd d|Drd }tt|t |jStjfd d|Dd}|j d}|rtt t ||kj d}|j d d} || 8}t|d|} t|d| } d} |D]$} | t| | d| j7} qB| | 8} | | }|d}||}| |}||}tjddd||}Wdn1s0Yt|||}t|r|rtj}tj}n|r6tj}d}n&tj||<d||<tj||<tj||<t||S)a6Perform 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 ----- F_onewayConstantInputWarning Raised if each of the input arrays is constant array. In this case the F statistic is either infinite or isn't defined, so ``np.inf`` or ``np.nan`` is returned. F_onewayBadInputSizesWarning 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 each group contains constant values, 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 -------- >>> 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]) rz&at least two inputs are required; got .cSsg|]}tj|tdqSrrorrrerirdrdrgrrizf_oneway..rc3s|]}|jdkVqdS)rNrrrrdrgrh$rizf_oneway..zat least one input has length 0c3s|]}|jdkVqdS)rNrrrrdrgrh*rizeall input arrays have length 1. f_oneway requires that at least one input has length greater than 1.cs$g|]}t||kjddqS)Trq)rsr)rerzrrdrgr9sTrqrrrjrrlNr)rrsro concatenaterrrwrxrBrrrArsr_square_of_sums_sum_of_squaresrpspecialZfdtrcrrtinfr)rrh num_groupsalldataZbignr0Zis_constZ all_constZall_same_constoffsetZ normalized_ssZsstotssbnrzZsswnZdfbnZdfwnZmsbZmswrrrdrrgr@ sf      "(    r@r{cst|}tdd|Dr8ttttjtjStfdd|D}tdd|D}ddt ||D}dt |}|t |}t ||}|||}|d} | d} d| d } | t d|d | d} | | d d | | d | d d | dd| d d| | d dd| | d d| } t t | }t j|t|d}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 ----- AlexanderGovernConstantInputWarning 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 sigificance 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. cSsg|]}||dkqS)rrrrdrdrgrriz#alexandergovern..cs&g|]}dkrt|nt|qS)rc)rrrrrrdrgrscSsg|]}t|qSrd)rorrrdrdrgrricSs(g|] \}}tj|ddt|qS)rr)rorr)rerilengthrdrdrgrsrr 0rrrr!riWrYr)!_alexandergovern_input_validationrorrwrx#AlexanderGovernConstantInputWarningAlexanderGovernResultrtrrsquarerrrrr2rr)r{rhlengthsZmeansZstandard_errorsZ inv_sq_serZvar_wZt_statsrrzrrrr.r8rdrrgr_vs6U    *"r_cCst|dkrtdt|dd|D}t|D]p\}}t|dkrRtd|jdkrdtdt|rztdt ||d \}}|r4|d kr4t |||<q4|S) Nrz2 or more inputs required, got cSsg|]}tj|tdqSrrrrdrdrgrriz5_alexandergovern_input_validation..rz+Input sample size must be greater than one.z%Input samples must be one-dimensionalzInput samples must be finite.rrc) rrsrrorrmrrzrr}rr)rhr{rrir|rdrdrgrs   rrc@seZdZdZdddZdS)rzAWarning generated by `alexandergovern` when an input is constant.NcCs|dur d}|f|_dS)Nz9An input array is constant; the statistic is not defined.rrrdrdrgrsz,AlexanderGovernConstantInputWarning.__init__)Nrrdrdrdrgrsrc@seZdZdZdddZdS)rCz:Warning generated by `pearsonr` when an input is constant.NcCs|dur d}|f|_dSNzGAn input array is constant; the correlation coefficient is not defined.rrrdrdrgr"sz%PearsonRConstantInputWarning.__init__)NrrdrdrdrgrCsrCc@seZdZdZdddZdS)rDzAWarning generated by `pearsonr` when an input is nearly constant.NcCs|dur d}|f|_dS)NzZAn input array is nearly constant; the computed correlation coefficient may be inaccurate.rrrdrdrgr,sz)PearsonRNearConstantInputWarning.__init__)NrrdrdrdrgrD)srDc Cst|}|t|krtd|dkr,tdt|}t|}||dks`||dkrxtttjtjfSt d|d|d}|dkr|t |d|dt |d|ddfS|j |d}|j |d}| ||}| ||}t |}t |} d} || t|ks<| | t|krHttt|||| } tt| dd } |dd} dt| | d dtt| } | | fS) aB Pearson correlation coefficient and p-value for testing non-correlation. The Pearson correlation coefficient [1]_ measures the linear relationship between two datasets. The calculation of the p-value relies on the assumption that each dataset is normally distributed. (See Kowalski [3]_ for a discussion of the effects of non-normality of the input on the distribution of the correlation coefficient.) 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. 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. Returns ------- r : float Pearson's correlation coefficient. p-value : float Two-tailed p-value. Warns ----- PearsonRConstantInputWarning Raised if an input is a constant array. The correlation coefficient is not defined in this case, so ``np.nan`` is returned. PearsonRNearConstantInputWarning 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 :math:`x` and :math:`m_y` is the mean of the vector :math:`y`. Under the assumption that :math:`x` and :math:`m_y` are drawn from independent normal distributions (so the population correlation coefficient is 0), the probability density function of the sample correlation coefficient :math:`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 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. 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 -------- >>> from scipy import stats >>> a = np.array([0, 0, 0, 1, 1, 1, 1]) >>> b = np.arange(7) >>> stats.pearsonr(a, b) (0.8660254037844386, 0.011724811003954649) >>> stats.pearsonr([1, 2, 3, 4, 5], [10, 9, 2.5, 6, 4]) (-0.7426106572325057, 0.1505558088534455) z"x and y must have the same length.rz$x and y must have length at least 2.rrrrgvIh%<=r )rrmrorrrwrxrCrtrr*rrrrrrDdotrrrZbtdtrr)r-r#rrZxmeanZymeanZxmZymZnormxmZnormym thresholdrabrrdrdrgrE3s6x      4    $  $rEcstjtj|tjd}|jdks(tdt|dkr>tdd|jddvs^d|jddvrhtj dfS|d dkr|d dkr|d |d |d |d }ntj }|d |d }|d |d }|d |d }fd d}|dkr |d ||||}n|dkrB |d ||||d |d }nt|dkrt |d|d||d |d |||| ||||} dt| t| dkr|dfS|d kr@ |d ||||}  |||||kr|| fS||||d} | | d||||}nh|d d||||}  d||||kr|| fS||||d} |  | ||||}n d} t| t|d}||fS)apPerform a Fisher exact test on a 2x2 contingency table. 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' * 'less': one-sided * 'greater': one-sided See the Notes for more details. Returns ------- oddsratio : float This is prior odds ratio and not a posterior estimate. p_value : float P-value, the probability of obtaining a distribution at least as extreme as the one that was actually observed, assuming that the null hypothesis is true. 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. 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 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:: >>> 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 >>> oddsr, p = fisher_exact(table, alternative='two-sided') >>> p 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``:: >>> oddsr, p = fisher_exact(table, alternative='greater') >>> p 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``:: >>> oddsr, p = fisher_exact(table, alternative='less') >>> p 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 one R uses. This SciPy implementation returns the (more common) "unconditional Maximum Likelihood Estimate", while R uses the "conditional Maximum Likelihood Estimate". 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 >>> oddsratio, pvalue = fisher_exact([[8, 2], [1, 5]]) >>> 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. rrrz*The input `table` must be of shape (2, 2).rz*All values in `table` must be nonnegative.rrrrrrZ)rr)rrc s|dkr}|}nd}}d}||dkr||dkrD||krD|}n ||d}|||||}|dkrv|d}n|d}|kr|||||krqnqq|kr|}q|}q|dkr|}|dkr2|dkr|||||kr|d8}qԈ|||||kr|d7}qn^|||||kr\|d7}q2|dkr|||||kr|d8}q\|S)z:Binary search for where to begin halves in two-sided test.rrrrr)pmf) rrrsideminvalmaxvalguessZpguessngepsilon hypergeomrZpexactrdrg binary_searchsF   (      z#fisher_exact..binary_searchr r r rgH.?rrIz?`alternative` should be one of {'two-sided', 'less', 'greater'})rrrorint64rrmrrrrtrrrrrrrr)tablerrZ oddsratiorrrrrZpmodeZplowerrZpupperr0rdrrgrFsT   ")  (  $ rFc@seZdZdZdddZdS)rGz;Warning generated by `spearmanr` when an input is constant.NcCs|dur d}|f|_dSrrrrdrdrgrsz&SpearmanRConstantInputWarning.__init__)NrrdrdrdrgrGsrGSpearmanrResult)Z correlationrcCs|dur|dkrtd|t||\}}|jdkr>td|durZ|jdkrtdn4t||\}}|dkrt||f}nt||f}|jd|}|j|}|dkrttj tj S|dkr6|dddfd|dddfk s|dddfd|dddfk rt t ttj tj Snn|dddfd|dddfk s|dddfd|dddfk rt t ttj tj St||\} }tj|td} | r"|d krtj||||d S|d kr"|jdks|dkrttj tj St|j|d } tt||} tj| |d } |d} tjdd4| t| | dd| d}Wdn1s0Yt| ||\}}| jdkrt| d|dStj | | ddf<tj | dd| f<t| |SdS)aCalculate 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. Unlike the Pearson correlation, the Spearman correlation does not assume that both datasets are normally distributed. 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. The p-values are not entirely reliable but are probably reasonable for datasets larger than 500 or so. 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 ------- correlation : 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 hypotheisis is that two sets of data are uncorrelated. See `alternative` above for alternative hypotheses. `pvalue` has the same shape as `correlation`. References ---------- .. [1] Zwillinger, D. and Kokoska, S. (2000). CRC Standard Probability and Statistics Tables and Formulae. Chapman & Hall: New York. 2000. Section 14.7 Examples -------- >>> from scipy import stats >>> stats.spearmanr([1,2,3,4,5], [5,6,7,8,7]) SpearmanrResult(correlation=0.82078..., pvalue=0.08858...) >>> rng = np.random.default_rng() >>> x2n = rng.standard_normal((100, 2)) >>> y2n = rng.standard_normal((100, 2)) >>> stats.spearmanr(x2n) SpearmanrResult(correlation=-0.07960396039603959, pvalue=0.4311168705769747) >>> stats.spearmanr(x2n[:,0], x2n[:,1]) SpearmanrResult(correlation=-0.07960396039603959, pvalue=0.4311168705769747) >>> rho, pval = stats.spearmanr(x2n, y2n) >>> rho 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. ]]) >>> pval 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. ]]) >>> rho, pval = stats.spearmanr(x2n.T, y2n.T, axis=1) >>> rho 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. ]]) >>> stats.spearmanr(x2n, y2n, axis=None) SpearmanrResult(correlation=0.044981624540613524, pvalue=0.5270803651336189) >>> stats.spearmanr(x2n.ravel(), y2n.ravel()) SpearmanrResult(correlation=0.044981624540613524, pvalue=0.5270803651336189) >>> rng = np.random.default_rng() >>> xint = rng.integers(10, size=(100, 2)) >>> stats.spearmanr(xint) SpearmanrResult(correlation=0.09800224850707953, pvalue=0.3320271757932076) Nrzqspearmanr only handles 1-D or 2-D arrays, supplied axis argument {}, please use only values 0, 1 or None for axisrz(spearmanr only handles 1-D or 2-D arraysz1`spearmanr` needs at least 2 variables to comparerrrc)rr{rr`r)Zrowvarrjrrrr)rmrrrroZ column_stackZ row_stackrrrtrrwrxrGr}rboolrrHrqrrrrZZcorrcoefrprclip _ttest_finish)rzrrr{rZaxisoutr3Zn_varsZn_obsZa_contains_nanZvariable_has_nanZa_rankedrsZdofrkrrdrdrgrHs^m     T T    D rHPointbiserialrResultcCst||\}}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 uses a shortcut formula but produces the same result as `pearsonr`. Parameters ---------- x : array_like of bools Input array. y : array_like Input array. Returns ------- correlation : float R value. pvalue : float 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 -------- >>> 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. ]]) )rEr)r-r#ZrpbrrdrdrgrIsRrIKendalltauResultautorcCsNt|}t|}|j|jkrBtd|jd|jn|jrN|js\ttjtjSt||\}}t||\}} |p~|} |dks| dkrd}| r|dkrttjtjS| r|dkrt |}t |}|dkrt j |||ddStd|d urt d d d } |j} t|} || || }}tjd|d d |d dkfjtjd}tj|dd} || || }}tjd|d d |d dkfjtjd}t||}tjd|d d |d dk|d d |d dkBdf}tt|djddd}||d d}| |\}}}| |\}}}| | d d}||ks^||krlttjtjS||||d|}|dkr|t||t||}nR|dkrttt|tt|}d|| d|d |}ntd|dtdtd|}|dkr8|dks0|dkr8td|dkr~|dkrz|dkrz| dkstt|||d krzd}nd }|dkr|dkr|dkrt | t|||}n|d kr4| | d}|d| d!||d"d|||||d#|| d}tt|t|td}ntd$|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 Unused (deprecated). 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'. Returns ------- correlation : float The tau statistic. pvalue : float The two-sided 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] >>> tau, p_value = stats.kendalltau(x1, x2) >>> tau -0.47140452079103173 >>> p_value 0.2827454599327748 zBAll inputs to `kendalltau` must be of the same size, found x-size z and y-size rcr`rT)methodZuse_tiesz/Only variant 'b' is supported for masked arraysNz"initial_lexsort" is gone!cSsft|jddd}||dk}||dd||d|d||dd|dfS)NrFrrrrr)ror:rrr)Zrankscntrdrdrgcount_rank_ties  z"kendalltau..count_rank_tierrr mergesortrrrFrrrz&Unknown variant of the method chosen: z. variant must be 'b' or 'c'.rrexactz(Ties found, exact method cannot be used.rrZ asymptoticrrzUnknown method z1 specified. Use 'auto', 'exact' or 'asymptotic'.) rorrvrrmrrtr}rrrrJrwrxargsortr_rbintprdiffnonzerorrrrrrrurZ_kendall_p_exactrerfcr)r-r#Zinitial_lexsortr{rvariantcnxnpxcnynpyr|rrpermdisobsrZntieZxtieZx0x1ZytieZy0y1ZtotZ con_minus_distauZ minclassesrrrrdrdrgrJ s`          ,, < "     rJWeightedTauResultcCst|}t|}|j|jkr>> from scipy import stats >>> x = [12, 2, 1, 12, 2] >>> y = [1, 4, 7, 1, 0] >>> tau, p_value = stats.weightedtau(x, y) >>> tau -0.56694968153682723 >>> p_value nan >>> tau, p_value = stats.weightedtau(x, y, additive=False) >>> tau -0.62205716951801038 NaNs are considered the smallest possible score: >>> x = [12, 2, 1, 12, 2] >>> y = [1, 4, 7, 1, np.nan] >>> tau, _ = stats.weightedtau(x, y) >>> tau -0.56694968153682723 This is exactly Kendall's tau: >>> x = [12, 2, 1, 12, 2] >>> y = [1, 4, 7, 1, 0] >>> tau, _ = stats.weightedtau(x, y, weigher=lambda x: 1) >>> tau -0.47140452079103173 >>> x = [12, 2, 1, 12, 2] >>> y = [1, 4, 7, 1, 0] >>> stats.weightedtau(x, y, rank=None) WeightedTauResult(correlation=-0.4157652301037516, pvalue=nan) >>> stats.weightedtau(y, x, rank=None) WeightedTauResult(correlation=-0.7181341329699028, pvalue=nan) zSAll inputs to `weightedtau` must be of the same size, found x-size %s and y-size %sTNrFrzVAll inputs to `weightedtau` must be of the same size, found x-size %s and rank-size %s)rorrvrrmrrtrqrrrrrint32Zfloat32rraranger)r-r#rPZweigherZadditiverdrdrgrKsV          rKc@s eZdZdZddZddZdS) _ParallelPz.Helper function to calculate parallel p-value.cCs||_||_||_dSrr-r# random_states)rr-r#r rdrdrgrsz_ParallelP.__init__cCsB|j||jjd}|j|dd|f}t|j|d}|Sr~)r  permutationr#r _mgc_statr-)rindexorderZpermyZ perm_statrdrdrg__call__sz_ParallelP.__call__N)rrrrrrrdrdrdrgrsrrrc stfddt|D}t|||d}t|(}tt||t|} Wdn1sb0Y| |k|} | dkrd|} | | fS)aHelper 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 `). 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 s&g|]}tjtddtjdqS)lr)rr)rorandomZ RandomStater Zuint32)rer3 random_staterdrgrs z_perm_test..rNrr)r rrr rorrrr) r-r#statrepsworkersrr Z parallelpZ mapwrapper null_distrrdrrg _perm_tests(  6rcCs t||Srr)r-rdrdrg_euclidean_distsr MGCResult)rrmgc_dictcCs&t|tjrt|tjs td|jdkr>|ddtjf}n|jdkrXtd|j|jdkrv|ddtjf}n|jdkrtd|j|j\}}|j\} } t|ddt|ddt t |d kst t |d krtd || kr|| krd }ntd |d ks"| d kr*td| tj }| tj }t |s^|dur^tdt|trt|d kr~tdn|dkrd} t| t|r|durtdt||\}}|dur||}||}t||\} } | d}| d}t||| |||d\}}|||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 ``). 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 overriden 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 ------- stat : float The sample MGC test statistic within `[-1, 1]`. pvalue : float The p-value obtained via permutation. mgc_dict : dict Contains additional useful additional returns containing the following keys: - mgc_map : ndarray A 2D representation of the latent geometry of the relationship. 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 -------- >>> from scipy.stats import multiscale_graphcorr >>> x = np.arange(100) >>> y = x >>> stat, pvalue, _ = multiscale_graphcorr(x, y, workers=-1) >>> '%.1f, %.3f' % (stat, pvalue) '1.0, 0.001' Alternatively, >>> x = np.arange(100) >>> y = x >>> mgc = multiscale_graphcorr(x, y) >>> '%.1f, %.3f' % (mgc.stat, mgc.pvalue) '1.0, 0.001' To run an unpaired two-sample test, >>> x = np.arange(100) >>> y = np.arange(79) >>> mgc = multiscale_graphcorr(x, y) >>> '%.3f, %.2f' % (mgc.stat, mgc.pvalue) # doctest: +SKIP '0.033, 0.02' or, if shape of the inputs are the same, >>> x = np.arange(100) >>> y = x >>> mgc = multiscale_graphcorr(x, y, is_twosamp=True) >>> '%.3f, %.1f' % (mgc.stat, mgc.pvalue) # doctest: +SKIP '-0.008, 1.0' zx and y must be ndarraysrNrz(Expected a 2-D array `x`, found shape {}z(Expected a 2-D array `y`, found shape {}rbrrzInputs contain infinitiesTzZShape mismatch, x and y must have shape [n, p] and [n, q] or have shape [n, p] and [m, p].rz;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.rzThe 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)rrr)Zmgc_maprr)rrorrmrZnewaxisrrr}rrrzrrrrrwrxry_two_sample_transformr rr)r-r#Zcompute_distancerrZ is_twosamprnxZpxnypyr0r stat_dictrrrrrrdrdrgrLslM        (           rLc Cs|t||dd}|j\}}|dks(|dkrF||d|d}||}n$t|d}t||}t||\}}||d} || fS)asHelper function that calculates the MGC stat. See above for use. Parameters ---------- x, y : ndarray `x` and `y` 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. Zmgc)Z global_corrr)rr)rrr_threshold_mgc_map_smooth_mgc_map) ZdistxZdistyrrrrr samp_size sig_connectr rdrdrgr s    r c Cs|j\}}dd|}||ddd}tj|||dd}t|||d|d}||k}t|dkrt|\}}tj |dd \}}t |dd d} || k}nt 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{Gz?rrr rrTrNF) rrbetaZppfrrorrr labelrrr) rr#rrZper_sigrr$r3Z label_countsZ max_labelrdrdrgr!1s   r!c Cs|j\}}||d|d}||g}tj|dkrt|tdt||t||krt||}t||k|@}||kr|}|\}} ||| } t| |}t| |} |d| dg}||fS)aJFinds 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. rrr%) rrorrrrrLrrr) r$rrrrrZmax_corrZmax_corr_indexr4reZ one_d_indicesrdrdrgr"^s (  r"cCsT|jd}|jd}tj||gdd}tjt|t|gdddd}||fS)aHelper 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)`. rrrr)rrorrrr)urrrr-r#rdrdrgrs   &rTtest_1sampResultc Cst||\}}t||\}}|rP|dkrP|dkr8tdt|}t|||S|j|}|d}t |||}tj ||dd} t | |} tj dddt || } Wdn1s0Yt|| |\} } t| | S) a Calculate the T-test for the mean of ONE group of scores. This is a two-sided 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 it must have the same shape as `a` excluding the axis dimension. 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' * 'less': one-sided * 'greater': one-sided .. versionadded:: 1.6.0 Returns ------- statistic : float or array t-statistic. pvalue : float or array Two-sided p-value. Examples -------- >>> from scipy import stats >>> rng = np.random.default_rng() >>> rvs = stats.norm.rvs(loc=5, scale=10, size=(50, 2), random_state=rng) Test if mean of random sample is equal to true mean, and different mean. We reject the null hypothesis in the second case and don't reject it in the first case. >>> stats.ttest_1samp(rvs, 5.0) Ttest_1sampResult(statistic=array([-2.09794637, -1.75977004]), pvalue=array([0.04108952, 0.08468867])) >>> stats.ttest_1samp(rvs, 0.0) Ttest_1sampResult(statistic=array([1.64495065, 1.62095307]), pvalue=array([0.10638103, 0.11144602])) Examples using axis and non-scalar dimension for population mean. >>> result = stats.ttest_1samp(rvs, [5.0, 0.0]) >>> result.statistic array([-2.09794637, 1.62095307]) >>> result.pvalue array([0.04108952, 0.11144602]) >>> result = stats.ttest_1samp(rvs.T, [5.0, 0.0], axis=1) >>> result.statistic array([-2.09794637, 1.62095307]) >>> result.pvalue array([0.04108952, 0.11144602]) >>> result = stats.ttest_1samp(rvs, [[5.0], [0.0]]) >>> result.statistic array([[-2.09794637, -1.75977004], [ 1.64495065, 1.62095307]]) >>> result.pvalue array([[0.04108952, 0.08468867], [0.10638103, 0.11144602]]) rcr rrrrjrN)rr}rmrrrrMrrorrrrprrr)) rzZpopmeanrr{rr|rdfrrr/rkrrdrdrgrMs P   *rMcCst|dkrtj||}nB|dkr0tj||}n*|dkrRdtjt||}ntd|jdkrl|d}||fS)z+Common code between all 3 t-test functions.r r r rr rrd)rrkrrrorrmr)r*rkrrrdrdrgrs rcCsZ||}tjdddt||}Wdn1s80Yt|||\}}||fS)Nrjr)rorprr)mean1mean2r/r*rrrkrrdrdrg_ttest_ind_from_stats/s *r-cCs||}||}tjddd<||d|d|d|d|d}Wdn1s`0Ytt|d|}t||}||fS)Nrjrrr)rorprrqr)v1rv2rZvn1Zvn2r*r/rdrdrg_unequal_var_ttest_denom9sJr0cCsJ||d}|d||d||}t|d|d|}||fS)Nrrr)ror)r.rr/rr*Zsvarr/rdrdrg_equal_var_ttest_denomFs r1Ttest_indResultc Cszt|}t|}t|}t|}|rHt|d||d|\}} nt|d||d|\}} t||| ||} t| S)a T-test for means of two independent samples from descriptive statistics. This is a two-sided 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 standard deviation(s) of sample 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 standard deviations(s) of sample 2. 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' * 'less': one-sided * 'greater': one-sided .. 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 ----- .. versionadded:: 0.16.0 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:: 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): >>> 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.16 Sample 2 200 45 0.225 0.174375 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.16), nobs1=150, ... mean2=0.225, std2=np.sqrt(0.17437), nobs2=200) Ttest_indResult(statistic=-0.564327545549774, pvalue=0.5728947691244874) 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)rorr1r0r-r2) r+Zstd1Znobs1r,Zstd2Znobs2 equal_varrr*r/rrdrdrgrOPsn     rOcCsHt|||}t|dkr&tj}tj}ntj|tjd}|}|||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 -------- >>> 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) rr)rrrortrr)rzrrZnamedtuple_typerrkr8rdrdrg _ttest_nanss!  r4c  Csd|krdksntdt|||\}}}t||\} } t||\} } | pR| } | dksd| dkrhd}| r|dkr|s|dks|dkrtdt|}t|}t||||S|jdks|jdkrt|||t S|dur@|dkr@|dkrtd|dkst |r&t ||kr&td t ||||||||d }n|j|}|j|}|dkrt j||d d }t j||d d }t ||}t ||}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 two-sided 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' * 'less': one-sided * 'greater': one-sided .. 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 two-tailed 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. 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 reccomended if the underlying distribution is long-tailed or contaminated with outliers [4]_. 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] http://en.wikipedia.org/wiki/Resampling_%28statistics%29 .. [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 -------- >>> 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.0052) 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) rr z/Trimming percentage should be 0 <= `trim` < .5.rcr znan-containing/masked inputs with nan_policy='omit' are currently not supported by permutation tests, one-sided asymptotic tests, or trimmed tests.Nz7Permutations are currently not supported with trimming.z,Permutations must be a non-negative integer.) permutationsrr3r{rrrr)rmrr}rrrrNrr4r2roisfiniter_permutation_ttestrrr_ttest_trim_var_mean_lenr1r0r-)rzrrr3r{r5rrtrimcnanpacnbnpbr|rrrr.r/m1rr*r/rdrdrgrNsXS        rNcCsTtj||d}|j|}t||}t|||}|d|8}t|||d}|||fS)zCVariance, mean, and length of winsorized input along specified axisrr)ror@rr_calculate_winsorized_variancer?)rzr9rrgrrrdrdrgr8s    r8cCs|dkrtj|d|dSt||d}tjt|dd}|d|gf|dd|f<|d| dgf|d| df<ttj|d|ddd}tj||<|S) z;Calculates g-times winsorized variance along specified axisrrrrr.Nr)rormoveaxisrrqrrt)rzr@rZa_winZ nans_indicesZvar_winrdrdrgr?s " r?csZfdd|D}tjdd|Djfdd|D}tj|dd}t|d}|S)z3Concatenate arrays along an axis with broadcasting.csg|]}t|dqSr)roswapaxesrer-rrdrgrCriz*_broadcast_concatenate..cSsg|] }|dqS)).rrdrDrdrdrgrErics$g|]}t||jdfqSrB)rortrrDrrdrgrGrirr)ro broadcastrrrC)xsrrrd)rrrg_broadcast_concatenate@s rGcst|dkr|j|}|j|t|}||krZtfddt|Dj}n$|}tddt ||Dj}| |d}|d|f}| d|}t |dd}||fS)zAAll partitions of data into sets of given lengths, ignoring orderrcsg|]}qSrd)r rrrrdrgr\sz$_data_partitions..cSsg|]}t|qSrd)ror)rerrdrdrgr`sr.r) r rrrcombrorrr;rrCrA)rr5size_arrZn_maxindicesrdrHrg_data_partitionsOs$         rLc Cs|j|}|j|}tj||d}tj||d}tj||dd}tj||dd} |sht||| |d} nt||| |d} ||| S)z4Calculate the t statistic along the given dimension.rrr)rrorrr0r1) rzrr3rnanbZavg_aZavg_bZvar_aZvar_br/rdrdrg _calc_t_statjs  rOcCst|}t||||d}|j|} t||f|d} t| |d} t| || |d\} }| dd| f}| d| df}t|||} tjtjddd} | || |}|j d d|}|d krt | rt |d krt tj}ntj|t |<||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 two-tailed p-value. rr)rJr.NcSs|t| k|t|kBSr)rorrmrdrdrgriz$_permutation_ttest..r r r rr`)r rOrrGrorArLr{Z greater_equalrrrqrrrrt)rzrr5rr3r{rrZt_stat_observedrMmatZmat_permZt_statruZcmpspvaluesrdrdrgr7{s,)   r7cCs8z|j|}Wn$ty2t||j|dYn0|Sr)rrrorr)rzrr0rrdrdrg_get_lens  rTTtest_relResultcCst|||\}}}t||\}}t||\}}|p4|} |dksF|dkrJd}| r|dkr|dkrftdt|}t|}tt|t|} tj|| dd} tj|| dd} t | | |St ||d} t ||d}| |krtd| d krt |||t S|j |}|d }||tj}tj||d d }t||}t||}tjd d d t||}Wdn1s|0Yt|||\}}t ||S)a Calculate the t-test on TWO RELATED samples of scores, a and b. This is a two-sided test for the null hypothesis that 2 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' * 'less': one-sided * 'greater': one-sided .. versionadded:: 1.6.0 Returns ------- statistic : float or array t-statistic. pvalue : float or array Two-sided p-value. 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. References ---------- https://en.wikipedia.org/wiki/T-test#Dependent_t-test_for_paired_samples Examples -------- >>> 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) Ttest_relResult(statistic=-0.4549717054410304, pvalue=0.6493274702088672) >>> 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) Ttest_relResult(statistic=-5.879467544540889, pvalue=7.540777129099917e-09) rcr rT)maskrzfirst argumentzsecond argumentzunequal length arraysrrrrjrN)rr}rmrrZmask_orZgetmaskrrrPrTr4rUrrrorrrrrprr)rzrrr{rr:r;r<r=r|rZaaZbbrMrNrr*rrdmr/rkrrdrdrgrPs>E       ,rPgrgUUUUUU?)pearsonzlog-likelihoodz freeman-tukeyzmod-log-likelihoodZneymanz cressie-readcCsTt|dr6|j|d}t|tjrP|jdkrPt|}n|durF|j}n |j|}|S)zCount the number of non-masked elements of an array. This function behaves like `np.ma.count`, but is much faster for ndarrays. rrrN) hasattrrrrorrrrr)rzrnumrdrdrg_countLs    r[cCs>tj|r.tjjt||t|j|dStj||ddS)N)rVT)Zsubok)rorZ isMaskedArrayZ masked_arrayrtrV)rzrrdrdrg_m_broadcast_to`s   r\Power_divergenceResultcCs,t|trD|tvr:tttdd}td||t|}n |durPd}t |}| tj }|dur,t |}t |j |j }t||}t||}d}tjddN|j|d} |j|d} t| | t| | } | |k} Wdn1s0Y| rhd |d | } t| n= 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): >>> 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])) rrz8invalid string for lambda_: {0!r}. Valid strings are {1}Ng:0yE>rjrkrzFor 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: Trqrrrr )rr|_power_div_lambda_namesrrkeysrmrrorrrrrr\rprrrrrrrZxlogyr[rrr2rr])f_obsf_exprrlambda_namesZ f_obs_floatZbshapeZrtolZ f_obs_sumZ f_exp_sumZ relative_diffZ diff_gt_tolr0ZtermsrZnum_obsr8rdrdrgrUks^            , .     rUcCst||||ddS)aCalculate 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. >>> 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])) rX)rarrrb)rU)r`rarrrdrdrgrTHs| rT KstestResultcCs$t|}td|d||S)zComputes D+ as used in the Kolmogorov-Smirnov test. Parameters ---------- cdfvals: array_like Sorted array of CDF values between 0 and 1 Returns ------- Maximum distance of the CDF values below Uniform(0, 1) rrrrorrcdfvalsrrdrdrg_compute_dpluss rhcCs t|}|td||S)zComputes D- as used in the Kolmogorov-Smirnov test. Parameters ---------- cdfvals: array_like Sorted array of CDF values between 0 and 1 Returns ------- Maximum distance of the CDF values above Uniform(0, 1) rrerfrdrdrg_compute_dminuss ric Cs<dddd|d|}|dvr0td|tj|rD|}t|}t|}||g|R}|dkrt |}t |t j ||S|dkrt|}t |t j ||St |}t|}t||g} |dkrd }|d krt j | |} n4|d krt j | t|} nd t j | |} t| 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. mode : {'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 ------- statistic : float KS test statistic, either D, D+ or D- (depending on the value of 'alternative') pvalue : float One-tailed or two-tailed p-value. 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 -------- >>> from scipy import stats >>> rng = np.random.default_rng() >>> x = np.linspace(-15, 15, 9) >>> stats.ks_1samp(x, stats.norm.cdf) (0.44435602715924361, 0.038850142705171065) >>> stats.ks_1samp(stats.norm.rvs(size=100, random_state=rng), ... stats.norm.cdf) KstestResult(statistic=0.165471391799..., pvalue=0.007331283245...) *Test against one-sided alternative hypothesis* Shift distribution to larger values, so that `` CDF(x) < norm.cdf(x)``: >>> x = stats.norm.rvs(loc=0.2, size=100, random_state=rng) >>> stats.ks_1samp(x, stats.norm.cdf, alternative='less') KstestResult(statistic=0.100203351482..., pvalue=0.125544644447...) Reject null hypothesis in favor of alternative hypothesis: less >>> stats.ks_1samp(x, stats.norm.cdf, alternative='greater') KstestResult(statistic=0.018749806388..., pvalue=0.920581859791...) Reject null hypothesis in favor of alternative hypothesis: greater >>> stats.ks_1samp(x, stats.norm.cdf) KstestResult(statistic=0.100203351482..., pvalue=0.250616879765...) Don't reject null hypothesis in favor of alternative hypothesis: two-sided *Testing t distributed random variables against normal distribution* With 100 degrees of freedom the t distribution looks close to the normal distribution, and the K-S test does not reject the hypothesis that the sample came from the normal distribution: >>> stats.ks_1samp(stats.t.rvs(100,size=100, random_state=rng), ... stats.norm.cdf) KstestResult(statistic=0.064273776544..., pvalue=0.778737758305...) With 3 degrees of freedom the t distribution looks sufficiently different from the normal distribution, that we can reject the hypothesis that the sample came from the normal distribution at the 10% level: >>> stats.ks_1samp(stats.t.rvs(3,size=100, random_state=rng), ... stats.norm.cdf) KstestResult(statistic=0.128678487493..., pvalue=0.066569081515...) r r r rkr@rerr r r Unexpected alternative %srrasymprr)getrIrmror is_masked compressedrr@rhrdrZksonerrirkstwoZ kstwobignrr) r-rrhrrNrgZDplusZDminusDrrdrdrgrRs8q      rRcCs||kr||}}||}||}dttt|||d}}||}td|d|d} tj} tj| | d} d| ||<d} td|dD]} ||}}ttt|| ||dd}t||}ttt|| |||d}||krdSt | ||||| d||<||}||krZd| ||||||<| ||d}t |\}}|dkr|d8}t | | } | |7} q| ||d}td|dD]D} || || }t |\}}|dkrt || }| |7} qt || S)a Count the proportion of paths that stay strictly inside two diagonal lines. 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 proportion of paths that stay inside the two lines. Count the integer lattice paths from (0, 0) to (m, n) which satisfy |x/m - y/n| < h / lcm(m, n). 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. rrrrii i) rrrorLrrrrrKrbr!frexpldexp)rrr@rdmgrZminjZmaxjZcurlenZlenArr.ZexpntrZlastminjZlastlenvalr3Zvalexptrdrdrg_compute_prob_inside_methodsH   "   $ $ &    rxcCsvd}tt||}|dkrnd}t|D],}|||||||||d}q*|d|}|d8}qd|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. rrrrr)rrorKr)rrdPr4p1rOrdrdrg_compute_prob_outside_squares *  r{c s||kr||}}|||||}fddt|D}|dkrjtt|||St|}d|d<td|D]}tt||||}t|stt|D]>} tt|||| || || } || || 8}q|||<t|stqd} t|D]R}tt|||||||} ||| } t| sjt| | 7} q"t| S)aCount 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. Raises ------ FloatingPointError: Raised if the intermediate computation goes outside the range of a float. 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. cs$g|]}|dqSrrd)rerOrdrvrrdrgrIriz/_count_paths_outside_method..rr)rrorrbinomrr6FloatingPointError) rrr@rdZlxjZxjBrOZBjrbin num_pathsZtermrdr|rg_count_paths_outside_methods8/    *  &   rc CsL|||}tt||}|d|}|dkr= 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. If the KS statistic is small or the p-value is high, then we cannot reject the null hypothesis in favor of the alternative. If the mode is 'auto', the computation is exact if the sample sizes are less than 10000. For larger sizes, the computation uses the Kolmogorov-Smirnov distributions to compute an approximate value. 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 -------- >>> from scipy import stats >>> rng = np.random.default_rng() >>> n1 = 200 # size of first sample >>> n2 = 300 # size of second sample For a different distribution, we can reject the null hypothesis since the pvalue is below 1%: >>> rvs1 = stats.norm.rvs(size=n1, loc=0., scale=1, random_state=rng) >>> rvs2 = stats.norm.rvs(size=n2, loc=0.5, scale=1.5, random_state=rng) >>> stats.ks_2samp(rvs1, rvs2) KstestResult(statistic=0.24833333333333332, pvalue=5.846586728086578e-07) For a slightly different distribution, we cannot reject the null hypothesis at a 10% or lower alpha since the p-value at 0.144 is higher than 10% >>> rvs3 = stats.norm.rvs(size=n2, loc=0.01, scale=1.0, random_state=rng) >>> stats.ks_2samp(rvs1, rvs3) KstestResult(statistic=0.07833333333333334, pvalue=0.4379658456442945) For an identical distribution, we cannot reject the null hypothesis since the p-value is high, 41%: >>> rvs4 = stats.norm.rvs(size=n2, loc=0.0, scale=1.0, random_state=rng) >>> stats.ks_2samp(rvs1, rvs4) KstestResult(statistic=0.12166666666666667, pvalue=0.05401863039081145) )rrrmzInvalid value for mode: r r r rjr)r r r zInvalid value for alternative: i'z)Data passed to ks_2samp must not be emptyrT)rrrQrrrmz;Exact ks_2samp calculation not possible with samples sizes rz. Switching to 'asymp'.z= 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 -------- >>> from scipy import stats >>> rng = np.random.default_rng() >>> x = np.linspace(-15, 15, 9) >>> stats.kstest(x, 'norm') KstestResult(statistic=0.444356027159..., pvalue=0.038850140086...) >>> stats.kstest(stats.norm.rvs(size=100, random_state=rng), stats.norm.cdf) KstestResult(statistic=0.165471391799..., pvalue=0.007331283245...) The above lines are equivalent to: >>> stats.kstest(stats.norm.rvs, 'norm', N=100) KstestResult(statistic=0.113810164200..., pvalue=0.138690052319...) # may vary *Test against one-sided alternative hypothesis* Shift distribution to larger values, so that ``CDF(x) < norm.cdf(x)``: >>> x = stats.norm.rvs(loc=0.2, size=100, random_state=rng) >>> stats.kstest(x, 'norm', alternative='less') KstestResult(statistic=0.1002033514..., pvalue=0.1255446444...) Reject null hypothesis in favor of alternative hypothesis: less >>> stats.kstest(x, 'norm', alternative='greater') KstestResult(statistic=0.018749806388..., pvalue=0.920581859791...) Don't reject null hypothesis in favor of alternative hypothesis: greater >>> stats.kstest(x, 'norm') KstestResult(statistic=0.100203351482..., pvalue=0.250616879765...) *Testing t distributed random variables against normal distribution* With 100 degrees of freedom the t distribution looks close to the normal distribution, and the K-S test does not reject the hypothesis that the sample came from the normal distribution: >>> stats.kstest(stats.t.rvs(100, size=100, random_state=rng), 'norm') KstestResult(statistic=0.064273776544..., pvalue=0.778737758305...) With 3 degrees of freedom the t distribution looks sufficiently different from the normal distribution, that we can reject the hypothesis that the sample came from the normal distribution at the 10% level: >>> stats.kstest(stats.t.rvs(3, size=100, random_state=rng), 'norm') KstestResult(statistic=0.128678487493..., pvalue=0.066569081515...) Z two_sidedr rkrl)rhrr)rr)rmrrRrS)rrrhrrrrZxvalsZyvalsrdrdrgrQes  rQcCst|}ttjd|dd|ddkdfd}t|tj}t|j}|dkrbdSd|d||d|S) aTie 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 TrNrrrrr) ror@rrrrrrrr)ZrankvalsrlrNrrrdrdrgrVs % . rVRanksumsResultc Csttj||f\}}t|}t|}t||f}t|}|d|}tj|dd}|||dd}||t||||dd} 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. >>> 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. Nrrrr(@) maprorrrrZrrrrr) r-r#rrrrrankedrfexpectedrrrdrdrgrW!s? &rW KruskalResultcGstttj|}t|}|dkr(td|D]2}|jdkrLttjtjS|j dkr,tdq,tttt|}|dvrtdd}|D]}t ||}|drd }qq|r|d kr|D]}t |}qt j|S|r|d krttjtjSt|}t|} t| } | dkrtd tt|dd} d} t|D].} | t| | | | | d|| 7} q>> 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) rz+Need at least two groups in stats.kruskal()rrz Samples must be one-dimensional.raz1nan_policy must be 'propagate', 'raise' or 'omit'FTrcr`z$All numbers are identical in kruskalrrr)rrrorrrmrrrtrr}rrrrXrrZrVinsertrbrrrrrrr2r)r{rhrrirr|ZcnrzrrtiesrOrrZtotalnrdr*rdrdrgrXqsLB           , rXFriedmanchisquareResultc GsHt|}|dkrtd|t|d}td|D]}t|||kr4tdq4t|j}|t}tt|D]}t ||||<qtd}tt|D]6}t t ||\}}|D]}||||d7}qqd||||d|} t |j ddd} d|||d| d||d| } t | tj| |dS) aCompute the Friedman test for repeated measurements. The Friedman test tests the null hypothesis that repeated measurements of the same individuals have the same distribution. It is often used to test for consistency among measurements obtained in different ways. For example, if two measurement techniques are used on the same set of individuals, the Friedman test can be used to determine if the two measurement techniques are consistent. Parameters ---------- measurements1, measurements2, measurements3... : array_like Arrays of measurements. All of the arrays must have the same number of elements. At least 3 sets of measurements 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 measurements. References ---------- .. [1] https://en.wikipedia.org/wiki/Friedman_test rzHAt least 3 sets of measurements must be given for Friedman test, got {}.rrz*Unequal N in friedmanchisquare. Aborting.rrr)rrmrrroZvstackr;rrrZrrrrrrr2r) rhr4rrrrZreplistZrepnumrkrrZchisqrdrdrgrYs,#    ,rYBrunnerMunzelResultrkcCst|}t|}t||\}}t||\}}|p6|} |dksH|dkrLd}| rf|dkrfttjtjS| r|dkrt|}t|}t||||St |} t |} | dks| dkrttjtjSt t ||f} | d| } | | | | }t | }t |}t |}t |}t |}t |}t t| |||d}|| d}t t||||d}|| d}| | ||}|| | t| || |}|dkrt| || |d}t| |d| d}|t| |d| d7}||}tj||}n |dkr6tj|}ntd|d krJn>|d kr^d|}n*|d krd t|d|g}ntd 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 rcr`rrrrkrz&distribution should be 't' or 'normal'r r r rz6alternative should be 'less', 'greater' or 'two-sided')rorr}rrtrrrr^rrZrrrrr+rrrkrrrmr)r-r#r distributionr{rrrrr|rrZrankcZrankcxZrankcyZ rankcx_meanZ rankcy_meanZrankxZrankyZ rankx_meanZ ranky_meanZSxZSyZwbfnZdf_numerZdf_denomr*r8rdrdrgr^0sjL             "      r^rc Cst|}|jdkrtd|dkrRdtt|}tj|dt |}nv|dkrdtt | }tj|dt |}n>|dkr t dt |tj }tt| tt | }d t |d }t ||d}tj ||||}n|d kr4t|}tj|dt |}n|d kr|d urTt|}nt |t |krntdt|}|jdkrtdtj|}t||tj|}tj|}n td|||fS)a Combine p-values from independent tests bearing upon the same hypothesis. Parameters ---------- pvalues : array_like, 1-D Array of p-values assumed to come from independent tests. method : {'fisher', 'pearson', 'tippett', 'stouffer', 'mudholkar_george'}, optional Name of method to use to combine p-values. The following methods are available (default is 'fisher'): * 'fisher': Fisher's method (Fisher's combined probability test), the sum of the logarithm of the p-values * 'pearson': Pearson's method (similar to Fisher's but uses sum of the complement of the p-values inside the logarithms) * 'tippett': Tippett's method (minimum of p-values) * 'stouffer': Stouffer's Z-score method * 'mudholkar_george': the difference of Fisher's and Pearson's methods divided by 2 weights : array_like, 1-D, optional Optional array of weights used only for Stouffer's Z-score method. Returns ------- statistic: float The statistic calculated by the specified method. pval: float The combined p-value. Notes ----- Fisher's method (also known as Fisher's combined probability test) [1]_ uses a chi-squared statistic to compute a combined p-value. The closely related Stouffer's Z-score method [2]_ uses Z-scores rather than p-values. The advantage of Stouffer's 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]_. The Pearson's method uses :math:`log(1-p_i)` inside the sum whereas Fisher's method uses :math:`log(p_i)` [4]_. For Fisher's and Pearson's method, the sum of the logarithms is multiplied by -2 in the implementation. This quantity has a chi-square distribution that determines the p-value. The `mudholkar_george` method is the difference of the Fisher's and Pearson's test statistics, each of which include the -2 factor [4]_. However, the `mudholkar_george` method does not include these -2 factors. The test statistic of `mudholkar_george` is the sum of logisitic random variables and equation 3.6 in [3]_ is used to approximate the p-value based on Student's t-distribution. Fisher's method may be extended to combine p-values from dependent tests [5]_. Extensions such as Brown's method and Kost's method are not currently implemented. .. versionadded:: 0.15.0 References ---------- .. [1] https://en.wikipedia.org/wiki/Fisher%27s_method .. [2] https://en.wikipedia.org/wiki/Fisher%27s_method#Relation_to_Stouffer.27s_Z-score_method .. [3] George, E. O., and G. S. Mudholkar. "On the convolution of logistic random variables." Metrika 30.1 (1983): 1-13. .. [4] Heard, N. and Rubin-Delanchey, P. "Choosing between methods of combining p-values." Biometrika 105.1 (2018): 239-246. .. [5] 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. .. [6] 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. .. [7] https://en.wikipedia.org/wiki/Extensions_of_Fisher%27s_method rzpvalues is not 1-DrrrrXZmudholkar_georgerrrZtippettZstoufferNz-pvalues and weights must be of the same size.zweights is not 1-DzoInvalid method '%s'. Options are 'fisher', 'pearson', 'mudholkar_george', 'tippett', 'or 'stouffer')rorrrmrrrrr2rrlog1prpirkrr&Z ones_likerZisfrr) rSrrrZpvalZnormalizing_factornuZ approx_factorZZirdrdrgr[sLJ   $         r[cCstd||||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_distanceu_valuesv_values u_weights v_weightsrdrdrgr\5 sJr\cCstdtd||||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`). 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] "Energy distance", https://en.wikipedia.org/wiki/Energy_distance .. [2] Szekely "E-statistics: The energy of statistical samples." Bowling Green State University, Department of Mathematics and Statistics, Technical Report 02-16 (2002). .. [3] Rizzo, Szekely "Energy distance." Wiley Interdisciplinary Reviews: Computational Statistics, 8(1):27-38 (2015). .. [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)rorrrrdrdrgr] sNr]c Cst||\}}t||\}}t|}t|}t||f}|jddt|}|||ddd} |||ddd} |dur| |j} n*tdgt||f} | | | d} |dur| |j} n*tdgt||f}|| |d} |dkr&t t t | | |S|dkrRt t t t | | |Stt t tt | | ||d|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`. rrNrrTrrr)_validate_distributionrorrr@rrrrbrrmultiplyrrrr+)r8rrrrZu_sorterZv_sorterZ all_valuesZdeltasZ u_cdf_indicesZ v_cdf_indicesZu_cdfZu_sorted_cumweightsZv_cdfZv_sorted_cumweightsrdrdrgr s<,          " rcCstj|td}t|dkr"td|durtj|td}t|t|krPtdt|dkrftddt|krtjksntd||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. rrzDistribution 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.)rorrrrmrrrr)valuesrrdrdrgr+!s rRepeatedResults)rrcCstttj|tjdS)aFind 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)rrrorr)rlrdrdrgr]!s rcCst||\}}t|||S)aSquare 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`). )rrorr)rzrrdrdrgr!srcCsBt||\}}t||}t|s2|t|St||SdS)aSum 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`). N)rrorrrrr)rzrrfrdrdrgr!s   rrc Cs|dvrtd||durxt|}|jdkrhtjj||j|dkrRtj ntj }tj |j |dSt t|||Stt|}|dkrdnd }tj||d }tj |jtjd}tj|jtjd||<|dkr|d S||}tjd |d d|dd kf}||} |dkr"| Stjt|dt|f} |dkrP| | S|dkrj| | d d Sd| | | | d d 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. 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 -------- >>> 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. ]]) )rrrdenseordinalzunknown method "{0}"NrrrrrZ quicksortrrTrrrrr )rmrrorrrrrrrrrrrrrZrvrrrrrbrr) rzrrdtrlalgoZsorterr=rrrrdrdrgrZ!s6A  "    rZ)r`)rNN)rN)rr`)NrN)Nrrr)NrTr`)NrTr`)Nrrr)Nrrr)rrr`)rr`r)rTr`)rTTr`)rrTr`)rr`r )rr`r )rr`)rdr?N)rP)rYNNF)rYNN)rYNN)rrr`)r)rrr`)rrr`)rr)Nrrr`rF)r)r))r)rTr)r)r )Nrr`r )Nr`rr)TNT)rrN)rr`r )Tr )rTr`NNr r)rN)r)rTr`Nr )rr`r )N)NrrN)Nrr)rdr r)r r)rdr(r r)r )r rkr`)rN)NN)NN)NN)r)r)r)rrwr!r collectionsrZnumpyrorrrZscipy.spatial.distancerZ scipy.ndimager Zscipy._lib._utilr r r r Z scipy.specialrZscipyrrrZ_stats_mstats_commonrrrrZ_statsrrrrZ dataclassesrZ _hypotestsr__all__r}rrrrrrrrrrr r!r"r#r$r%r&rr'r(r)rr*rrr+r'r,r1r-r5r.Z deprecater/r0rAr1rVr_r`r2rgr3r4r5rnrorpr7r6r9Zerfinvrrr8rrr;Z%_median_absolute_deviation_deprec_msgr:rr<r=r>r?rryrArBrrsr@r_rrrrCrDrErFrGrrHrrIrrJrrKrrrrrLr r!r"rr)rMrr-r0r1r2rOr4rNr8r?rGrLrOr7rTrUrPr^r[r\r]rUrTrdrhrirRZKs_2sampResultrxr{rrrSrrQrVrrWrrXrrYrr^r[r\r]rrrrrrrZrdrdrdrgs             L C  ]. 1 6 > = 0 ; Y+ ; g n X  f  p  I > ) P+ Z N M PS @  G R  -   p  D = < E  d    9   :V  J  5 <  !0-3  j    |+ #   K r  ^    g & W /2  - M v A yMRW / #