(ph^ bSrSSKrSSKrSSKJr SSKJr SSKJr SSKr SSKJ r J r J r SSK Jr SSKJr SS KJrJr SS KJrJrJrJrJrJr SS KJr SSKJr SS K Jr S SK J!r! S SK J"r# S SK$J%r%J&r&J'r' S SK(J)r)J*r*J+r+ SSK,J-r-J.r. S SK/J0r0 S SK1J2r2 S SK3J4r4J5r5J6r6J7r7J8r8J9r9J:r: S SK;Jr>J?r?J@r@JArAJBrBJCrCJDrD S SKEJFrG SSKHJIrI SSK JJrJ SSKJKrK SSKJLrL SSKMJNrNJOrOJPrPJQrQJRrRJSrSJTrTJUrU SSKVJWrX SSKJYrY /SQrZSS .S!jr[S"r\SS .S#jr]\I"S$S%S&//5r^\<"S'S S SS(S)S*/S+9GS>S,j5r_\<"S-S S SS(S.S*/S+9GS?SS/.S0jj5r`\<"S1S S SS(S2S*/S+9SSSS3.S4j5ra\"S5S65rbS7rc\<"\cS(S8S9.S:9GS@S<j5rd\ RS4S=jrf\<"S>S SS?S@9GSASAj5rg\<"SBS SCSD9GSBSEj5rh\<"SFS SGSD9GSCSHj5ri\<"SIS SJSD9GSCSKj5rj\<"SLS SMSD9GSBSNj5rk\<"SOS SPSD9GSBSQj5rlGSDSRjrmSSrnSTro\"SUSV5\<"\nS \o\mSW9GSESSX.SYjj55rpS(SZ.S[jrqSSS\.S]jrrGSFS^jrs\<"S_S`S Sa9GSGSbj5rt\<"ScSdS Sa9GSHSej5ru\"SfSg5rvGSIShjrwGSJSijrx\"SjSk5ry\<"\yS SlSm9GSKSoj5rz\"SpSk5r{\<"\{S SqSm9GSKSrj5r|\"SsSk5r}\<"\}S SlSm9GSLStj5r~\<"\^SSu9SSv.Swj5rGSMSxjrSyrGSNSzjr\"S{S|5rGSOS}jr\"S~S5rGSPSjr\"SS5rGSPSjrSr\<"SSS S S9GSQSj5rSrGSRSjrSSS;S.SjrGSRSjrGSSSjrS\GR "S5S-\GR""S5-0r\<"SSS SSS80S9GSTSj5rSrS\ GR*SS;4Sjr\"SS5rGSUSjrGSVSjrGSWSjrGSVSjr\"SSk5rSrSrGSXSjr\<"\S\Sm9SSv.Sj5r\-"SS55r\<"\SSS S9S;SS.Sj5rSrSrSr\"SSS/5r\I"SS%S&//5r"SS\5rSnSSS.SjrGSYSS.SjjrSrSrSrSrGSZSjrSrS;SSSnS.SjrGS[Sjr\I"SS%S&/S/5r"SS\5rSrSr\<"\SS\SS9GSKSj5rGS\SjrGSYSjrGSYSjrGSYSjr\"SSk5rGS]SjrSr\"SSS1\S9\<"\SS\SS9SS(S;SSSnSSS.Sj55rSrSrSrGSYSjrGS^SjrGS_SjrSr\<"\SS\SS(S9GSKSj5rS SSSSSS.rSrSrSrSr\"SSk5rGS`SjrGSaSjrGSbS(S.Sjjr\I"SS%S&/SS/5rSrSrSrSr\<"\S Sq\S9\"SS5GScSj55r\rSrSrSr\<"\SSq\S9\"SS5GSdSj55rGSrGSr\<"\\Sq\S9\"SS5GSeGSj55rGSr\"GSSk5r\<"\SGS9GSfGSj5r\"GSSk5r\<"\SGS9S;GS.GS j5r\"GS Sk5r\<"\SS(GS 9GS 5r\"GS Sk5r\<"\SGS9GSgGSj5r\<"\^S*/S(GS9GShSSv.GSjj5r\-"GSGS55rGSrSSSnGS.GSjrGS\GSjrGS\GSjrGS\GSjrGS\GSjrGSr\"GSGS5r\Y"GS5GS5rGSVGSjrGSVGS jrGSiSS;GS!.GS"jjrGS#rGSjGS$jrGSkSS/.GS%jjrGS&rSGS'.GS(jrGS)r\<"\nS \oGS*SW9GSYSS8S(GS+.GS,jj5r\I"GS-/GS.QGS//GS09rGSlGS1jrSSS8S;SSGS2.GS3jrSSS8S;SSGS4.GS5jGr"GS6GS75Gr"GS8GS95Gr"GS:GS;5Gr"GS<GS=5Grg(mz 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)Sequence)arrayasarrayma)sparse)distance_matrix)milpLinearConstraint)check_random_state_get_nan_rename_parameter _contains_nan AxisError _lazywhere)_deprecate_positional_args)linalg) distributions) _mstats_basic) _find_repeats theilslopes siegelslopes) _kendall_dis_toint64_weightedrankedtau) dataclassfield)_all_partitions)!_compute_outer_prob_inside_method)MonteCarloMethodPermutationMethodBootstrapMethodmonte_carlo_testpermutation_test bootstrap_batch_generator) _axis_nan_policy_factory_broadcast_concatenate_broadcast_shapes#_broadcast_array_shapes_remove_axisSmallSampleWarningtoo_small_1d_not_omittoo_small_1d_omittoo_small_nd_not_omittoo_small_nd_omit)_binary_search_for_binom_tst)_make_tuple_bunch)stats) root_scalar)normalize_axis_index)_asarrayarray_namespaceis_numpyxp_sizexp_moveaxis_to_endxp_signxp_vector_normxp_broadcast_promote)array_api_extra) _deprecated)D find_repeatsgmeanhmeanpmeanmodetmeantvartmintmaxtstdtsemmomentskewkurtosisdescribeskewtest kurtosistest normaltest jarque_berascoreatpercentilepercentileofscorecumfreqrelfreqobrientransformsemzmapzscoregzscoreiqrgstdmedian_abs_deviation sigmacliptrimbothtrim1 trim_meanf_onewaypearsonr fisher_exact spearmanrpointbiserialr kendalltau weightedtau linregressrr ttest_1samp ttest_indttest_ind_from_stats ttest_relkstestks_1sampks_2samp chisquarepower_divergence tiecorrectranksumskruskalfriedmanchisquarerankdatacombine_pvalues quantile_testwasserstein_distancewasserstein_distance_ndenergy_distance brunnermunzelalexandergovern expectilelmomentxpcUc [U5nUcURUS5nSnOURU5nUnURS:XaURUS5nX4$)Nr)r8reshaperndim)aaxisroutaxiss H/var/www/html/venv/lib/python3.13/site-packages/scipy/stats/_stats_py.py _chk_asarrayrps` z Q  | JJq%  JJqMvv{ JJq%  :cbUc/[R"U5n[R"U5nSnO.[R"U5n[R"U5nUnURS:Xa[R"U5nURS:Xa[R"U5nXU4$)Nr)npravelrr atleast_1d)rbrrs r _chk2_asarrayrs | HHQK HHQK JJqM JJqMvv{ MM! vv{ MM!  =rc Uc[U6OUnUVs/sH n[USS9PM nnUVs/sHKnURURS5(aUR S5RO URPMM nnUR "U6nUVs/sHo R X$SS9PM nn[U5S:XaUS$[U5$s snfs snfs snf) NTsubokintegral?Fcopyrr) r8r7isdtypedtyper result_typeastypelentuple)rarraysrdtypesrs r_convert_common_floatrs%'Z& !RB7= >vehuD)vF >.46.4U(*zz%++z'J'Jrzz"~##KK .4 6 NNF #E?E Fveii5i1vF FF Q6!99E&M9 ?6GsC ACCSignificanceResult statisticpvaluecU$Nxs rr!rTcU4$rrrs rrr1$rweights) n_samples n_outputs too_smallpairedresult_to_tuple kwd_samplesc [X5nURXS9nUbURX2S9n[R"SS9 UR U5nSSS5 UR [ WXS95$!,(df  N'=f)aCompute the weighted geometric mean along the specified axis. The weighted geometric mean of the array :math:`a_i` associated to weights :math:`w_i` is: .. math:: \exp \left( \frac{ \sum_{i=1}^n w_i \ln a_i }{ \sum_{i=1}^n w_i } \right) \, , and, with equal weights, it gives: .. math:: \sqrt[n]{ \prod_{i=1}^n a_i } \, . Parameters ---------- a : array_like Input array or object that can be converted to an array. axis : int or None, optional Axis along which the geometric mean is computed. Default is 0. If None, compute over the whole array `a`. dtype : dtype, optional Type to which the input arrays are cast before the calculation is performed. weights : array_like, optional The `weights` array must be broadcastable to the same shape as `a`. Default is None, which gives each value a weight of 1.0. Returns ------- gmean : ndarray See `dtype` parameter above. See Also -------- numpy.mean : Arithmetic average numpy.average : Weighted average hmean : Harmonic mean Notes ----- The sample geometric mean is the exponential of the mean of the natural logarithms of the observations. Negative observations will produce NaNs in the output because the *natural* logarithm (as opposed to the *complex* logarithm) is defined only for non-negative reals. References ---------- .. [1] "Weighted Geometric Mean", *Wikipedia*, https://en.wikipedia.org/wiki/Weighted_geometric_mean. .. [2] Grossman, J., Grossman, M., Katz, R., "Averages: A New Approach", Archimedes Foundation, 1983 Examples -------- >>> from scipy.stats import gmean >>> gmean([1, 4]) 2.0 >>> gmean([1, 2, 3, 4, 5, 6, 7]) 3.3800151591412964 >>> gmean([1, 4, 7], weights=[3, 1, 3]) 2.80668351922014 rNignoredividerr)r8rrerrstatelogexp_xp_mean)rrrrrlog_as rrBrBstN  $B 1 "A**W*2 H %q  & 66(5t= >> & %s A44 BcU$rrrs rrrrrcU4$rrrs rrrrrrc~[X5nURXS9nUbURX2S9nUS:nURU5(a8URXTRU5nSn[ R "U[SS9 [R"SS9 S [S U- XS 9- sSSS5 $!,(df  g=f) aCalculate the weighted harmonic mean along the specified axis. The weighted harmonic mean of the array :math:`a_i` associated to weights :math:`w_i` is: .. math:: \frac{ \sum_{i=1}^n w_i }{ \sum_{i=1}^n \frac{w_i}{a_i} } \, , and, with equal weights, it gives: .. math:: \frac{ n }{ \sum_{i=1}^n \frac{1}{a_i} } \, . Parameters ---------- a : array_like Input array, masked array or object that can be converted to an array. axis : int or None, optional Axis along which the harmonic mean is computed. Default is 0. If None, compute over the whole array `a`. dtype : dtype, optional Type of the returned array and of the accumulator in which the elements are summed. If `dtype` is not specified, it defaults to the dtype of `a`, unless `a` has an integer `dtype` with a precision less than that of the default platform integer. In that case, the default platform integer is used. weights : array_like, optional The weights array can either be 1-D (in which case its length must be the size of `a` along the given `axis`) or of the same shape as `a`. Default is None, which gives each value a weight of 1.0. .. versionadded:: 1.9 Returns ------- hmean : ndarray See `dtype` parameter above. See Also -------- numpy.mean : Arithmetic average numpy.average : Weighted average gmean : Geometric mean Notes ----- The sample harmonic mean is the reciprocal of the mean of the reciprocals of the observations. 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. The harmonic mean is only defined if all observations are non-negative; otherwise, the result is NaN. References ---------- .. [1] "Weighted Harmonic Mean", *Wikipedia*, https://en.wikipedia.org/wiki/Harmonic_mean#Weighted_harmonic_mean .. [2] Ferger, F., "The nature and use of the harmonic mean", Journal of the American Statistical Association, vol. 26, pp. 36-40, 1931 Examples -------- >>> from scipy.stats import hmean >>> hmean([1, 4]) 1.6000000000000001 >>> hmean([1, 2, 3, 4, 5, 6, 7]) 2.6997245179063363 >>> hmean([1, 4, 7], weights=[3, 1, 3]) 1.9029126213592233 rNrzaThe harmonic mean is only defined if all elements are non-negative; otherwise, the result is NaN. stacklevelrrrr) r8ranywherenanwarningswarnRuntimeWarningrrr)rrrrr negative_maskmessages rrCrCs`  $B 1 "A**W*2EM vvm HH]FFA .A g~!< H %XcAgDBB & % %s B.. B<cU$rrrs rrrZrrcU4$rrrs rrr[rrrrrc[U[[45(d [S5eUS:Xa [ XX4S9$[ X5nUR XS9nUbUR XCS9nUS:nURU5(a=URU[RU5nSn[R"U[SS9 [R"S S S 9 [U[U5-X$S 9S U- -sSSS5 $!,(df  g=f) uz Calculate the weighted power mean along the specified axis. The weighted power mean of the array :math:`a_i` associated to weights :math:`w_i` is: .. math:: \left( \frac{ \sum_{i=1}^n w_i a_i^p }{ \sum_{i=1}^n w_i } \right)^{ 1 / p } \, , and, with equal weights, it gives: .. math:: \left( \frac{ 1 }{ n } \sum_{i=1}^n a_i^p \right)^{ 1 / p } \, . When ``p=0``, it returns the geometric mean. This mean is also called generalized mean or Hölder mean, and must not be confused with the Kolmogorov generalized mean, also called quasi-arithmetic mean or generalized f-mean [3]_. Parameters ---------- a : array_like Input array, masked array or object that can be converted to an array. p : int or float Exponent. axis : int or None, optional Axis along which the power mean is computed. Default is 0. If None, compute over the whole array `a`. dtype : dtype, optional Type of the returned array and of the accumulator in which the elements are summed. If `dtype` is not specified, it defaults to the dtype of `a`, unless `a` has an integer `dtype` with a precision less than that of the default platform integer. In that case, the default platform integer is used. weights : array_like, optional The weights array can either be 1-D (in which case its length must be the size of `a` along the given `axis`) or of the same shape as `a`. Default is None, which gives each value a weight of 1.0. Returns ------- pmean : ndarray, see `dtype` parameter above. Output array containing the power mean values. See Also -------- numpy.average : Weighted average gmean : Geometric mean hmean : Harmonic mean Notes ----- The power mean is computed over a single dimension of the input array, ``axis=0`` by default, or all values in the array if ``axis=None``. float64 intermediate and return values are used for integer inputs. The power mean is only defined if all observations are non-negative; otherwise, the result is NaN. .. versionadded:: 1.9 References ---------- .. [1] "Generalized Mean", *Wikipedia*, https://en.wikipedia.org/wiki/Generalized_mean .. [2] Norris, N., "Convexity properties of generalized mean value functions", The Annals of Mathematical Statistics, vol. 8, pp. 118-120, 1937 .. [3] Bullen, P.S., Handbook of Means and Their Inequalities, 2003 Examples -------- >>> from scipy.stats import pmean, hmean, gmean >>> pmean([1, 4], 1.3) 2.639372938300652 >>> pmean([1, 2, 3, 4, 5, 6, 7], 1.3) 4.157111214492084 >>> pmean([1, 4, 7], -2, weights=[3, 1, 3]) 1.4969684896631954 For p=-1, power mean is equal to harmonic mean: >>> pmean([1, 4, 7], -1, weights=[3, 1, 3]) 1.9029126213592233 >>> hmean([1, 4, 7], weights=[3, 1, 3]) 1.9029126213592233 For p=0, power mean is defined as the geometric mean: >>> pmean([1, 4, 7], 0, weights=[3, 1, 3]) 2.80668351922014 >>> gmean([1, 4, 7], weights=[3, 1, 3]) 2.80668351922014 z:Power mean only defined for exponent of type int or float.rrrNz^The power mean is only defined if all elements are non-negative; otherwise, the result is NaN.rrrrinvalidrr) isinstanceintfloat ValueErrorrBr8rrrrrrrrrr)rprrrrrrs rrDrDYsL a#u & &"# #AvQ@@  $B 1 "A**W*2EM vvm HH]BFFA .A g~!< Hh 758 $@1Q3G 8 7 7s C66 D ModeResult)rEcountc[R"U5nURS:Xa,U(a"[R"SURS9SOUnOSX'[ X5$)Nrrr)risnanshaperrr)rEris r _mode_resultrsK Aww"}89 1EKK04u d ""rF) vectorizationnan_propagation)override propagatec[R"UR[R5(d Sn[ U5eUR S:Xa2[ U5n[[R"US/URS96$[R"USS9upgXgR5UR5p[USU S5$)aReturn an array of the modal (most common) value in the passed array. If there is more than one such value, only one is returned. The bin-count for the modal bins is also returned. Parameters ---------- a : array_like Numeric, n-dimensional array of which to find mode(s). axis : int or None, optional Axis along which to operate. Default is 0. If None, compute over the whole array `a`. nan_policy : {'propagate', 'raise', 'omit'}, optional Defines how to handle when input contains nan. The following options are available (default is 'propagate'): * 'propagate': treats nan as it would treat any other value * 'raise': throws an error * 'omit': performs the calculations ignoring nan values keepdims : bool, optional If set to ``False``, the `axis` over which the statistic is taken is consumed (eliminated from the output array). If set to ``True``, the `axis` is retained with size one, and the result will broadcast correctly against the input array. Returns ------- mode : ndarray Array of modal values. count : ndarray Array of counts for each mode. Notes ----- The mode is calculated using `numpy.unique`. In NumPy versions 1.21 and after, all NaNs - even those with different binary representations - are treated as equivalent and counted as separate instances of the same value. By convention, the mode of an empty array is NaN, and the associated count is zero. Examples -------- >>> import numpy as np >>> a = np.array([[3, 0, 3, 7], ... [3, 2, 6, 2], ... [1, 7, 2, 8], ... [3, 0, 6, 1], ... [3, 2, 5, 5]]) >>> from scipy import stats >>> stats.mode(a, keepdims=True) ModeResult(mode=array([[3, 0, 6, 1]]), count=array([[4, 2, 2, 1]])) To get mode of whole array, specify ``axis=None``: >>> stats.mode(a, axis=None, keepdims=True) ModeResult(mode=[[3]], count=[[5]]) >>> stats.mode(a, axis=None, keepdims=False) ModeResult(mode=3, count=5) zArgument `a` is not recognized as numeric. Support for input that cannot be coerced to a numeric array was deprecated in SciPy 1.9.0 and removed in SciPy 1.11.0. Please consider `np.unique`.rrT) return_countsr) r issubdtypernumber TypeErrorsizerrruniqueargmaxmax) rr nan_policykeepdimsrNaNvalscntsmodescountss rrErEsD ==")) , ,:  vv{qk288S!HCII>??1D1JD'6 eBi ,,rcUc [U5OUnURURURS9nUcX4$UupgUupUbXX(aX:OX:*-nUbXY(aX:OX:-nUR U5(a [ S5eUR U5(agURURS5(aURS5RO URn URXTRX:S9U5nX4$)asReplace elements outside limits with a value. 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). Elements in the input array less than the lower limit or greater than the upper limit will be replaced with `val`. 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. val : float, default: NaN The value with which extreme elements of the array are replaced. rz#No array values within given limitsrr) r8zerosrboolallrrrrrr) rlimits inclusivevalrmask lower_limit upper_limit lower_include upper_includers r_put_val_to_limitsr:s& "z rB 88AGG2778 +D ~w%K#, M ]8HH ]8HH vvd||>?? vvd||)+ 177J(G(G 2$$QWW HHT::c:7 ; 7NrcU$rrrs rrrbarcU4$rrrs rrrcsqdr)r default_axisrcH[U5n[XUSUS9upURXURS9nURUR U)URS9X0RS9n[ US:gXg4UR UR5nURS:XaUS$U$)aWCompute the trimmed mean. This function finds the arithmetic mean of given values, ignoring values outside the given `limits`. Parameters ---------- a : array_like Array of values. limits : None or (lower limit, upper limit), optional Values in the input array less than the lower limit or greater than the upper limit will be ignored. When limits is None (default), then all values are used. Either of the limit values in the tuple can also be None representing a half-open interval. inclusive : (bool, bool), optional A tuple consisting of the (lower flag, upper flag). These flags determine whether values exactly equal to the lower or upper limits are included. The default value is (True, True). axis : int or None, optional Axis along which to compute test. Default is None. Returns ------- tmean : ndarray Trimmed mean. See Also -------- trim_mean : Returns mean after trimming a proportion from both tails. Examples -------- >>> import numpy as np >>> from scipy import stats >>> x = np.arange(20) >>> stats.tmean(x) 9.5 >>> stats.tmean(x, (3,17)) 10.0 rrrrrrr) r8rsumrrrrrr) rrrrrrrnmeans rrFrFas\  B I2"EGA &&QWW& -C rzz4%qwwz/d''JA a1fsh 266 :DyyA~48/4/rcU$rrrs rrrrrcU4$rrrs rrrr)rrc [U5n[XX%S9up[R"5 [R"S[ 5 [ XUSUS9sSSS5 $!,(df  g=f)aCompute the trimmed variance. This function computes the sample variance of an array of values, while ignoring values which are outside of given `limits`. Parameters ---------- a : array_like Array of values. limits : None or (lower limit, upper limit), optional Values in the input array less than the lower limit or greater than the upper limit will be ignored. When limits is None, then all values are used. Either of the limit values in the tuple can also be None representing a half-open interval. The default value is None. inclusive : (bool, bool), optional A tuple consisting of the (lower flag, upper flag). These flags determine whether values exactly equal to the lower or upper limits are included. The default value is (True, True). axis : int or None, optional Axis along which to operate. Default is 0. If None, compute over the whole array `a`. ddof : int, optional Delta degrees of freedom. Default is 1. Returns ------- tvar : float Trimmed variance. Notes ----- `tvar` computes the unbiased sample variance, i.e. it uses a correction factor ``n / (n - 1)``. Examples -------- >>> import numpy as np >>> from scipy import stats >>> x = np.arange(20) >>> stats.tvar(x) 35.0 >>> stats.tvar(x, (3,17)) 20.0 rromit correctionrrrN)r8rrcatch_warnings simplefilterr-_xp_var)rrrrddofr_s rrGrGsVb  B a :DA  "h(:;qBO # " "s 'A A,cU$rrrs rrrrrcU4$rrrs rrrrrc[U5nURn[XS4US4URUS9upUR XS9nUR UR U)URS9US9n URU S:gXR5n URURU 55(dURXSS9n U RS:XaU S$U $) aCompute the trimmed minimum. This function finds the minimum 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. Returns ------- tmin : float, int or ndarray Trimmed minimum. Examples -------- >>> import numpy as np >>> from scipy import stats >>> x = np.arange(20) >>> stats.tmin(x) 0 >>> stats.tmin(x, 13) 13 >>> stats.tmin(x, 13, inclusive=False) 14 Nr rrrFrr) r8rrinfminrrrrrrrr) r lowerlimitrrrrrrr"rress rrHrHsZ  B GGE $6D8I%'VV4GA &&& C rzz4%qwwz/d;A ((163 'C 66"((3- iii/hh!m3r7,,rcU$rrrs rrrrrcU4$rrrs rrrrrc[U5nURn[USU4SU4UR*US9upUR XS9nUR UR U)URS9US9n URU S:gXR5n URURU 55(dURXSS9n U RS:XaU S$U $) aCompute 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. Returns ------- tmax : float, int or ndarray Trimmed maximum. Examples -------- >>> import numpy as np >>> from scipy import stats >>> x = np.arange(20) >>> stats.tmax(x) 19 >>> stats.tmax(x, 13) 13 >>> stats.tmax(x, 13, inclusive=False) 12 Nr r rrFrr) r8rrr!rrrrrrrrr) r upperlimitrrrrrrrrr$s rrIrIsX  B GGE T:$6y8I&(ffW5GA &&& C rzz4%qwwz/d;A ((163 'C 66"((3- iii/hh!m3r7,,rcU$rrrs rrrPrrcU4$rrrs rrrPrrc  [XX#USS9S-$)a:Compute the trimmed sample standard deviation. This function finds the sample standard deviation of given values, ignoring values outside the given `limits`. Parameters ---------- a : array_like Array of values. limits : None or (lower limit, upper limit), optional Values in the input array less than the lower limit or greater than the upper limit will be ignored. When limits is None, then all values are used. Either of the limit values in the tuple can also be None representing a half-open interval. The default value is None. inclusive : (bool, bool), optional A tuple consisting of the (lower flag, upper flag). These flags determine whether values exactly equal to the lower or upper limits are included. The default value is (True, True). axis : int or None, optional Axis along which to operate. Default is 0. If None, compute over the whole array `a`. ddof : int, optional Delta degrees of freedom. Default is 1. Returns ------- tstd : float Trimmed sample standard deviation. Notes ----- `tstd` computes the unbiased sample standard deviation, i.e. it uses a correction factor ``n / (n - 1)``. Examples -------- >>> import numpy as np >>> from scipy import stats >>> x = np.arange(20) >>> stats.tstd(x) 5.9160797830996161 >>> stats.tstd(x, (3,17)) 4.4721359549995796 T_no_deco?)rG)rrrrrs rrJrJOsb 9D4 @# EErcU$rrrs rrrrrcU4$rrrs rrrrrc F[U5n[XX%S9up[R"5 [R"S[ 5 [ XUSUS9S-nSSS5 URURU5)UWRS9nXxS-- $!,(df  N@=f)a6Compute the trimmed standard error of the mean. This function finds the standard error of the mean for given values, ignoring values outside the given `limits`. Parameters ---------- a : array_like Array of values. limits : None or (lower limit, upper limit), optional Values in the input array less than the lower limit or greater than the upper limit will be ignored. When limits is None, then all values are used. Either of the limit values in the tuple can also be None representing a half-open interval. The default value is None. inclusive : (bool, bool), optional A tuple consisting of the (lower flag, upper flag). These flags determine whether values exactly equal to the lower or upper limits are included. The default value is (True, True). axis : int or None, optional Axis along which to operate. Default is 0. If None, compute over the whole array `a`. ddof : int, optional Delta degrees of freedom. Default is 1. Returns ------- tsem : float Trimmed standard error of the mean. Notes ----- `tsem` uses unbiased sample standard deviation, i.e. it uses a correction factor ``n / (n - 1)``. Examples -------- >>> import numpy as np >>> from scipy import stats >>> x = np.arange(20) >>> stats.tsem(x) 1.3228756555322954 >>> stats.tsem(x, (3,17)) 1.1547005383792515 rrrrr.Nr ) r8rrrrr-rrrr) rrrrrrrsdn_obss rrKrKsb  B a :DA  "h(:;Qdv" Ms R # FFBHHQKUR[X X$S 9[ R"S 45 Ml UR%USS9$[XX$S 9$)aCCalculate 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. order : int or 1-D 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 center : float or None, optional The point about which moments are taken. This can be the sample mean, the origin, or any other be point. If `None` (default) compute the center as the sample mean. Returns ------- n-th moment about the `center` : 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 moment of a data sample is: .. math:: m_k = \frac{1}{n} \sum_{i = 1}^n (x_i - c)^k Where `n` is the number of samples, and `c` is the center around which the moment is calculated. This function uses exponentiation by squares [1]_ for efficiency. Note that, if `a` is an empty array (``a.size == 0``), array `moment` with one element (`moment.size == 1`) is treated the same as scalar `moment` (``np.isscalar(moment)``). This might produce arrays of unexpected shape. References ---------- .. [1] https://eli.thegreenplace.net/2009/03/21/efficient-integer-exponentiation-algorithms Examples -------- >>> from scipy.stats import moment >>> moment([1, 2, 3, 4, 5], order=1) 0.0 >>> moment([1, 2, 3, 4, 5], order=2) 2.0 rrrrr6z)All elements of `order` must be integral.rNrTrr)r.r )r8rrrrfloat64r:rrroundrrrangerappend_momentrnewaxisconcat) rr5rrrBrcalculate_meanrmmntrorder_is rrLrLsT  B1r*GA zz!'':&& JJq J + JJqM JJuGGJ ,Eu~ LMM vvexx&''DEEqE"IeE zzA~4=BFF519,=7Erwwqdw34u{{1~&AhG~'A+ GA@SQR GAB2::s?ST ' yyAy&&q33r)precision_warningcX- n[U5S:XaU$URUR5RS-n[R "SSS9 UR URU5USS9URU5- nSSS5 [R "SS9 URWU:5nSSS5 Uc [U5OJ[R"[R"UR5[R"U55n W(a)U S:a#U(aS n [R"U [S S 9 U$!,(df  N=f!,(df  N=f) Nr rrTrDrrzPrecision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.r)r:finforepsrrrabsrprodrrrrr) rrrrrO a_zero_meanrUrel_diffprecision_lossrrs r_demeanr[bs (K{q  ((4::  " "R 'C Hh 766"&&-D#')+-66$<8 8 X &3/ '|ggbjj)"**T*:;<!a%$5F  g~!<  8 7 ' &s3E "E E E)rrcNUc [U5OUnURURS5(aURXRS9nURn[ U5S:XaUR XS9$US:Xd US:XaUUcR[UR5nXb US:XaURXeS9OURXeS9nURS:XaUS$U$U/nUn U S:a1U S-(a U S- S- n OU S-n URU 5 U S:aM1UcUR XS S 9OURX5S9nURS:XaUSOUn[XX$S 9n US S:XaURU S S 9n OU S-n USSS 2Hn U S-n U S-(dMX-n M UR XS9$)zVectorized calculation of raw moment about specified center When `mean` is None, the mean is computed and used as the center; otherwise, the provided value is used as the center. Nrrrr rrrTrDrrr)r8rrrrEr:rlistronesrrrHr[) rr5rrrrrtempn_list current_nrXsrs rrIrIs "z rB zz!'':&& JJq J + GGEqzQwwqw$$ zeqjT\QWW  K/4z+XXeX1 99>tBx3t3WFI a- q="Q!+I NI i a-59LBGGA4G 0D. yyA~484D!4/K bzQ JJ{J . NBFF^ qD q55 A 7717  rcUc [U5OUn[USXUS9nUS:wa9UbURUO [U5nU[R "XfU- 5-nU$)Nrr\r)r8rIrr:rr)rrrrrvarrs r_varrgs]!z rB !QB /C qy!-AGGDM71: ryydF## JrcU$rrrs rrrrrcU4$rrrs rrrA4r)rrc[U5n[XUS9upURUnURXSS9nUR XaS9n[ USXUS9n[ USXUS9n [ R"SS 9 URUR5Rn XU-S-:*n URXRUR5XS -- 5n S S S 5 U(dFW )US:-n URU 5(a'XnXn US - U-S -US- - U -US -- nUW U 'W RS:XaU S$U $!,(df  Nr=f)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 NaN where all values are equal. Notes ----- The sample skewness is computed as the Fisher-Pearson coefficient of skewness, i.e. .. math:: g_1=\frac{m_3}{m_2^{3/2}} where .. math:: m_i=\frac{1}{N}\sum_{n=1}^N(x[n]-\bar{x})^i is the biased sample :math:`i\texttt{th}` central moment, and :math:`\bar{x}` is the sample mean. If ``bias`` is False, the calculations are corrected for bias and the value computed is the adjusted Fisher-Pearson standardized moment coefficient, i.e. .. math:: G_1=\frac{k_3}{k_2^{3/2}}= \frac{\sqrt{N(N-1)}}{N-2}\frac{m_3}{m_2^{3/2}}. References ---------- .. [1] Zwillinger, D. and Kokoska, S. (2000). CRC Standard Probability and Statistics Tables and Formulae. Chapman & Hall: New York. 2000. Section 2.2.24.1 Examples -------- >>> from scipy.stats import skew >>> skew([1, 2, 3, 4, 5]) 0.0 >>> skew([2, 8, 0, 4, 1, 9, 9, 0]) 0.2650554122698573 rTrDr rr\rr?Nrr.@rr)r8rrrsqueezerIrrrTrrUrrrrr)rrbiasrrrr mean_reducedm2m3rUzeror can_correctnvals rrMrMsP^  B1r*GA  A 771$7 /D::d:.L At2 .B At2 .B  "hhrxx $$L(1,,xxjj0"3w,? # eq1uo 66+  BBWMC'1s73b82s7BD $D yyA~48/4/ # "s 2A D>> E cU$rrrs rrr)rrcU4$rrrs rrr)rjrc[U5n[XUS9upURUnURXSS9nUR XqS9n[ USXUS9n [ USXUS9n [ R"SS 9 XRU R5RU-S-:*n [XS9n URXXS -- 5n S S S 5 U(d[W )US :-nURU5(a<Xn Xn S US- - US - - US-S - U -U S -- S US- S --- -nUS-W U'U(aW S - OW n U RS:XaU S$U $!,(df  N=f)a Compute the kurtosis (Fisher or Pearson) of a dataset. Kurtosis is the fourth central moment divided by the square of the variance. If Fisher's definition is used, then 3.0 is subtracted from the result to give 0.0 for a normal distribution. If bias is False then the kurtosis is calculated using k statistics to eliminate bias coming from biased moment estimators Use `kurtosistest` to see if result is close enough to normal. Parameters ---------- a : array Data for which the kurtosis is calculated. axis : int or None, optional Axis along which the kurtosis is calculated. Default is 0. If None, compute over the whole array `a`. fisher : bool, optional If True, Fisher's definition is used (normal ==> 0.0). If False, Pearson's definition is used (normal ==> 3.0). bias : bool, optional If False, then the calculations are corrected for statistical bias. nan_policy : {'propagate', 'raise', 'omit'}, optional Defines how to handle when input contains nan. 'propagate' returns nan, 'raise' throws an error, 'omit' performs the calculations ignoring nan values. Default is 'propagate'. Returns ------- kurtosis : array The kurtosis of values along an axis, returning NaN where all values are equal. References ---------- .. [1] Zwillinger, D. and Kokoska, S. (2000). CRC Standard Probability and Statistics Tables and Formulae. Chapman & Hall: New York. 2000. Examples -------- In Fisher's definition, the kurtosis of the normal distribution is zero. In the following example, the kurtosis is close to zero, because it was calculated from the dataset, not from the continuous distribution. >>> import numpy as np >>> from scipy.stats import norm, kurtosis >>> data = norm.rvs(size=1000, random_state=3) >>> kurtosis(data) -0.06928694200380558 The distribution with a higher kurtosis has a heavier tail. The zero valued kurtosis of the normal distribution in Fisher's definition can serve as a reference point. >>> import matplotlib.pyplot as plt >>> import scipy.stats as stats >>> from scipy.stats import kurtosis >>> x = np.linspace(-5, 5, 100) >>> ax = plt.subplot() >>> distnames = ['laplace', 'norm', 'uniform'] >>> for distname in distnames: ... if distname == 'uniform': ... dist = getattr(stats, distname)(loc=-2, scale=4) ... else: ... dist = getattr(stats, distname) ... data = dist.rvs(size=1000) ... kur = kurtosis(data, fisher=True) ... y = dist.pdf(x) ... ax.plot(x, y, label="{}, {}".format(distname, round(kur, 3))) ... ax.legend() The Laplace distribution has a heavier tail than the normal distribution. The uniform distribution (which has negative kurtosis) has the thinnest tail. rTrDr rr\rrmroNrlrr@rr)r8rrrrprIrrrTrrUrrrr)rrfisherrqrrrrrrrsm4rurrrvrws rrNrN(spl  B1r*GA  A 771$7 /D::d:.L At2 .B At2 .B  "hhrxx(,,|;a??r!xx2C<0 # eq1uo 66+  BB!9ac?q!tCxmBG&;a1s l&JKD $s D 4!84DyyA~48/4/ # "s 2AE EDescribeResult)nobsminmaxrvarianceskewnessrNc[U5n[XUS9up[X5updU(a3US:Xa-[R"U5n[ R "XX#5$[U5S:Xa [S5eURUnURXS9URXS94nURXS9n [XX%S9n [XUS9n [XUS9n [!XxXX5$)aCompute 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. Raises ------ ValueError If size of `a` is 0. See Also -------- skew, kurtosis Examples -------- >>> import numpy as np >>> from scipy import stats >>> a = np.arange(10) >>> stats.describe(a) DescribeResult(nobs=10, minmax=(0, 9), mean=4.5, variance=9.166666666666666, skewness=0.0, kurtosis=-1.2242424242424244) >>> b = [[1, 2], [3, 4]] >>> stats.describe(b) DescribeResult(nobs=2, minmax=(array([1, 2]), array([3, 4])), mean=array([2., 3.]), variance=array([2., 2.]), skewness=array([0., 0.]), kurtosis=array([-2., -2.])) rrrzThe input must not be empty.r )rrrrq)r8rrrmasked_invalid mstats_basicrOr:rrr"rrrgrMrNr) rrrrqrr contains_nanrmmmvskkurts rrOrOsL  B1r*GA,Q;L f,   a $$Qd99qzQ788  A &&& q 4 5B A Q,A aD !B A$ 'D !r 00rcdUc [U5OUnUS:XaURU5nU$US:XaURU5nU$US:Xa\SU(a URURU55O/UR URU5URU55-nU$Sn[ U5e)zKGet p-value given the statistic, (continuous) distribution, and alternativelessgreater two-sidedrz8`alternative` must be 'less', 'greater', or 'two-sided'.)r8cdfsfrVminimumr)r distribution alternative symmetricrrrs r _get_pvaluers')z #rBf!!), M  !+ M  #IloobffY&78::l&6&6y&A&2ooi&@BC MM!!rSkewtestResultrr)rrrcz[U5n[XUS9up[XSS9nURUnUS:aSU<S3n[ U5eU[ R "US-US--S US - -- 5-nS US -S U--S - -US--US--US- US--US--US--- n S[ R "S U S- -5-n S[ R "S[ R"U 5-5- n [ R "SU S- - 5n URUS:HURSURS9U5nXRX- UR X- S -S-5-5-n [U [5X4S9nU RS:XaU SOU n URS:XaUSOUn[X5$)ae 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. Must contain at least eight observations. 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. See Also -------- :ref:`hypothesis_skewtest` : Extended example 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) For a more detailed example, see :ref:`hypothesis_skewtest`. rTr,z4`skewtest` requires at least 8 observations; only n= observations were given.rrl@rr|FrorSr rr.rrr)r8rrMrrmathsqrtrrrrr _SimpleNormalrr)rrrrrb2rrybeta2W2deltaalphaZrs rrPrPs\  B1r*GA a %B  A1u$79!! TYYQ1q5)cQUm< ==A AqD2a4K"$ %1 -1 5u1o1%1-/E diiUQY( (B  # ,- -E IIcR!Vn %E aAQWW5q9A qy277AI>A+=#>>??A MO[ @F1"!A!;;!+VBZF ! $$rKurtosistestResultr{c [U5n[XUS9upURUnUS:aSU<S3n[U5eUS:aSU<S3n[R "USS9 [ XS S S 9nS US - -US -- nSU-US- -US- -US -US--US--US--- n Xx- U S-- n SXU-SU-- S--US-US--- SUS--US--XUS- -US- -- S--n SSU - SU - S SU S-- -S----n S SSU -- - n S U SU S- - S---n[XS9n[U5URUS:HUS SU - - URU5- S-5-nURUS:H5(aSn[R "U[SS9 U U- SSU -- S-- n[U[5X4S9nURS:XaUSOUnURS:XaUSOUn[!UU5$)au 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. Must contain at least five observations. 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. See Also -------- :ref:`hypothesis_kurtosistest` : Extended example Notes ----- Valid only for n>20. This function uses the method described in [1]_. References ---------- .. [1] F. J. Anscombe, W. J. Glynn, "Distribution of the kurtosis statistic b2 for normal samples", Biometrika, vol. 70, pp. 227-234, 1983. Examples -------- >>> import numpy as np >>> from scipy.stats import kurtosistest >>> kurtosistest(list(range(20))) KurtosistestResult(statistic=-1.7058104152122062, pvalue=0.08804338332528348) >>> kurtosistest(list(range(20)), alternative='less') KurtosistestResult(statistic=-1.7058104152122062, pvalue=0.04402169166264174) >>> kurtosistest(list(range(20)), alternative='greater') KurtosistestResult(statistic=-1.7058104152122062, pvalue=0.9559783083373583) >>> rng = np.random.default_rng() >>> s = rng.normal(0, 1, 1000) >>> kurtosistest(s) KurtosistestResult(statistic=-1.475047944490622, pvalue=0.14019965402996987) For a more detailed example, see :ref:`hypothesis_kurtosistest`. rrSz8`kurtosistest` requires at least 5 observations; only n=rzQ`kurtosistest` p-value may be inaccurate with fewer than 20 observations; only n=rrFT)r}r-r|rg8@rlrr.rrrg @ro@g"@r gUUUUUU?rz\Test statistic not defined in some cases due to division by zero. Return nan in that case...r)r8rrrrrrNrr<rrVrrrrrr)rrrrrrrrEvarb2r sqrtbeta1Aterm1denomrterm2msgrrs rrQrQ~sR  B1r*GA  A1u$79!!2v,)*,EG g!, !%$ 7B QqS QqSA FAaCL!A# 1Q32,!"4ac": ;E AQS1WQY!A#!-#qs)QqS/45sGQqSM2CEH1III c)ms9}#y!|2D0Ds/JJKKA 3q5 ME Q#Y$$ $E 1 C ENRXXeslC()#a%'>#&FH HE vveqj2 c>a8 1c!e9s**A MO[ @F1"!A!;;!+VBZF a ((rNormaltestResultc[U5n[XSS9upE[XSS9upeXD-Xf--n[UR S55n[ XxSSUS9n UR S:XaUSOUnU R S:XaU SOU n [Xy5$) a3Test 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. Must contain at least eight observations. 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. See Also -------- :ref:`hypothesis_normaltest` : Extended example References ---------- .. [1] D'Agostino, R. B. (1971), "An omnibus test of normality for moderate and large sample size", Biometrika, 58, 341-348 .. [2] D'Agostino, R. and Pearson, E. S. (1973), "Tests for departure from normality", Biometrika, 60, 613-622 Examples -------- >>> import numpy as np >>> from scipy import stats >>> rng = np.random.default_rng() >>> pts = 1000 >>> a = rng.normal(0, 1, size=pts) >>> b = rng.normal(2, 1, size=pts) >>> x = np.concatenate((a, b)) >>> res = stats.normaltest(x) >>> res.statistic 53.619... # random >>> res.pvalue 2.273917413209226e-12 # random For a more detailed example, see :ref:`hypothesis_normaltest`. Tr,rorFrrrrr)r8rPrQ _SimpleChi2rrrr) rrrrrdrkrchi2rs rrRrRs|  B Ad +DA $ /DAac I rzz"~ &D i5UW XF!*1!4 " )I!;;!+VBZF I ..r)r r c[U5nURU5nUcURUS5nSnURUnUS:Xa [ S5eUR XSS9nX- n[ XQSS9n[XQSS9nUS- US-US-S - --n[URS 55n [XS S US 9n URS:XaUSOUnU RS:XaU SOU n [X5$)aqPerform the Jarque-Bera goodness of fit test on sample data. The Jarque-Bera test tests whether the sample data has the skewness and kurtosis matching a normal distribution. Note that this test only works for a large enough number of data samples (>2000) as the test statistic asymptotically has a Chi-squared distribution with 2 degrees of freedom. Parameters ---------- x : array_like Observations of a random variable. axis : int or None, default: 0 If an int, the axis of the input along which to compute the statistic. The statistic of each axis-slice (e.g. row) of the input will appear in a corresponding element of the output. If ``None``, the input will be raveled before computing the statistic. Returns ------- result : SignificanceResult An object with the following attributes: statistic : float The test statistic. pvalue : float The p-value for the hypothesis test. See Also -------- :ref:`hypothesis_jarque_bera` : Extended example References ---------- .. [1] Jarque, C. and Bera, A. (1980) "Efficient tests for normality, homoscedasticity and serial independence of regression residuals", 6 Econometric Letters 255-259. Examples -------- >>> import numpy as np >>> from scipy import stats >>> rng = np.random.default_rng() >>> x = rng.normal(0, 1, 100000) >>> jarque_bera_test = stats.jarque_bera(x) >>> jarque_bera_test Jarque_beraResult(statistic=3.3415184718131554, pvalue=0.18810419594996775) >>> jarque_bera_test.statistic 3.3415184718131554 >>> jarque_bera_test.pvalue 0.18810419594996775 For a more detailed example, see :ref:`hypothesis_jarque_bera`. rrz%At least one observation is required.TrD)rr-rr{rorFrr) r8rrrrrrMrNrrrr) rrrrmudiffxrdrrrrs rrSrSAst  B 1 A | JJq%   AAv@AA  -B FE U-AD1AAA1q)I rzz"~ &D i5UW XF!*1!4 " )I!;;!+VBZF i 00rc[R"U5nURS:Xa{[R"U5(a[R$[R "[R"U5R [R[RS9$U(aXSU:*XS:*-n[R"XS9nUcSn[XQX45$)a0Calculate the score at a given percentile of the input sequence. For example, the score at ``per=50`` is the median. If the desired quantile lies between two data points, we interpolate between them, according to the value of `interpolation`. If the parameter `limit` is provided, it should be a tuple (lower, upper) of two values. Parameters ---------- a : array_like A 1-D array of values from which to extract score. per : array_like Percentile(s) at which to extract score. Values should be in range [0,100]. limit : tuple, optional Tuple of two scalars, the lower and upper limits within which to compute the percentile. Values of `a` outside this (closed) interval will be ignored. interpolation_method : {'fraction', 'lower', 'higher'}, optional Specifies the interpolation method to use, when the desired quantile lies between two data points `i` and `j` The following options are available (default is 'fraction'): * 'fraction': ``i + (j - i) * fraction`` where ``fraction`` is the fractional part of the index surrounded by ``i`` and ``j`` * 'lower': ``i`` * 'higher': ``j`` axis : int, optional Axis along which the percentiles are computed. Default is None. If None, compute over the whole array `a`. Returns ------- score : float or ndarray Score at percentile(s). See Also -------- percentileofscore, numpy.percentile Notes ----- This function will become obsolete in the future. For NumPy 1.9 and higher, `numpy.percentile` provides all the functionality that `scoreatpercentile` provides. And it's significantly faster. Therefore it's recommended to use `numpy.percentile` for users that have numpy >= 1.9. Examples -------- >>> import numpy as np >>> from scipy import stats >>> a = np.arange(100) >>> stats.scoreatpercentile(a, 50) 49.5 rrrr ) rrrisscalarrfullrrEsort_compute_qth_percentile)rperlimitinterpolation_methodrsorted_s rrTrTs| 1 Avv{ ;;s  66M772::c?00"&& K K Qx1}Ah/ 0gga#G | "71E LLrc |[R"U5(d2UVs/sHn[XX#5PM nn[R"U5$SUs=::aS::d O [ S5e[ S5/UR -nUS- URUS- -n[U5U:wa^US:Xa [[R"U55nO8US:Xa [[R"U55nOUS:XaO [ S 5e[U5nXG:Xa[ XDS-5Xc'[S5nS n OU[ XDS -5Xc'US-n [X- Xt- /[5nS/UR -n S X'XlUR5n [RRU[U5U-US 9U - $s snf) Nrdz(percentile must be in the range [0, 100]Y@rlowerhigherfractionz@interpolation_method can only be 'fraction', 'lower' or 'higher'rrr )rrrrrslicerrrfloorceilrraddreducer) rrrrrscoreindexeridxrsumvaljwshapes rrrs ;;s  Q))=E xx OOCDDT{mgll*G * d+a/ 0C 3x3 7 *bhhsm$C !X -bggcl#C !Z / 34 4 CAxaQ (aQ E!'SW.6w||#   66==w07:= F OOMsF9c[R"U5n[U5n[R"U5n[X5upV[X5upxU(dU(aUS:Xa [ S5eU(a+[ R "[R"U5U5nU(aIUS:Xa;[ R "[R"U5U5nUR5nUS:XaSnUS:Xa3[R"U[R[RS9n OUSnSn US :Xa&U "X:5n U "X:*5n X:n X-U -S U- -n O^US :XaU "X:5S U- -n OGUS :XaU "X:*5S U- -n O0US:XaU "X:5n U "X:*5n X-S U- -n O [ S5e[ R"U [R5n U RS:XaU S$U $)a Compute the percentile rank of a score relative to a list of scores. A `percentileofscore` of, for example, 80% means that 80% of the scores in `a` are below the given score. In the case of gaps or ties, the exact definition depends on the optional keyword, `kind`. Parameters ---------- a : array_like A 1-D array to which `score` is compared. score : array_like Scores to compute percentiles for. kind : {'rank', 'weak', 'strict', 'mean'}, optional Specifies the interpretation of the resulting score. The following options are available (default is 'rank'): * 'rank': Average percentage ranking of score. In case of multiple matches, average the percentage rankings of all matching scores. * 'weak': This kind corresponds to the definition of a cumulative distribution function. A percentileofscore of 80% means that 80% of values are less than or equal to the provided score. * 'strict': Similar to "weak", except that only values that are strictly less than the given score are counted. * 'mean': The average of the "weak" and "strict" scores, often used in testing. See https://en.wikipedia.org/wiki/Percentile_rank nan_policy : {'propagate', 'raise', 'omit'}, optional Specifies how to treat `nan` values in `a`. The following options are available (default is 'propagate'): * 'propagate': returns nan (for each value in `score`). * 'raise': throws an error * 'omit': performs the calculations ignoring nan values Returns ------- pcos : float Percentile-position of score (0-100) relative to `a`. See Also -------- numpy.percentile scipy.stats.scoreatpercentile, scipy.stats.rankdata Examples -------- Three-quarters of the given values lie below a given score: >>> import numpy as np >>> from scipy import stats >>> stats.percentileofscore([1, 2, 3, 4], 3) 75.0 With multiple matches, note how the scores of the two matches, 0.6 and 0.8 respectively, are averaged: >>> stats.percentileofscore([1, 2, 3, 3, 4], 3) 70.0 Only 2/5 values are strictly less than 3: >>> stats.percentileofscore([1, 2, 3, 3, 4], 3, kind='strict') 40.0 But 4/5 values are less than or equal to 3: >>> stats.percentileofscore([1, 2, 3, 3, 4], 3, kind='weak') 80.0 The average between the weak and the strict scores is: >>> stats.percentileofscore([1, 2, 3, 3, 4], 3, kind='mean') 60.0 Score arrays (of any dimensionality) are supported: >>> stats.percentileofscore([1, 2, 3, 3, 4], [2, 3]) array([40., 70.]) The inputs can be infinite: >>> stats.percentileofscore([-np.inf, 0, 1, np.inf], [1, 2, np.inf]) array([75., 75., 100.]) If `a` is empty, then the resulting percentiles are all `nan`: >>> stats.percentileofscore([], [1, 2]) array([nan, nan]) raisezThe input contains nan valuesrrrr).Nc0[R"US5$Nr)r count_nonzerors rr percentileofscore..counts##Ar* *rrankgI@strictrweakrz3kind can only be 'rank', 'strict', 'weak' or 'mean'r)rrrrrr masked_whererr full_likerrEfilledr)rrkindrrcnanpacnsnpsperctrleftrightplus1s rrUrUst 1 A AA JJu EQ+HCU/HC s g-899 7   Q/A A  $A Av UBFF"**=i  + 6>#D!*%ELE\E)dQh7E X !)$ 2E V^!*%3E V^#D!*%E\dQh/EEG G IIeRVV $E zzQRy LrHistogramResult)rr#binsize extrapointsc [R"U5nUcHURS:XaSnO5UR5nUR 5nXe- SUS- -- nXW- Xg-4n[R "XUUS9up[R "U[S9nU SU S- n [UV s/sHn USU :d XS:dMU PM sn 5n U S:aU(a[R"SU 3S S 9 [XSX5$s sn f) 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. rrrror)binsrGrrrz'Points outside given histogram range = rlr) rrrr"r histogramrrrrrr) rnumbins defaultlimitsr printextrasdata_mindata_maxrdhist bin_edgesrrrs r _histogramrs^  A 66Q;"MuuwHuuwH$w|)<=A%\8<8Mll1-+24OD 88D &DlYq\)G!H!Q'*Q.!A6F2F!HIKQ; ? }M!" % 4q!17 HH Hs 'DD CumfreqResult)cumcountr#rrcd[XX#S9upEpg[R"US-SS9n[XXg5$)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 numpy as np >>> import matplotlib.pyplot as plt >>> from scipy import stats >>> rng = np.random.default_rng() >>> x = [1, 4, 2, 1, 3, 1] >>> res = stats.cumfreq(x, numbins=4, defaultreallimits=(1.5, 5)) >>> res.cumcount array([ 1., 2., 3., 3.]) >>> res.extrapoints 3 Create a normal distribution with 1000 random values >>> samples = stats.norm.rvs(size=1000, random_state=rng) Calculate cumulative frequencies >>> res = stats.cumfreq(samples, numbins=25) Calculate space of values for x >>> x = res.lowerlimit + np.linspace(0, res.binsize*res.cumcount.size, ... res.cumcount.size) Plot histogram and cumulative histogram >>> fig = plt.figure(figsize=(10, 4)) >>> ax1 = fig.add_subplot(1, 2, 1) >>> ax2 = fig.add_subplot(1, 2, 2) >>> ax1.hist(samples, bins=25) >>> ax1.set_title('Histogram') >>> ax2.bar(x, res.cumcount, width=res.binsize) >>> ax2.set_title('Cumulative histogram') >>> ax2.set_xlim([x.min(), x.max()]) >>> plt.show() rrrr )rrcumsumr) rrdefaultreallimitsrhlrecumhists rrVrV s7PA(9KJA!iiAA&G Q **r RelfreqResult) frequencyr#rrc[R"U5n[XX#S9upEpgX@RS- n[ XEXg5$)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 numpy as np >>> import matplotlib.pyplot as plt >>> from scipy import stats >>> rng = np.random.default_rng() >>> a = np.array([2, 4, 1, 2, 3, 2]) >>> res = stats.relfreq(a, numbins=4) >>> res.frequency array([ 0.16666667, 0.5 , 0.16666667, 0.16666667]) >>> np.sum(res.frequency) # relative frequencies should add up to 1 1.0 Create a normal distribution with 1000 random values >>> samples = stats.norm.rvs(size=1000, random_state=rng) Calculate relative frequencies >>> res = stats.relfreq(samples, numbins=25) Calculate space of values for x >>> x = res.lowerlimit + np.linspace(0, res.binsize*res.frequency.size, ... res.frequency.size) Plot relative frequency histogram >>> fig = plt.figure(figsize=(5, 4)) >>> ax = fig.add_subplot(1, 1, 1) >>> ax.bar(x, res.frequency, width=res.binsize) >>> ax.set_title('Relative frequency histogram') >>> ax.set_xlim([x.min(), x.max()]) >>> plt.show() rr)r asanyarrayrrr )rrrrrrrrs rrWrWW s@J aAA(9KJA! GGAJA q $$rc[R"[R"[5R5n/nSnUHn[R "U5n[ U5n[R"U5nXW- S-nUR5n US- U-U-SU -- US- US- -- n XS- - n [U [R"U 5- 5U:a [S5eURU 5 URnM U(a6USSH-n X>> 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. Nrrnr.rz'Lack of convergence in obrientransform.rr)rrrTrrUrrrrrVrrHrrobject) samplesTINYrsLastsamplerrrsqsumsqtrfarrs rrXrX s)r 77288E?&& 'DF E JJv  F WWQZfq[#g]R #+ -1q5QU2C D1uo sRWWQZ 4 'FG G a#& #2;C !xxf55 88F rcU$rrrs rrr rrcU4$rrrs rrr rjr)rrrc[U5nUcURUS5nSn[R"UR U5SUS9nUR UnUR XUS9US-- nU$)aCompute 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. Must contain at least two observations. axis : int or None, optional Axis along which to operate. Default is 0. If None, compute over the whole array `a`. ddof : int, optional Delta degrees-of-freedom. How many degrees of freedom to adjust for bias in limited samples relative to the population estimate of variance. Defaults to 1. nan_policy : {'propagate', 'raise', 'omit'}, optional Defines how to handle when input contains nan. The following options are available (default is 'propagate'): * 'propagate': returns nan * 'raise': throws an error * 'omit': performs the calculations ignoring nan values Returns ------- s : ndarray or float The standard error of the mean in the sample(s), along the input axis. Notes ----- The default value for `ddof` is different to the default (0) used by other ddof containing routines, such as np.std and np.nanstd. Examples -------- Find standard error along the first axis: >>> import numpy as np >>> from scipy import stats >>> a = np.arange(20).reshape(5,4) >>> stats.sem(a) array([ 2.8284, 2.8284, 2.8284, 2.8284]) Find standard error across the whole array, using n degrees of freedom: >>> stats.sem(a, axis=None, ddof=0) 1.2893796958227628 rrr)rr)rrr.)r8rxpx atleast_ndrrstd)rrrrrrrds rrYrY spn  B | JJq%  rzz!}14A  A q-36A HrcU[R"U5)nURS:Xa[R"S/5$USU:HR SS9$)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. rT)r)rrrrrrrs r_isconstr A sL 288A;,Avv{xx! --rc[XXUS9$)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`. See Also -------- numpy.mean : Arithmetic average numpy.std : Arithmetic standard deviation scipy.stats.gzscore : Geometric standard score Notes ----- This function preserves ndarray subclasses, and works also with matrices and masked arrays (it uses `asanyarray` instead of `asarray` for parameters). References ---------- .. [1] "Standard score", *Wikipedia*, https://en.wikipedia.org/wiki/Standard_score. .. [2] Huck, S. W., Cross, T. L., Clark, S. B, "Overcoming misconceptions about Z-scores", Teaching Statistics, vol. 8, pp. 38-40, 1986 Examples -------- >>> import numpy as np >>> a = np.array([ 0.7972, 0.0767, 0.4383, 0.7866, 0.8091, ... 0.1954, 0.6307, 0.6599, 0.1065, 0.0508]) >>> from scipy import stats >>> stats.zscore(a) array([ 1.1273, -1.247 , -0.0552, 1.0923, 1.1664, -0.8559, 0.5786, 0.6748, -1.1488, -1.3324]) Computing along a specified axis, using n-1 degrees of freedom (``ddof=1``) to calculate the standard deviation: >>> b = np.array([[ 0.3148, 0.0478, 0.6243, 0.4608], ... [ 0.7149, 0.0775, 0.6072, 0.9656], ... [ 0.6341, 0.1403, 0.9759, 0.4064], ... [ 0.5918, 0.6948, 0.904 , 0.3721], ... [ 0.0921, 0.2481, 0.1188, 0.1366]]) >>> stats.zscore(b, axis=1, ddof=1) array([[-0.19264823, -1.28415119, 1.07259584, 0.40420358], [ 0.33048416, -1.37380874, 0.04251374, 1.00081084], [ 0.26796377, -1.12598418, 1.23283094, -0.37481053], [-0.22095197, 0.24468594, 1.19042819, -1.21416216], [-0.82780366, 1.4457416 , -0.43867764, -0.1792603 ]]) An example with ``nan_policy='omit'``: >>> x = np.array([[25.11, 30.10, np.nan, 32.02, 43.15], ... [14.95, 16.06, 121.25, 94.35, 29.81]]) >>> stats.zscore(x, axis=1, nan_policy='omit') array([[-1.13490897, -0.37830299, nan, -0.08718406, 1.60039602], [-0.91611681, -0.89090508, 1.4983032 , 0.88731639, -0.5785977 ]]) rrr)rZ)rrrrs rr[r[Q sd 4z BBrr"c[U5n[XS9n[U[R5(a[R O UR n[ U"U5XUS9$)a Compute the geometric standard score. Compute the geometric z score of each strictly positive value in the sample, relative to the geometric mean and standard deviation. Mathematically the geometric z score can be evaluated as:: gzscore = log(a/gmu) / log(gsigma) where ``gmu`` (resp. ``gsigma``) is the geometric mean (resp. standard deviation). Parameters ---------- a : array_like Sample data. axis : int or None, optional Axis along which to operate. Default is 0. If None, compute over the whole array `a`. ddof : int, optional Degrees of freedom correction in the calculation of the standard deviation. Default is 0. nan_policy : {'propagate', 'raise', 'omit'}, optional Defines how to handle when input contains nan. 'propagate' returns nan, 'raise' throws an error, 'omit' performs the calculations ignoring nan values. Default is 'propagate'. Note that when the value is 'omit', nans in the input also propagate to the output, but they do not affect the geometric z scores computed for the non-nan values. Returns ------- gzscore : array_like The geometric z scores, standardized by geometric mean and geometric standard deviation of input array `a`. See Also -------- gmean : Geometric mean gstd : Geometric standard deviation zscore : Standard score Notes ----- This function preserves ndarray subclasses, and works also with matrices and masked arrays (it uses ``asanyarray`` instead of ``asarray`` for parameters). .. versionadded:: 1.8 References ---------- .. [1] "Geometric standard score", *Wikipedia*, https://en.wikipedia.org/wiki/Geometric_standard_deviation#Geometric_standard_score. Examples -------- Draw samples from a log-normal distribution: >>> import numpy as np >>> from scipy.stats import zscore, gzscore >>> import matplotlib.pyplot as plt >>> rng = np.random.default_rng() >>> mu, sigma = 3., 1. # mean and standard deviation >>> x = rng.lognormal(mu, sigma, size=500) Display the histogram of the samples: >>> fig, ax = plt.subplots() >>> ax.hist(x, 50) >>> plt.show() Display the histogram of the samples standardized by the classical zscore. Distribution is rescaled but its shape is unchanged. >>> fig, ax = plt.subplots() >>> ax.hist(zscore(x), 50) >>> plt.show() Demonstrate that the distribution of geometric zscores is rescaled and quasinormal: >>> fig, ax = plt.subplots() >>> ax.hist(gzscore(x), 50) >>> plt.show() rr")r8rrr MaskedArrayrr[)rrrrrrs rr\r\ sKp  Ba'Aq"..11"&&rvvC #a&t: FFrc dXLn[X5n[XUS9up[R"5 U(a[R"S[ 5 [ XSUS9n[XUSUS9S-nSSS5 [R"SSS9 [UWX&S S 9W- n SSS5 U(aeURW R5Rn WURU W-5:*n URXR 5n UR"X'W $!,(df  N=f!,(df  N=f) 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]) rrT)rrr)rrrrr.NrrF)rrO)r8rrrrr-rrrrr[rTrrUrV broadcast_torr) scorescomparerrr like_zscorermnrzrUrus rrZrZ sl$K  )B+FCOF  "   ! !(,> ? g4J OgT# <=@A # Xh 7 FBu E K 8 hhqww##bffS2X&&tWW-&& H' # " 8 7s=D D! D! D/c [R"U5n[U[R5(a-Sn[ R "U[SS9 [RnO[Rn[R"SSS9 [R"[R"U"U5XS95nSSS5 US:*R5(aS n[ R "U[SS9 W$!,(df  ND=f) aZ 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 exponential of the standard deviation of the natural logarithms of the observations. Parameters ---------- a : array_like An array containing finite, strictly positive, real numbers. .. deprecated:: 1.14.0 Support for masked array input was deprecated in SciPy 1.14.0 and will be removed in version 1.16.0. 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 ------- gstd : ndarray or float An array of the geometric standard deviation. If `axis` is None or `a` is a 1d array a float is returned. See Also -------- gmean : Geometric mean numpy.std : Standard deviation gzscore : Geometric standard score Notes ----- Mathematically, the sample geometric standard deviation :math:`s_G` can be defined in terms of the natural logarithms of the observations :math:`y_i = \log(x_i)`: .. math:: s_G = \exp(s), \quad s = \sqrt{\frac{1}{n - d} \sum_{i=1}^n (y_i - \bar y)^2} where :math:`n` is the number of observations, :math:`d` is the adjustment `ddof` to the degrees of freedom, and :math:`\bar y` denotes the mean of the natural logarithms of the observations. Note that the default ``ddof=1`` is different from the default value used by similar functions, such as `numpy.std` and `numpy.var`. When an observation is infinite, the geometric standard deviation is NaN (undefined). Non-positive observations will also produce NaNs in the output because the *natural* logarithm (as opposed to the *complex* logarithm) is defined and finite only for positive reals. The geometric standard deviation is sometimes confused with the exponential of the standard deviation, ``exp(std(a))``. Instead, the geometric standard deviation is ``exp(std(log(a)))``. References ---------- .. [1] "Geometric standard deviation", *Wikipedia*, https://en.wikipedia.org/wiki/Geometric_standard_deviation. .. [2] Kirkwood, T. B., "Geometric means and measures of dispersion", Biometrics, vol. 35, pp. 908-909, 1979 Examples -------- Find the geometric standard deviation of a log-normally distributed sample. Note that the standard deviation of the distribution is one; on a log scale this evaluates to approximately ``exp(1)``. >>> import numpy as np >>> from scipy.stats import gstd >>> rng = np.random.default_rng() >>> sample = rng.lognormal(mean=0, sigma=1, size=1000) >>> gstd(sample) 2.810010162475324 Compute the geometric standard deviation of a multidimensional array and of a given axis. >>> a = np.arange(1, 25).reshape(2, 3, 4) >>> gstd(a, axis=None) 2.2944076136018947 >>> gstd(a, axis=2) array([[1.82424757, 1.22436866, 1.13183117], [1.09348306, 1.07244798, 1.05914985]]) >>> gstd(a, axis=(1,2)) array([2.12939215, 1.22120169]) zk`gstd` support for masked array input was deprecated in SciPy 1.14.0 and will be removed in version 1.16.0.rrrr&rrNrzThe geometric standard deviation is only defined if all elements are greater than or equal to zero; otherwise, the result is NaN.)rr rrr$rrDeprecationWarningrrrrrr)rrrrrr$s rr^r^T s~ aA!R^^$$I g1a@ffff Xh 7ffRVVCF9: 8 Q||~~V g~!< J 8 7s 0C66 Dnormalr.rocU$rrrs rrr rrcU4$rrrs rrr rjrr)rrr rrcf[U5nUR(d [U5$[U[5(a1UR 5nU[ ;a[US35e[ Un[X5upU(aUS:Xa[Rn O[Rn [U5S:wa [S5e[R"U5R5(a [S5e[!U5nU "XXUS9n [R""U SU S5n US :waX-n U $) a= Compute the interquartile range of the data along the specified axis. The interquartile range (IQR) is the difference between the 75th and 25th percentile of the data. It is a measure of the dispersion similar to standard deviation or variance, but is much more robust against outliers [2]_. The ``rng`` parameter allows this function to compute other percentile ranges than the actual IQR. For example, setting ``rng=(0, 100)`` is equivalent to `numpy.ptp`. The IQR of an empty array is `np.nan`. .. versionadded:: 0.18.0 Parameters ---------- x : array_like Input array or object that can be converted to an array. axis : int or sequence of int, optional Axis along which the range is computed. The default is to compute the IQR for the entire array. rng : Two-element sequence containing floats in range of [0,100] optional Percentiles over which to compute the range. Each must be between 0 and 100, inclusive. The default is the true IQR: ``(25, 75)``. The order of the elements is not important. scale : scalar or str or array_like of reals, optional The numerical value of scale will be divided out of the final result. The following string value is also recognized: * 'normal' : Scale by :math:`2 \sqrt{2} erf^{-1}(\frac{1}{2}) \approx 1.349`. The default is 1.0. Array-like `scale` of real dtype is also allowed, as long as it broadcasts correctly to the output such that ``out / scale`` is a valid operation. The output dimensions depend on the input array, `x`, the `axis` argument, and the `keepdims` flag. nan_policy : {'propagate', 'raise', 'omit'}, optional Defines how to handle when input contains nan. The following options are available (default is 'propagate'): * 'propagate': returns nan * 'raise': throws an error * 'omit': performs the calculations ignoring nan values interpolation : str, optional Specifies the interpolation method to use when the percentile boundaries lie between two data points ``i`` and ``j``. The following options are available (default is 'linear'): * 'linear': ``i + (j - i)*fraction``, where ``fraction`` is the fractional part of the index surrounded by ``i`` and ``j``. * 'lower': ``i``. * 'higher': ``j``. * 'nearest': ``i`` or ``j`` whichever is nearest. * 'midpoint': ``(i + j)/2``. For NumPy >= 1.22.0, the additional options provided by the ``method`` keyword of `numpy.percentile` are also valid. keepdims : bool, optional If this is set to True, the reduced axes are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the original array `x`. Returns ------- iqr : scalar or ndarray If ``axis=None``, a scalar is returned. If the input contains integers or floats of smaller precision than ``np.float64``, then the output data-type is ``np.float64``. Otherwise, the output data-type is the same as that of the input. See Also -------- numpy.std, numpy.var References ---------- .. [1] "Interquartile range" https://en.wikipedia.org/wiki/Interquartile_range .. [2] "Robust measures of scale" https://en.wikipedia.org/wiki/Robust_measures_of_scale .. [3] "Quantile" https://en.wikipedia.org/wiki/Quantile Examples -------- >>> import numpy as np >>> from scipy.stats import iqr >>> x = np.array([[10, 7, 4], [3, 2, 1]]) >>> x array([[10, 7, 4], [ 3, 2, 1]]) >>> iqr(x) 4.0 >>> iqr(x, axis=0) array([ 3.5, 2.5, 1.5]) >>> iqr(x, axis=1) array([ 3., 1.]) >>> iqr(x, axis=1, keepdims=True) array([[ 3.], [ 1.]]) z not a valid scale for `iqr`rrz+quantile range must be two element sequencezrange must not contain NaNs)rmethodrrrr)rrrrstrr_scale_conversionsrrr nanpercentile percentilerrrrsortedsubtract) rrrngscaler interpolationr scale_keyrpercentile_funcpctouts rr]r] s ^  A 66{%KKM . .w&BCD D"9- -Q;L f,**-- 3x1}EFF xx}677 +C !t#+ -C ++c!fc!f %C |  Jrc:[R"U5nUR5(aUS:Xa[R$X)nURS:Xa[R$U"U5n[R "[R "X- 55nU$)Nrr)rrrrrmedianrV)rrBrrmedmads r_mad_1drFb sp HHQKE yy{{  $66M fIvv{vv )C ))BFF17O $C Jrc^[U5(d[S[U5S35e[U[5(a%UR 5S:XaSnO[ US35e[U5nUR(dvTc[R$[U4Sj[UR555nUS:Xa[R$[R"U[R5$[X5updU(aCTc[!UR#5X$5nXs- $[R$"[ TXU5nXs- $Tc7U"USS 9n[R&"[R("X- 55nXs- $[R*"U"UTS 9T5n[R&"[R("X- 5TS 9nXs- $) 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: >>> import numpy as np >>> from scipy import stats >>> x = stats.norm.rvs(size=100, scale=1, random_state=123456) >>> x.std() 0.9973906394005013 >>> stats.median_abs_deviation(x) 0.82832610097857 >>> x[0] = 345.6 >>> x.std() 34.42304872314415 >>> stats.median_abs_deviation(x) 0.8323442311590675 Axis handling example: >>> x = np.array([[10, 7, 4], [3, 2, 1]]) >>> x array([[10, 7, 4], [ 3, 2, 1]]) >>> stats.median_abs_deviation(x) array([3.5, 2.5, 1.5]) >>> stats.median_abs_deviation(x, axis=None) 2.0 Scale normal example: >>> x = stats.norm.rvs(size=1000000, scale=2, random_state=123456) >>> stats.median_abs_deviation(x) 1.3487398527041636 >>> stats.median_abs_deviation(x, scale='normal') 1.9996446978061115 z8The argument 'center' must be callable. The given value z is not callable.r0gIRk?z is not a valid scale value.Nc3<># UHupUT:wdM Uv M g7frr).0ritemrs r 'median_abs_deviation.. sN.@71AI$$.@s  rr )callablerreprrr5rrrrrrr enumeraterrrrFrapply_along_axisrCrV expand_dims) rrrBr<r nan_shaperrErDs ` rr_r_x s\ F  !!%f.?AB B % ;;=H $&Ew&BCD D A 66 <66MNi.@NN ?66Mwwy"&&)),Q;L <!'')V8C ;%%gtQ KC ; <&C))BFF17O,C ;..!5t mean(c) + std(c)*high The iteration continues with the updated sample until no elements are outside the (updated) range. Parameters ---------- a : array_like Data array, will be raveled if not 1-D. low : float, optional Lower bound factor of sigma clipping. Default is 4. high : float, optional Upper bound factor of sigma clipping. Default is 4. Returns ------- clipped : ndarray Input array with clipped elements removed. lower : float Lower threshold value use for clipping. upper : float Upper threshold value use for clipping. Examples -------- >>> import numpy as np >>> from scipy.stats import sigmaclip >>> a = np.concatenate((np.linspace(9.5, 10.5, 31), ... np.linspace(0, 20, 5))) >>> fact = 1.5 >>> c, low, upp = sigmaclip(a, fact, fact) >>> c array([ 9.96666667, 10. , 10.03333333, 10. ]) >>> c.var(), c.std() (0.00055555555555555165, 0.023570226039551501) >>> low, c.mean() - fact*c.std(), c.min() (9.9646446609406727, 9.9646446609406727, 9.9666666666666668) >>> upp, c.mean() + fact*c.std(), c.max() (10.035355339059327, 10.035355339059327, 10.033333333333333) >>> a = np.concatenate((np.linspace(9.5, 10.5, 11), ... np.linspace(-100, -50, 3))) >>> c, low, upp = sigmaclip(a, 1.8, 1.8) >>> (c == np.linspace(9.5, 10.5, 11)).all() True r)rrrrrrrS) rlowhighcrc_stdc_meanr critlower crituppers rr`r` sn 1 A E vvS[( T\) I~!.1 2vv  % 1i 33rc|[R"U5nURS:XaU$UcUR5nSnURUn[ X-5nX4- nXE:a [ S5e[R"XUS- 4U5n[S5/UR-n[XE5Xr'U[U5$)aSlice off a proportion of items from both ends of an array. Slice off the passed proportion of items from both ends of the passed array (i.e., with `proportiontocut` = 0.1, slices leftmost 10% **and** rightmost 10% of scores). The trimmed values are the lowest and highest ones. Slice off less if proportion results in a non-integer slice index (i.e. conservatively slices off `proportiontocut`). Parameters ---------- a : array_like Data to trim. proportiontocut : float Proportion (in range 0-1) of total data set to trim of each end. axis : int or None, optional Axis along which to trim data. Default is 0. If None, compute over the whole array `a`. Returns ------- out : ndarray Trimmed version of array `a`. The order of the trimmed content is undefined. See Also -------- trim_mean Examples -------- Create an array of 10 values and trim 10% of those values from each end: >>> import numpy as np >>> from scipy import stats >>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> stats.trimboth(a, 0.1) array([1, 3, 2, 4, 5, 6, 7, 8]) Note that the elements of the input array are trimmed by value, but the output array is not necessarily sorted. The proportion to trim is rounded down to the nearest integer. For instance, trimming 25% of the values from each end of an array of 10 values will return an array of 6 values: >>> b = np.arange(10) >>> stats.trimboth(b, 1/4).shape (6,) Multidimensional arrays can be trimmed along any axis or across the entire array: >>> c = [2, 4, 6, 8, 0, 1, 3, 5, 7, 9] >>> d = np.array([a, b, c]) >>> stats.trimboth(d, 0.4, axis=0).shape (1, 10) >>> stats.trimboth(d, 0.4, axis=1).shape (3, 2) >>> stats.trimboth(d, 0.4, axis=None).shape (6,) rNProportion too big.r) rrrrrrr partitionrrrrproportiontocutrrlowercutuppercutatmpsls rrara_ s@ 1 Avv{ | GGI 774=D?)*HH.// <<hl3T :D + "BX(BH b ?rc[R"U5nUcUR5nSnURUnUS:a/$UR 5S:XaSnU[ X-5- nO#UR 5S:Xa[ X-5nUn[R "UWWS- 4U5n[S5/UR-n[XV5X'U[U5$)alSlice off a proportion from ONE end of the passed array distribution. If `proportiontocut` = 0.1, slices off 'leftmost' or 'rightmost' 10% of scores. The lowest or highest values are trimmed (depending on the tail). Slice off less if proportion results in a non-integer slice index (i.e. conservatively slices off `proportiontocut` ). Parameters ---------- a : array_like Input array. proportiontocut : float Fraction to cut off of 'left' or 'right' of distribution. tail : {'left', 'right'}, optional Defaults to 'right'. axis : int or None, optional Axis along which to trim data. Default is 0. If None, compute over the whole array `a`. Returns ------- trim1 : ndarray Trimmed version of array `a`. The order of the trimmed content is undefined. Examples -------- Create an array of 10 values and trim 20% of its lowest values: >>> import numpy as np >>> from scipy import stats >>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> stats.trim1(a, 0.2, 'left') array([2, 4, 3, 5, 6, 7, 8, 9]) Note that the elements of the input array are trimmed by value, but the output array is not necessarily sorted. The proportion to trim is rounded down to the nearest integer. For instance, trimming 25% of the values from an array of 10 values will return an array of 8 values: >>> b = np.arange(10) >>> stats.trim1(b, 1/4).shape (8,) Multidimensional arrays can be trimmed along any axis or across the entire array: >>> c = [2, 4, 6, 8, 0, 1, 3, 5, 7, 9] >>> d = np.array([a, b, c]) >>> stats.trim1(d, 0.8, axis=0).shape (1, 10) >>> stats.trim1(d, 0.8, axis=1).shape (3, 2) >>> stats.trim1(d, 0.8, axis=None).shape (6,) Nrrrr) rrrrrrr`rrr) rrbtailrrrcrdrerfs rrbrb sz 1 A | GGI 774=D!  zz|w#o455  -. <<Hhl3T :D + "BX(BH b ?rc[R"U5nURS:Xa[R$UcUR 5nSnUR Un[ X-5nX4- nXE:a [S5e[R"XUS- 4U5n[S5/UR-n[XE5Xr'[R"U[U5US9$)aQReturn mean of array after trimming a specified fraction of extreme values Removes the specified proportion of elements from *each* end of the sorted array, then computes the mean of the remaining elements. Parameters ---------- a : array_like Input array. proportiontocut : float Fraction of the most positive and most negative elements to remove. When the specified proportion does not result in an integer number of elements, the number of elements to trim is rounded down. axis : int or None, default: 0 Axis along which the trimmed means are computed. If None, compute over the raveled array. Returns ------- trim_mean : ndarray Mean of trimmed array. See Also -------- trimboth : Remove a proportion of elements from each end of an array. tmean : Compute the mean after trimming values outside specified limits. Notes ----- For 1-D array `a`, `trim_mean` is approximately equivalent to the following calculation:: import numpy as np a = np.sort(a) m = int(proportiontocut * len(a)) np.mean(a[m: len(a) - m]) Examples -------- >>> import numpy as np >>> from scipy import stats >>> x = [1, 2, 3, 5] >>> stats.trim_mean(x, 0.25) 2.5 When the specified proportion does not result in an integer number of elements, the number of elements to trim is rounded down. >>> stats.trim_mean(x, 0.24999) == np.mean(x) True Use `axis` to specify the axis along which the calculation is performed. >>> x2 = [[1, 2, 3, 5], ... [10, 20, 30, 50]] >>> stats.trim_mean(x2, 0.25) array([ 5.5, 11. , 16.5, 27.5]) >>> stats.trim_mean(x2, 0.25, axis=1) array([ 2.5, 25. ]) rNr_rr ) rrrrrrrrr`rrrrras rrcrc s| 1 Avv{vv  | GGI 774=D?)*HH.// <<hl3T :D + "BX(BH 774b ? ..rF_onewayResultc[U[U55nUSUXS-S-n[R"U[ U6S9nUR 5n[ USUS5$)z This is a helper function for f_oneway for creating the return values in certain degenerate conditions. It creates return values that are all nan with the appropriate shape for the given `shape` and `axis`. Nr) fill_valuer)r6rrrrrrj)rrrshpfprobs r_create_f_oneway_nan_resultrpcsa c%j 1D ,Avw 'C ' 23A 668D !B%b **rcl[R"U[R"SURS9U5$)z>Return arr[..., 0:1, ...] where 0:1 is in the `axis` position.r)ndmin)rtake_along_axisrr)rrs r_firstrtps&  c288ASXX#> EErrc^S[U5S3n[U5S:a [U5e[U4SjU55(ag[U4SjU55(a!Sn[R "[ U5SS9 gg ) Nz'At least two samples are required; got .rc3F># UHoRTS:Hv M g7frNrrIrrs rrK)_f_oneway_is_too_small..| 9v<<  "!Tc3F># UHoRTS:Hv M g7f)rNryrzs rrKr{r|r}zeall input arrays have length 1. f_oneway requires that at least one input has length greater than 1.rF)rrrrrrr-)rkwargsrrrs ` r_f_oneway_is_too_smallrusv7G ~QGG 7|a   9 999 9 999< (-!< rc  [U5S:a[S[U5S35e[U5n[R"XS9nURUn[ U5(a[ URX5$[R"UVs/sHn[XP5U:HRUSS9PM! snUS9nURUS9nUR5(a+Sn[R"[R"U5SS9 [X05U:HRUS9n URUSS9n X:- n[X0S9U- n [!X0S9U - n S n UH#n[XZ- US9nXURU- -n M% X- n X- nUS - nXB- nU U- nUU- n[R""S S S 9 UU- nS S S 5 [$R&"UUW5n[R("U5(aBU (a![R*n[R*nOXU(a[R,nSnO>[R,UU'SUU'[R*UU '[R*UU '[/UU5$s snf!,(df  N=f)aPerform one-way ANOVA. The one-way ANOVA tests the null hypothesis that two or more groups have the same population mean. The test is applied to samples from two or more groups, possibly with differing sizes. Parameters ---------- sample1, sample2, ... : array_like The sample measurements for each group. There must be at least two arguments. If the arrays are multidimensional, then all the dimensions of the array must be the same except for `axis`. axis : int, optional Axis of the input arrays along which the test is applied. Default is 0. Returns ------- statistic : float The computed F statistic of the test. pvalue : float The associated p-value from the F distribution. Warns ----- `~scipy.stats.ConstantInputWarning` Emitted if all values within each of the input arrays are identical. In this case the F statistic is either infinite or isn't defined, so ``np.inf`` or ``np.nan`` is returned. RuntimeWarning Emitted if the length of any input array is 0, or if all the input arrays have length 1. ``np.nan`` is returned for the F statistic and the p-value in these cases. Notes ----- The ANOVA test has important assumptions that must be satisfied in order for the associated p-value to be valid. 1. The samples are independent. 2. Each sample is from a normally distributed population. 3. The population standard deviations of the groups are all equal. This property is known as homoscedasticity. If these assumptions are not true for a given set of data, it may still be possible to use the Kruskal-Wallis H-test (`scipy.stats.kruskal`) or the Alexander-Govern test (`scipy.stats.alexandergovern`) although with some loss of power. The length of each group must be at least one, and there must be at least one group with length greater than one. If these conditions are not satisfied, a warning is generated and (``np.nan``, ``np.nan``) is returned. If all values in each group are identical, and there exist at least two groups with different values, the function generates a warning and returns (``np.inf``, 0). If all values in all groups are the same, function generates a warning and returns (``np.nan``, ``np.nan``). The algorithm is from Heiman [2]_, pp.394-7. References ---------- .. [1] R. Lowry, "Concepts and Applications of Inferential Statistics", Chapter 14, 2014, http://vassarstats.net/textbook/ .. [2] G.W. Heiman, "Understanding research methods and statistics: An integrated introduction for psychology", Houghton, Mifflin and Company, 2001. .. [3] G.H. McDonald, "Handbook of Biological Statistics", One-way ANOVA. http://www.biostathandbook.com/onewayanova.html Examples -------- >>> import numpy as np >>> from scipy.stats import f_oneway Here are some data [3]_ on a shell measurement (the length of the anterior adductor muscle scar, standardized by dividing by length) in the mussel Mytilus trossulus from five locations: Tillamook, Oregon; Newport, Oregon; Petersburg, Alaska; Magadan, Russia; and Tvarminne, Finland, taken from a much larger data set used in McDonald et al. (1991). >>> tillamook = [0.0571, 0.0813, 0.0831, 0.0976, 0.0817, 0.0859, 0.0735, ... 0.0659, 0.0923, 0.0836] >>> newport = [0.0873, 0.0662, 0.0672, 0.0819, 0.0749, 0.0649, 0.0835, ... 0.0725] >>> petersburg = [0.0974, 0.1352, 0.0817, 0.1016, 0.0968, 0.1064, 0.105] >>> magadan = [0.1033, 0.0915, 0.0781, 0.0685, 0.0677, 0.0697, 0.0764, ... 0.0689] >>> tvarminne = [0.0703, 0.1026, 0.0956, 0.0973, 0.1039, 0.1045] >>> f_oneway(tillamook, newport, petersburg, magadan, tvarminne) F_onewayResult(statistic=7.121019471642447, pvalue=0.0002812242314534544) `f_oneway` accepts multidimensional input arrays. When the inputs are multidimensional and `axis` is not given, the test is performed along the first axis of the input arrays. For the following data, the test is performed three times, once for each column. >>> a = np.array([[9.87, 9.03, 6.81], ... [7.18, 8.35, 7.00], ... [8.39, 7.58, 7.68], ... [7.45, 6.33, 9.35], ... [6.41, 7.10, 9.33], ... [8.00, 8.24, 8.44]]) >>> b = np.array([[6.35, 7.30, 7.16], ... [6.65, 6.68, 7.63], ... [5.72, 7.73, 6.72], ... [7.01, 9.19, 7.41], ... [7.75, 7.87, 8.30], ... [6.90, 7.97, 6.97]]) >>> c = np.array([[3.31, 8.77, 1.01], ... [8.25, 3.24, 3.62], ... [6.32, 8.81, 5.19], ... [7.48, 8.83, 8.91], ... [8.59, 6.01, 6.07], ... [3.07, 9.72, 7.48]]) >>> F = f_oneway(a, b, c) >>> F.statistic array([1.75676344, 0.03701228, 3.76439349]) >>> F.pvalue array([0.20630784, 0.96375203, 0.04733157]) rz&at least two inputs are required; got rvr TrDzPEach of the input arrays is constant; the F statistic is not defined or infiniterrrrrNr )rrr concatenaterrrprtrrrrr4ConstantInputWarningr_square_of_sums_sum_of_squaresrspecialfdtrcrrr!rj)rr num_groupsalldatabignris_const all_constrall_same_constoffset normalized_sssstotssbnsmo_sssswndfbndfwnmsbmswrnros rrdrds}F 7|a #G ~Q01 1WJ nnW0G == Dg&&*7==$HH~~ V  & ( - -47; . =  H $ 'I}}< e005!DW+w6;;;FN \\td\ 3FG#G7$>M G /- ?E D t<v||D111  D D  D +C +C Hh 7 #I 8 ==tQ 'D {{1~~ A66D ADvv) YFF.!vv^ !T "" V 8 7s&I:-I?? J c*\rSrSr%\\S'\\S'Srg)AlexanderGovernResultijrrrN)__name__ __module__ __qualname____firstlineno__r__annotations____static_attributes__rrrrrjs  Mrrc2URUR4$rrrs rrrrsq{{AHH5r)rrr)rrc "[X U5nUVs/sHo3RSPM nn[R"UVs/sH n[ USS9PM sn5n[ X$5VVs/sHup6[ USSS9U- PM nnn[R"U5nUS-n [R"U R5Rn U [R"X-5:*n [R"[RU RS9n [R"XU 5n SU- n U [R"U SSS 9- n[R"X-SSS 9n[X_S[S 9U - n[R"U5S- n[R"US S UR S- --5nUS- nS US--nU[R""SUS-U- -5-S-nUUS-SU--U- -SUS--SUS---SUS---SU--US-S-SU-US---SU--- - n[R"US-SS9n[%U5S- n['U5n[)UUSS[S9n[+UU5$s snfs snfs snnf)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, and each sample must contain at least two observations. 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 ------- res : AlexanderGovernResult An object with attributes: statistic : float The computed A statistic of the test. pvalue : float The associated p-value from the chi-squared distribution. Warns ----- `~scipy.stats.ConstantInputWarning` Raised if an input is a constant array. The statistic is not defined in this case, so ``np.nan`` is returned. See Also -------- f_oneway : one-way ANOVA Notes ----- The use of this test relies on several assumptions. 1. The samples are independent. 2. Each sample is from a normally distributed population. 3. Unlike `f_oneway`, this test does not assume on homoscedasticity, instead relaxing the assumption of equal variances. Input samples must be finite, one dimensional, and with size greater than one. References ---------- .. [1] Alexander, Ralph A., and Diane M. Govern. "A New and Simpler Approximation for ANOVA under Variance Heterogeneity." Journal of Educational Statistics, vol. 19, no. 2, 1994, pp. 91-101. JSTOR, www.jstor.org/stable/1165140. Accessed 12 Sept. 2020. Examples -------- >>> from scipy.stats import alexandergovern Here are some data on annual percentage rate of interest charged on new car loans at nine of the largest banks in four American cities taken from the National Institute of Standards and Technology's ANOVA dataset. We use `alexandergovern` to test the null hypothesis that all cities have the same mean APR against the alternative that the cities do not all have the same mean APR. We decide that a significance level of 5% is required to reject the null hypothesis in favor of the alternative. >>> atlanta = [13.75, 13.75, 13.5, 13.5, 13.0, 13.0, 13.0, 12.75, 12.5] >>> chicago = [14.25, 13.0, 12.75, 12.5, 12.5, 12.4, 12.3, 11.9, 11.9] >>> houston = [14.0, 14.0, 13.51, 13.5, 13.5, 13.25, 13.0, 12.5, 12.5] >>> memphis = [15.0, 14.0, 13.75, 13.59, 13.25, 12.97, 12.5, 12.25, ... 11.89] >>> alexandergovern(atlanta, chicago, houston, memphis) AlexanderGovernResult(statistic=4.65087071883494, pvalue=0.19922132490385214) The p-value is 0.1992, indicating a nearly 20% chance of observing such an extreme value of the test statistic under the null hypothesis. This exceeds 5%, so we do not reject the null hypothesis in favor of the alternative. rr r)rrr.rrTrDrrrr0rrlr{r!rSiWrQrirFr)!_alexandergovern_input_validationrrrrziprrTrrUrVrrrr[rrrrrrr)rrrrlengthsmeanslengthse2standard_errors_squaredstandard_errorsrUrur inv_sq_servar_wt_statsrrrrYr,rdfrrs rrrpsz0TJG/66gF||BgG6 JJHfb1H IE"%W!6 8!6~v Fqr 2V ;!6 8 jjo-s2O ((?(( ) - -C bffS[1 1D **RVV?#8#8 9Chht/:O++I"&&TBBG FF7?T :Eer2_DG 7aA 1edGLLN334A BA QT A RVVAAq(( ) )B.A q!tacz1n  QT6Bq!tG c!Q$h &Q . a47QqSAX Q & ( )A q!t!A W B r?DAteKA A &&]7H 8sJJ(J c[U5S:a[S[U535eUH!nURUS::dM[S5e UVs/sHn[R "X2S5PM nnU$s snf)Nrz2 or more inputs required, got rz+Input sample size must be greater than one.r)rrrrrmoveaxis)rrrrs rrrsy 7|a9#g,HII <<  "JK K.statisticAs40 rT)rrrrrr)r'_asdictrclipconfidence_intervalr)rr4rrrrrr$s r_pearsonr_bootstrap_cir=sf QFI N8H[ N[TU]X5 X0lX@lXPlX`lXplXlgr)super__init__ _alternative_n_x_y_axis correlation) selfrrrrrrr __class__s rrPearsonRResult.__init__es2 +' %rc~[U[5(ak[UR5nSn[ U5(d [ U5e[ XURURURUR5nU$Uc.[URURUUR5nU$Sn[ U5e)a; The confidence interval for the correlation coefficient. Compute the confidence interval for the correlation coefficient ``statistic`` with the given confidence level. If `method` is not provided, The confidence interval is computed using the Fisher transformation F(r) = arctanh(r) [1]_. When the sample pairs are drawn from a bivariate normal distribution, F(r) approximately follows a normal distribution with standard error ``1/sqrt(n - 3)``, where ``n`` is the length of the original samples along the calculation axis. When ``n <= 3``, this approximation does not yield a finite, real standard error, so we define the confidence interval to be -1 to 1. If `method` is an instance of `BootstrapMethod`, the confidence interval is computed using `scipy.stats.bootstrap` with the provided configuration options and other appropriate settings. In some cases, confidence limits may be NaN due to a degenerate resample, and this is typical for very small samples (~6 observations). Parameters ---------- confidence_level : float The confidence level for the calculation of the correlation coefficient confidence interval. Default is 0.95. method : BootstrapMethod, optional Defines the method used to compute the confidence interval. See method description for details. .. versionadded:: 1.11.0 Returns ------- ci : namedtuple The confidence interval is returned in a ``namedtuple`` with fields `low` and `high`. References ---------- .. [1] "Pearson correlation coefficient", Wikipedia, https://en.wikipedia.org/wiki/Pearson_correlation_coefficient zF`method` must be `None` if `pearsonr` arguments were not NumPy arrays.z:`method` must be an instance of `BootstrapMethod` or None.) rr$r8rr9rrrrrrrr)rrr4rrcis rr"PearsonRResult.confidence_intervalpsZ fo . . )B:GB<< ))'(8$''477(,(9(94::GB ^$T^^TWW>N%)%6%68B  "GW% %r)rrrrrr)ffffff?N rrrr__doc__rrr __classcell__rs@rrrSs" %==rr)rr4rc L ^^[TU5nURT5mURU5n[U5(dUbSnUc&URTS5mURUS5nSn[ U5nXd:wa [ S5eUnTR UnXqR U:wa [ S5eUS:a [ S5eURTU5umn[TXES 9m[XUS 9nSnURTRUR5n URU S 5(aURS 5Rn URU S 5(a [ S5eURTU SS9mURXSS9nURU 5RS-n UR!TTSSS24:HSS9n UR!XSSS24:HSS9n X-nUR#U5(a+Sn[$R&"[(R*"U5SS9 [-U[.5(aIUU4Sjn[1U4U4SUTS.UR35D6n[5UR6UR8UTTXS9$[-U[:5(aU4SjnUR35nUR=SS5=nb:[>R@RCU5nURDURD4US'[GTU44UUTS.UD6n[5UR6UR8UTTXS9$US:Xa S n [ U 5eUb S!n [ U 5eURITUS"S#9nURIXS"S#9nTU- nUU- nURKURMU5US"S#9nURKURMU5US"S#9n[>RN"S$S$S%9 U[QUU- US"S#9-nU[QUU- US"S#9-nSSS5 UR#WXRMU5-:US9nUR#WXRMU5-:US9nUU-nUR#UU)-5(a+S&n[$R&"[(RR"U5SS9 [>RN"S$S$S%9 URUUU- U-U- US9nSSS5 URSU S'9nURURWWU*U55nURXUU'US:Xa`UR[U5nURSU S'9nUR]URUR_U55URXU-U5n O/URUS- S- 5n![aU!U!SSS(9n"[cUU"TUS 9n URdS:XaUS)OUnU RdS:XaU S)OU n [5UU UTTXS9$![ [4anS n [ U 5UeSnAff=f!,(df  GN=f!,(df  GNZ=f)*a( Pearson correlation coefficient and p-value for testing non-correlation. The Pearson correlation coefficient [1]_ measures the linear relationship between two datasets. Like other correlation coefficients, this one varies between -1 and +1 with 0 implying no correlation. Correlations of -1 or +1 imply an exact linear relationship. Positive correlations imply that as x increases, so does y. Negative correlations imply that as x increases, y decreases. This function also performs a test of the null hypothesis that the distributions underlying the samples are uncorrelated and normally distributed. (See Kowalski [3]_ for a discussion of the effects of non-normality of the input on the distribution of the correlation coefficient.) The p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Pearson correlation at least as extreme as the one computed from these datasets. Parameters ---------- x : array_like Input array. y : array_like Input array. axis : int or None, default Axis along which to perform the calculation. Default is 0. If None, ravel both arrays before performing the calculation. .. versionadded:: 1.13.0 alternative : {'two-sided', 'greater', 'less'}, optional Defines the alternative hypothesis. Default is 'two-sided'. The following options are available: * 'two-sided': the correlation is nonzero * 'less': the correlation is negative (less than zero) * 'greater': the correlation is positive (greater than zero) .. versionadded:: 1.9.0 method : ResamplingMethod, optional Defines the method used to compute the p-value. If `method` is an instance of `PermutationMethod`/`MonteCarloMethod`, the p-value is computed using `scipy.stats.permutation_test`/`scipy.stats.monte_carlo_test` with the provided configuration options and other appropriate settings. Otherwise, the p-value is computed as documented in the notes. .. versionadded:: 1.11.0 Returns ------- result : `~scipy.stats._result_classes.PearsonRResult` An object with the following attributes: statistic : float Pearson product-moment correlation coefficient. pvalue : float The p-value associated with the chosen alternative. The object has the following method: confidence_interval(confidence_level, method) This computes the confidence interval of the correlation coefficient `statistic` for the given confidence level. The confidence interval is returned in a ``namedtuple`` with fields `low` and `high`. If `method` is not provided, the confidence interval is computed using the Fisher transformation [1]_. If `method` is an instance of `BootstrapMethod`, the confidence interval is computed using `scipy.stats.bootstrap` with the provided configuration options and other appropriate settings. In some cases, confidence limits may be NaN due to a degenerate resample, and this is typical for very small samples (~6 observations). Raises ------ ValueError If `x` and `y` do not have length at least 2. Warns ----- `~scipy.stats.ConstantInputWarning` Raised if an input is a constant array. The correlation coefficient is not defined in this case, so ``np.nan`` is returned. `~scipy.stats.NearConstantInputWarning` Raised if an input is "nearly" constant. The array ``x`` is considered nearly constant if ``norm(x - mean(x)) < 1e-13 * abs(mean(x))``. Numerical errors in the calculation ``x - mean(x)`` in this case might result in an inaccurate calculation of r. See Also -------- spearmanr : Spearman rank-order correlation coefficient. kendalltau : Kendall's tau, a correlation measure for ordinal data. Notes ----- The correlation coefficient is calculated as follows: .. math:: r = \frac{\sum (x - m_x) (y - m_y)} {\sqrt{\sum (x - m_x)^2 \sum (y - m_y)^2}} where :math:`m_x` is the mean of the vector x and :math:`m_y` is the mean of the vector y. Under the assumption that x and y are drawn from independent normal distributions (so the population correlation coefficient is 0), the probability density function of the sample correlation coefficient r is ([1]_, [2]_): .. math:: f(r) = \frac{{(1-r^2)}^{n/2-2}}{\mathrm{B}(\frac{1}{2},\frac{n}{2}-1)} where n is the number of samples, and B is the beta function. This is sometimes referred to as the exact distribution of r. This is the distribution that is used in `pearsonr` to compute the p-value when the `method` parameter is left at its default value (None). The distribution is a beta distribution on the interval [-1, 1], with equal shape parameters a = b = n/2 - 1. In terms of SciPy's implementation of the beta distribution, the distribution of r is:: dist = scipy.stats.beta(n/2 - 1, n/2 - 1, loc=-1, scale=2) The default p-value returned by `pearsonr` is a two-sided p-value. For a given sample with correlation coefficient r, the p-value is the probability that abs(r') of a random sample x' and y' drawn from the population with zero correlation would be greater than or equal to abs(r). In terms of the object ``dist`` shown above, the p-value for a given r and length n can be computed as:: p = 2*dist.cdf(-abs(r)) When n is 2, the above continuous distribution is not well-defined. One can interpret the limit of the beta distribution as the shape parameters a and b approach a = b = 0 as a discrete distribution with equal probability masses at r = 1 and r = -1. More directly, one can observe that, given the data x = [x1, x2] and y = [y1, y2], and assuming x1 != x2 and y1 != y2, the only possible values for r are 1 and -1. Because abs(r') for any sample x' and y' with length 2 will be 1, the two-sided p-value for a sample of length 2 is always 1. For backwards compatibility, the object that is returned also behaves like a tuple of length two that holds the statistic and the p-value. References ---------- .. [1] "Pearson correlation coefficient", Wikipedia, https://en.wikipedia.org/wiki/Pearson_correlation_coefficient .. [2] Student, "Probable error of a correlation coefficient", Biometrika, Volume 6, Issue 2-3, 1 September 1908, pp. 302-310. .. [3] C. J. Kowalski, "On the Effects of Non-Normality on the Distribution of the Sample Product-Moment Correlation Coefficient" Journal of the Royal Statistical Society. Series C (Applied Statistics), Vol. 21, No. 1 (1972), pp. 1-12. Examples -------- >>> import numpy as np >>> from scipy import stats >>> x, y = [1, 2, 3, 4, 5, 6, 7], [10, 9, 2.5, 6, 4, 3, 2] >>> res = stats.pearsonr(x, y) >>> res PearsonRResult(statistic=-0.828503883588428, pvalue=0.021280260007523286) To perform an exact permutation version of the test: >>> rng = np.random.default_rng(7796654889291491997) >>> method = stats.PermutationMethod(n_resamples=np.inf, random_state=rng) >>> stats.pearsonr(x, y, method=method) PearsonRResult(statistic=-0.828503883588428, pvalue=0.028174603174603175) To perform the test under the null hypothesis that the data were drawn from *uniform* distributions: >>> method = stats.MonteCarloMethod(rvs=(rng.uniform, rng.uniform)) >>> stats.pearsonr(x, y, method=method) PearsonRResult(statistic=-0.828503883588428, pvalue=0.0188) To produce an asymptotic 90% confidence interval: >>> res.confidence_interval(confidence_level=0.9) ConfidenceInterval(low=-0.9644331982722841, high=-0.3460237473272273) And for a bootstrap confidence interval: >>> method = stats.BootstrapMethod(method='BCa', rng=rng) >>> res.confidence_interval(confidence_level=0.9, method=method) ConfidenceInterval(low=-0.9983163756488651, high=-0.22771001702132443) # may vary If N-dimensional arrays are provided, multiple tests are performed in a single call according to the same conventions as most `scipy.stats` functions: >>> rng = np.random.default_rng(2348246935601934321) >>> x = rng.standard_normal((8, 15)) >>> y = rng.standard_normal((8, 15)) >>> stats.pearsonr(x, y, axis=0).statistic.shape # between corresponding columns (15,) >>> stats.pearsonr(x, y, axis=1).statistic.shape # between corresponding rows (8,) To perform all pairwise comparisons between slices of the arrays, use standard NumPy broadcasting techniques. For instance, to compute the correlation between all pairs of rows: >>> stats.pearsonr(x[:, np.newaxis, :], y, axis=-1).statistic.shape (8, 8) There is a linear dependence between x and y if y = a + b*x + e, where a,b are constants and e is a random error term, assumed to be independent of x. For simplicity, assume that x is standard normal, a=0, b=1 and let e follow a normal distribution with mean zero and standard deviation s>0. >>> rng = np.random.default_rng() >>> s = 0.5 >>> x = stats.norm.rvs(size=500, random_state=rng) >>> e = stats.norm.rvs(scale=s, size=500, random_state=rng) >>> y = x + e >>> stats.pearsonr(x, y).statistic 0.9001942438244763 This should be close to the exact value given by >>> 1/np.sqrt(1 + s**2) 0.8944271909999159 For s=0.5, we observe a high level of correlation. In general, a large variance of the noise reduces the correlation, while the correlation approaches one as the variance of the error goes to zero. It is important to keep in mind that no correlation does not imply independence unless (x, y) is jointly normal. Correlation can even be zero when there is a very simple dependence structure: if X follows a standard normal distribution, let y = abs(x). Note that the correlation between x and y is zero. Indeed, since the expectation of x is zero, cov(x, y) = E[x*y]. By definition, this equals E[x*abs(x)] which is zero by symmetry. The following lines of code illustrate this observation: >>> y = np.abs(x) >>> stats.pearsonr(x, y) PearsonRResult(statistic=-0.05444919272687482, pvalue=0.22422294836207743) A non-zero correlation coefficient can be misleading. For example, if X has a standard normal distribution, define y = x if x < 0 and y = 0 otherwise. A simple calculation shows that corr(x, y) = sqrt(2/Pi) = 0.797..., implying a high level of correlation: >>> y = np.where(x < 0, x, 0) >>> stats.pearsonr(x, y) PearsonRResult(statistic=0.861985781588, pvalue=4.813432002751103e-149) This is unintuitive since there is no dependence of x and y if x is larger than zero which happens in about half of the cases if we sample x and y. Nrrr`axis` must be an integer.z3`x` and `y` must have the same length along `axis`.rz(`x` and `y` must have length at least 2.z"`x` and `y` must be broadcastable.rrrcomplex floatingz+This function does not support complex dataFrg?.rrr GAn input array is constant; the correlation coefficient is not defined.rc">[TXTS9up#U$N)rrr)rrrrrrs rrpearsonr..statistics#AqMLI rpairings)permutation_typerr)rrrrrrrc">[XUTS9up4U$rr)rrrrrrs rrrs#AtMLI rr;rvsrrrz:`method` must be `None` if arguments are not NumPy arrays.zP`method` must be an instance of `PermutationMethod`,`MonteCarloMethod`, or None.TrDrr&zZAn input array is nearly constant; the computed correlation coefficient may be inaccurate.rlocr<r)3r8rr9rrrrbroadcast_arrays RuntimeErrorr;rrrrrTrUrrrrr4rrr#r&rrrrr"poprrandom default_rngr0r%rrrVrr=NearConstantInputWarningrrrrFrr _SimpleBetarr)#rrrr4rraxis_intrrrr thresholdconst_xconst_yconst_xyrrr$r;xmeanymeanxmymxmaxymaxnormxmnormymnconst_xnconst_y nconst_xyronerabdists#` ` rreresD A B 1 A 1 A B<&(tF 4 8 **Qe* $C 2771sdC()A&&AhK Av HHQKjj%j("**RXXa[1266#:sCZZ!a 2rr3Qkb91"!A!;;!+VBZF Af&1Q! HHi  %)6!q()Z 8 7 8 7s0 W#X'XW?,W::W? X X#)r4c~^^^^^[Rm[R"U[RS9nUR S:Xd [ S5e[R"US:5(a [ S5eURS:XaUb [X1U5$UcSOUnSURSS9;dSURS S9;a[[RS 5$US S:a!US S:aUS US-US US -- nO[RnUS US -mUS US-mUS US -mUUUU4SjmUS:XaTRUS TT-TT5nGOUS:Xa%TRUS TT-TUS US-5nGOUS:XGa[TS -TS --TT-S-- 5nTR!US TT-TT5nTR!UTT-TT5nSn S U -n [R""Xx- 5[R$"Xx5- U ::a [US 5$US U:asTRUS TT-TT5n TR!TTT-TT5Xz-:a [XK5$['U4SjU*U -UT5n U TR)U TT-TT5-nO}TR)US S - TT-TT5n TR!STT-TT5Xz-:a [XM5$['TXz-SU5n U TRU TT-TT5-nO Sn[ U5e[+US 5n[XE5$)a$!Perform a Fisher exact test on a contingency table. For a 2x2 table, the null hypothesis is that the true odds ratio of the populations underlying the observations is one, and the observations were sampled from these populations under a condition: the marginals of the resulting table must equal those of the observed table. The statistic is the unconditional maximum likelihood estimate of the odds ratio, and the p-value is the probability under the null hypothesis of obtaining a table at least as extreme as the one that was actually observed. For other table sizes, or if `method` is provided, the null hypothesis is that the rows and columns of the tables have fixed sums and are independent; i.e., the table was sampled from a `scipy.stats.random_table` distribution with the observed marginals. The statistic is the probability mass of this distribution evaluated at `table`, and the p-value is the percentage of the population of tables with statistic at least as extreme (small) as that of `table`. There is only one alternative hypothesis available: the rows and columns are not independent. There are other possible choices of statistic and two-sided p-value definition associated with Fisher's exact test; please see the Notes for more information. Parameters ---------- table : array_like of ints A contingency table. Elements must be non-negative integers. alternative : {'two-sided', 'less', 'greater'}, optional Defines the alternative hypothesis for 2x2 tables; unused for other table sizes. The following options are available (default is 'two-sided'): * 'two-sided': the odds ratio of the underlying population is not one * 'less': the odds ratio of the underlying population is less than one * 'greater': the odds ratio of the underlying population is greater than one See the Notes for more details. method : ResamplingMethod, optional Defines the method used to compute the p-value. If `method` is an instance of `PermutationMethod`/`MonteCarloMethod`, the p-value is computed using `scipy.stats.permutation_test`/`scipy.stats.monte_carlo_test` with the provided configuration options and other appropriate settings. Note that if `method` is an instance of `MonteCarloMethod`, the ``rvs`` attribute must be left unspecified; Monte Carlo samples are always drawn using the ``rvs`` method of `scipy.stats.random_table`. Otherwise, the p-value is computed as documented in the notes. .. versionadded:: 1.15.0 Returns ------- res : SignificanceResult An object containing attributes: statistic : float For a 2x2 table with default `method`, this is the odds ratio - the prior odds ratio not a posterior estimate. In all other cases, this is the probability density of obtaining the observed table under the null hypothesis of independence with marginals fixed. pvalue : float The probability under the null hypothesis of obtaining a table at least as extreme as the one that was actually observed. Raises ------ ValueError If `table` is not two-dimensional or has negative entries. See Also -------- chi2_contingency : Chi-square test of independence of variables in a contingency table. This can be used as an alternative to `fisher_exact` when the numbers in the table are large. contingency.odds_ratio : Compute the odds ratio (sample or conditional MLE) for a 2x2 contingency table. barnard_exact : Barnard's exact test, which is a more powerful alternative than Fisher's exact test for 2x2 contingency tables. boschloo_exact : Boschloo's exact test, which is a more powerful alternative than Fisher's exact test for 2x2 contingency tables. :ref:`hypothesis_fisher_exact` : Extended example Notes ----- *Null hypothesis and p-values* The null hypothesis is that the true odds ratio of the populations underlying the observations is one, and the observations were sampled at random from these populations under a condition: the marginals of the resulting table must equal those of the observed table. Equivalently, the null hypothesis is that the input table is from the hypergeometric distribution with parameters (as used in `hypergeom`) ``M = a + b + c + d``, ``n = a + b`` and ``N = a + c``, where the input table is ``[[a, b], [c, d]]``. This distribution has support ``max(0, N + n - M) <= x <= min(N, n)``, or, in terms of the values in the input table, ``min(0, a - d) <= x <= a + min(b, c)``. ``x`` can be interpreted as the upper-left element of a 2x2 table, so the tables in the distribution have form:: [ x n - x ] [N - x M - (n + N) + x] For example, if:: table = [6 2] [1 4] then the support is ``2 <= x <= 7``, and the tables in the distribution are:: [2 6] [3 5] [4 4] [5 3] [6 2] [7 1] [5 0] [4 1] [3 2] [2 3] [1 4] [0 5] The probability of each table is given by the hypergeometric distribution ``hypergeom.pmf(x, M, n, N)``. For this example, these are (rounded to three significant digits):: x 2 3 4 5 6 7 p 0.0163 0.163 0.408 0.326 0.0816 0.00466 These can be computed with:: >>> import numpy as np >>> from scipy.stats import hypergeom >>> table = np.array([[6, 2], [1, 4]]) >>> M = table.sum() >>> n = table[0].sum() >>> N = table[:, 0].sum() >>> start, end = hypergeom.support(M, n, N) >>> hypergeom.pmf(np.arange(start, end+1), M, n, N) array([0.01631702, 0.16317016, 0.40792541, 0.32634033, 0.08158508, 0.004662 ]) The two-sided p-value is the probability that, under the null hypothesis, a random table would have a probability equal to or less than the probability of the input table. For our example, the probability of the input table (where ``x = 6``) is 0.0816. The x values where the probability does not exceed this are 2, 6 and 7, so the two-sided p-value is ``0.0163 + 0.0816 + 0.00466 ~= 0.10256``:: >>> from scipy.stats import fisher_exact >>> res = fisher_exact(table, alternative='two-sided') >>> res.pvalue 0.10256410256410257 The one-sided p-value for ``alternative='greater'`` is the probability that a random table has ``x >= a``, which in our example is ``x >= 6``, or ``0.0816 + 0.00466 ~= 0.08626``:: >>> res = fisher_exact(table, alternative='greater') >>> res.pvalue 0.08624708624708627 This is equivalent to computing the survival function of the distribution at ``x = 5`` (one less than ``x`` from the input table, because we want to include the probability of ``x = 6`` in the sum):: >>> hypergeom.sf(5, M, n, N) 0.08624708624708627 For ``alternative='less'``, the one-sided p-value is the probability that a random table has ``x <= a``, (i.e. ``x <= 6`` in our example), or ``0.0163 + 0.163 + 0.408 + 0.326 + 0.0816 ~= 0.9949``:: >>> res = fisher_exact(table, alternative='less') >>> res.pvalue 0.9953379953379957 This is equivalent to computing the cumulative distribution function of the distribution at ``x = 6``: >>> hypergeom.cdf(6, M, n, N) 0.9953379953379957 *Odds ratio* The calculated odds ratio is different from the value computed by the R function ``fisher.test``. This implementation returns the "sample" or "unconditional" maximum likelihood estimate, while ``fisher.test`` in R uses the conditional maximum likelihood estimate. To compute the conditional maximum likelihood estimate of the odds ratio, use `scipy.stats.contingency.odds_ratio`. References ---------- .. [1] Fisher, Sir Ronald A, "The Design of Experiments: Mathematics of a Lady Tasting Tea." ISBN 978-0-486-41151-4, 1935. .. [2] "Fisher's exact test", https://en.wikipedia.org/wiki/Fisher's_exact_test Examples -------- >>> from scipy.stats import fisher_exact >>> res = fisher_exact([[8, 2], [1, 5]]) >>> res.statistic 20.0 >>> res.pvalue 0.034965034965034975 For tables with shape other than ``(2, 2)``, provide an instance of `scipy.stats.MonteCarloMethod` or `scipy.stats.PermutationMethod` for the `method` parameter: >>> import numpy as np >>> from scipy.stats import MonteCarloMethod >>> rng = np.random.default_rng(4507195762371367) >>> method = MonteCarloMethod(rng=rng) >>> fisher_exact([[8, 2, 3], [1, 5, 4]], method=method) SignificanceResult(statistic=np.float64(0.005782), pvalue=np.float64(0.0603)) For a more detailed example, see :ref:`hypothesis_fisher_exact`. rrz+The input `table` must have two dimensions.rz*All values in `table` must be nonnegative.rrrr rrrrr)rr)rrc2>TRUTT-TT5$r)pmf)r hypergeomrn1n2s rrfisher_exact..pmf9s}}QRQ//rrrg+=c>T"U5*$rr)rrs rrfisher_exact..Qs c!fWrz?`alternative` should be one of {'two-sided', 'less', 'greater'})rrrrint64rrrr_fisher_exact_rxcrrrr!rrrrVmaximum_binary_searchrr")tablerr4rY oddsratiorrEpexactpmodeepsilongammaplowerguesspupperrrrrrrs @@@@@rrfrfDsNt''I 5)A 66Q;FGG vva!e}}EFF 77f  2 88!,!4++KAEEqEMQ!%%Q%-/""&&#..w{qw{dGag%41T7):; FF 41T7 B 41T7 B $!D'A00fqwRQ7  !qwRQtWqw5FG  #AEb1f%b156qwRQ7 dBGR3G  66&. !BJJv$= = H%i4 4 tWt^]]1T7BGR;F}}QRQ/&.@))<<"#4vgotQOEill5"r'2qAAF\\!D'A+rBwA>F}}QRQ/&.@))<<"34@EimmE27BBBFOo  F i 00rcdUb Sn[U5eURS:Xa [S5eURSS:Xd1URSS:Xd[R"US:H5(a [ SS5$Uc[ R"5n[U[ R5(a [X5nO=[U[ R5(a [X5nOSU<S3n[U5e[ [R"URSS5UR5$)Nz``alternative` must be the default (None) unless `table` has shape `(2, 2)` and `method is None`.rz2`table` must have at least one row and one column.rrz`method=zi` not recognized; if provided, `method` must be an instance of `PermutationMethod` or `MonteCarloMethod`.)rrrrrrr4r"rr# _fisher_exact_permutation_method _fisher_exact_monte_carlo_methodrrr)rrr4rr$s rrrcsE!! zzQMNN {{1~ekk!n1RVVEQJ5G5G!#s++ ~'')&%1122.u= FE22 3 3.u=vi LL!! bggcmmT3? LLrc^^[U5unm[R"USS9n[R"USS9n[R"XC5mUU4Sjn[R "U4U4SSS.UR 5D6$)Nrr rcl>[RRUT5SnTRU5$r?)r4 contingencycrosstabr)rrXrs rr3_fisher_exact_permutation_method..statistics.!!**1a03uuU|rrr)rr) _untabulaterrr4 random_tabler&r)rr4rcolsumsrowsumsrr,rs @@rr&r&s~ u DAqffU#GffU#G 7,A  ! !1$  JJ.4 J8>8H JJrc^^ ^ UR5nURSS5b Sn[U5e[RR URSS55nUR m [R"USS9n[R"USS9n[R"U5m [R"XTUS9mU4SjnUU U 4S jn[R"UR5Xg4S S 0UD6$) NrzIf the `method` argument of `fisher_exact` is an instance of `MonteCarloMethod`, its `rvs` attribute must be unspecified. Use the `MonteCarloMethod` `rng` argument to control the random state.r;rr r)seedcJ>USnTRUS9RU5$)Nr)r)rr)r n_resamplesr,s rr-_fisher_exact_monte_carlo_method..rvss(1g uu+u&..t44rcr>URT:aST-OTnTRURU55$)Nr)rrr)rrshape_r,rtotsums rr3_fisher_exact_monte_carlo_method..statistics1"'**v"55uuU]]6*++rrr) rrrrrrrrr4r/r%r) rr4rr;r0r1rrr,rr9s @@@rr'r's ^^ F zz%*2!! ))   5$ 7 8C KKEffU#GffU#G VVE]F 7#6A5 ,  ! !%++- @.4 @8> @@rc(URup//pC[U5HGn[U5H5nURU/XU4-5 URU/XU4-5 M7 MI [R"U5[R"U54$r)rrGrHrr)rrrYrrrrs rr.r.s ;;DA rq 1XqA HHaS5A;& ' HHaS5A;& ' >>! bnnQ/ //rcUbUS:a[SUS35e[X5upURS:a [S5eUcURS:a [S5eOB[X5upUS:Xa[R"X45nO[R "X45nUR SU- nUR UnUS::a?[[R[R5n [RU l U $S n US:XaUSS2S4SUSS2S4:HR5(d)USS2S4SUSS2S4:HR5(ah[R"[R"U 5SS 9 [[R[R5n [RU l U $OUSSS24SUSSS24:HR5(d)USSS24SUSSS24:HR5(ah[R"[R"U 5SS 9 [[R[R5n [RU l U $[X5up[R "U["S 9n U (aUS :Xa[$R&"XUUS 9$US:XaxURS:XdUS::a?[[R[R5n [RU l U $[R("U5R+US9n [R,"[.XP5n [R0"XS9nUS- n[R2"SS9 U[R4"XS-SU- -- R7S55-nSSS5 [9U5n[;WUU[S9nUR S:Xa[USUS5n USU l U $[RXSS24'[RUSS2U 4'[USUS5n Xl U $!,(df  N=f)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. Like other correlation coefficients, this one varies between -1 and +1 with 0 implying no correlation. Correlations of -1 or +1 imply an exact monotonic relationship. Positive correlations imply that as x increases, so does y. Negative correlations imply that as x increases, y decreases. The p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Spearman correlation at least as extreme as the one computed from these datasets. Although calculation of the p-value does not make strong assumptions about the distributions underlying the samples, it is only accurate for very large samples (>500 observations). For smaller sample sizes, consider a permutation test (see Examples section below). Parameters ---------- a, b : 1D or 2D array_like, b is optional One or two 1-D or 2-D arrays containing multiple variables and observations. When these are 1-D, each represents a vector of observations of a single variable. For the behavior in the 2-D case, see under ``axis``, below. Both arrays need to have the same length in the ``axis`` dimension. axis : int or None, optional If axis=0 (default), then each column represents a variable, with observations in the rows. If axis=1, the relationship is transposed: each row represents a variable, while the columns contain observations. If axis=None, then both arrays will be raveled. nan_policy : {'propagate', 'raise', 'omit'}, optional Defines how to handle when input contains nan. The following options are available (default is 'propagate'): * 'propagate': returns nan * 'raise': throws an error * 'omit': performs the calculations ignoring nan values alternative : {'two-sided', 'less', 'greater'}, optional Defines the alternative hypothesis. Default is 'two-sided'. The following options are available: * 'two-sided': the correlation is nonzero * 'less': the correlation is negative (less than zero) * 'greater': the correlation is positive (greater than zero) .. versionadded:: 1.7.0 Returns ------- res : SignificanceResult An object containing attributes: statistic : float or ndarray (2-D square) Spearman correlation matrix or correlation coefficient (if only 2 variables are given as parameters). Correlation matrix is square with length equal to total number of variables (columns or rows) in ``a`` and ``b`` combined. pvalue : float The p-value for a hypothesis test whose null hypothesis is that two samples have no ordinal correlation. See `alternative` above for alternative hypotheses. `pvalue` has the same shape as `statistic`. Raises ------ ValueError If `axis` is not 0, 1 or None, or if the number of dimensions of `a` is greater than 2, or if `b` is None and the number of dimensions of `a` is less than 2. Warns ----- `~scipy.stats.ConstantInputWarning` Raised if an input is a constant array. The correlation coefficient is not defined in this case, so ``np.nan`` is returned. See Also -------- :ref:`hypothesis_spearmanr` : Extended example References ---------- .. [1] Zwillinger, D. and Kokoska, S. (2000). CRC Standard Probability and Statistics Tables and Formulae. Chapman & Hall: New York. 2000. Section 14.7 .. [2] Kendall, M. G. and Stuart, A. (1973). The Advanced Theory of Statistics, Volume 2: Inference and Relationship. Griffin. 1973. Section 31.18 Examples -------- >>> import numpy as np >>> from scipy import stats >>> res = stats.spearmanr([1, 2, 3, 4, 5], [5, 6, 7, 8, 7]) >>> res.statistic 0.8207826816681233 >>> res.pvalue 0.08858700531354381 >>> rng = np.random.default_rng() >>> x2n = rng.standard_normal((100, 2)) >>> y2n = rng.standard_normal((100, 2)) >>> res = stats.spearmanr(x2n) >>> res.statistic, res.pvalue (-0.07960396039603959, 0.4311168705769747) >>> res = stats.spearmanr(x2n[:, 0], x2n[:, 1]) >>> res.statistic, res.pvalue (-0.07960396039603959, 0.4311168705769747) >>> res = stats.spearmanr(x2n, y2n) >>> res.statistic array([[ 1. , -0.07960396, -0.08314431, 0.09662166], [-0.07960396, 1. , -0.14448245, 0.16738074], [-0.08314431, -0.14448245, 1. , 0.03234323], [ 0.09662166, 0.16738074, 0.03234323, 1. ]]) >>> res.pvalue array([[0. , 0.43111687, 0.41084066, 0.33891628], [0.43111687, 0. , 0.15151618, 0.09600687], [0.41084066, 0.15151618, 0. , 0.74938561], [0.33891628, 0.09600687, 0.74938561, 0. ]]) >>> res = stats.spearmanr(x2n.T, y2n.T, axis=1) >>> res.statistic array([[ 1. , -0.07960396, -0.08314431, 0.09662166], [-0.07960396, 1. , -0.14448245, 0.16738074], [-0.08314431, -0.14448245, 1. , 0.03234323], [ 0.09662166, 0.16738074, 0.03234323, 1. ]]) >>> res = stats.spearmanr(x2n, y2n, axis=None) >>> res.statistic, res.pvalue (0.044981624540613524, 0.5270803651336189) >>> res = stats.spearmanr(x2n.ravel(), y2n.ravel()) >>> res.statistic, res.pvalue (0.044981624540613524, 0.5270803651336189) >>> rng = np.random.default_rng() >>> xint = rng.integers(10, size=(100, 2)) >>> res = stats.spearmanr(xint) >>> res.statistic, res.pvalue (0.09800224850707953, 0.3320271757932076) For small samples, consider performing a permutation test instead of relying on the asymptotic p-value. Note that to calculate the null distribution of the statistic (for all possibly pairings between observations in sample ``x`` and ``y``), only one of the two inputs needs to be permuted. >>> x = [1.76405235, 0.40015721, 0.97873798, ... 2.2408932, 1.86755799, -0.97727788] >>> y = [2.71414076, 0.2488, 0.87551913, ... 2.6514917, 2.01160156, 0.47699563] >>> def statistic(x): # permute only `x` ... return stats.spearmanr(x, y).statistic >>> res_exact = stats.permutation_test((x,), statistic, ... permutation_type='pairings') >>> res_asymptotic = stats.spearmanr(x, y) >>> res_exact.pvalue, res_asymptotic.pvalue # asymptotic pvalue is too low (0.10277777777777777, 0.07239650145772594) For a more detailed example, see :ref:`hypothesis_spearmanr`. NrzAspearmanr only handles 1-D or 2-D arrays, supplied axis argument z., 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 comparerrrrr)rrrrr )rowvarrrrrrrr)rrrr column_stackvstackrrrrrrrr4rrrrrrgrrrPrycorrcoefrrr_SimpleStudentTr)rrrrraxisoutrn_varsr3r$warn_msga_contains_nanvariable_has_nana_rankedrsdofrr ros rrgrgsV D1H337&9889 9a&JAvvzCDDy 66A:45 5  A$ a<'A 1&!A WWQ[ !F GGG E z 0&& "H!| adGAJ!AqD' ! & & ( (Qq!tWQZ1QT7-B,G,G,I,I MM%44X>1 M$RVVRVV4C ffCOJ -J adGAJ!AqD' ! & & ( (Qq!tWQZ1QT7-B,G,G,I,I MM%44X>1 M$RVVRVV4C ffCOJ!.q!=Nxxd3  ))!:6AC C ; &vv{fk(8"$&& $&88A;???#@ ""8W8H X .B !)C H % #3R0177:; ; & 3 D q$  3D xx6 D4:6T( "$&&Q "$&&1  Bb2 % & %s 4Q  Q.cB[X5up#[X#5nX$lU$)a Calculate a point biserial correlation coefficient and its p-value. The point biserial correlation is used to measure the relationship between a binary variable, x, and a continuous variable, y. Like other correlation coefficients, this one varies between -1 and +1 with 0 implying no correlation. Correlations of -1 or +1 imply a determinative relationship. This function may be computed using a shortcut formula but produces the same result as `pearsonr`. Parameters ---------- x : array_like of bools Input array. y : array_like Input array. Returns ------- res: SignificanceResult An object containing attributes: statistic : float The R value. pvalue : float The two-sided p-value. Notes ----- `pointbiserialr` uses a t-test with ``n-1`` degrees of freedom. It is equivalent to `pearsonr`. The value of the point-biserial correlation can be calculated from: .. math:: r_{pb} = \frac{\overline{Y_1} - \overline{Y_0}} {s_y} \sqrt{\frac{N_0 N_1} {N (N - 1)}} Where :math:`\overline{Y_{0}}` and :math:`\overline{Y_{1}}` are means of the metric observations coded 0 and 1 respectively; :math:`N_{0}` and :math:`N_{1}` are number of observations coded 0 and 1 respectively; :math:`N` is the total number of observations and :math:`s_{y}` is the standard deviation of all the metric observations. A value of :math:`r_{pb}` that is significantly different from zero is completely equivalent to a significant difference in means between the two groups. Thus, an independent groups t Test with :math:`N-2` degrees of freedom may be used to test whether :math:`r_{pb}` is nonzero. The relation between the t-statistic for comparing two independent groups and :math:`r_{pb}` is given by: .. math:: t = \sqrt{N - 2}\frac{r_{pb}}{\sqrt{1 - r^{2}_{pb}}} References ---------- .. [1] J. Lev, "The Point Biserial Coefficient of Correlation", Ann. Math. Statist., Vol. 20, no.1, pp. 125-126, 1949. .. [2] R.F. Tate, "Correlation Between a Discrete and a Continuous Variable. Point-Biserial Correlation.", Ann. Math. Statist., Vol. 25, np. 3, pp. 603-607, 1954. .. [3] D. Kornbrot "Point Biserial Correlation", In Wiley StatsRef: Statistics Reference Online (eds N. Balakrishnan, et al.), 2014. :doi:`10.1002/9781118445112.stat06227` Examples -------- >>> import numpy as np >>> from scipy import stats >>> a = np.array([0, 0, 0, 1, 1, 1, 1]) >>> b = np.arange(7) >>> stats.pointbiserialr(a, b) (0.8660254037844386, 0.011724811003954652) >>> stats.pearsonr(a, b) (0.86602540378443871, 0.011724811003954626) >>> np.corrcoef(a, b) array([[ 1. , 0.8660254], [ 0.8660254, 1. ]]) )rerr)rrrpbror$s rrhrhs$pIC S 'CO Jrautor)rr4variantrc [R"U5R5n[R"U5R5nURUR:wa%[ SURSUR35eUR(aUR(d?[ [R [R 5n[R UlU$[X5upx[X5upU=(d U n US:XdU S:XaSnU (aEUS:Xa?[ [R [R 5n[R UlU$U (a\US:XaV[R"U5n[R"U5nUS:Xa[R"XUSUS9$Sn [ U 5eS n URn[R"U5nXXp[RSUS S US S :g4R[R S 9n[R"USS9nXXp[RSUS S US S :g4R[R S 9n[#X5n[RSUS S US S :gUS S US S :g-S4n[R$"[R&"U5S5R)SSS9n[+UUS - -S-R-55nU "U5unnnU "U5unnnXS - -S-nUU:XdUU:Xa?[ [R [R 5n[R UlU$UU- U- U-SU-- nUS:Xa7U."UU- 5- [R."UU- 5- nOZUS:XaE[1[3[5U55[3[5U555nSU-US-US - -U- - nO[ SUS35e[R6"S[9SU55nUS:XaUS:wdUS:wa [ S5eUS:Xa*US:Xa"US:XaUS::d[1UUU- 5S ::aSnOSnUS:Xa(US:Xa"US:Xa[R:"UUU- U5nOUS:XakXS- -nUSU-S--U- U- S - SU-U-U- -UU-S!U-US- -- -n U."U 5- n![=U![?5U[S"9nO[ S#US$35e[ US%US%5nUS%UlU$)&a7Calculate 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. nan_policy : {'propagate', 'raise', 'omit'}, optional Defines how to handle when input contains nan. The following options are available (default is 'propagate'): * 'propagate': returns nan * 'raise': throws an error * 'omit': performs the calculations ignoring nan values method : {'auto', 'asymptotic', 'exact'}, optional Defines which method is used to calculate the p-value [5]_. The following options are available (default is 'auto'): * 'auto': selects the appropriate method based on a trade-off between speed and accuracy * 'asymptotic': uses a normal approximation valid for large samples * 'exact': computes the exact p-value, but can only be used if no ties are present. As the sample size increases, the 'exact' computation time may grow and the result may lose some precision. variant : {'b', 'c'}, optional Defines which variant of Kendall's tau is returned. Default is 'b'. alternative : {'two-sided', 'less', 'greater'}, optional Defines the alternative hypothesis. Default is 'two-sided'. The following options are available: * 'two-sided': the rank correlation is nonzero * 'less': the rank correlation is negative (less than zero) * 'greater': the rank correlation is positive (greater than zero) Returns ------- res : SignificanceResult An object containing attributes: statistic : float The tau statistic. pvalue : float The p-value for a hypothesis test whose null hypothesis is an absence of association, tau = 0. Raises ------ ValueError If `nan_policy` is 'omit' and `variant` is not 'b' or if `method` is 'exact' and there are ties between `x` and `y`. 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. :ref:`hypothesis_kendalltau` : Extended example Notes ----- The definition of Kendall's tau that is used is [2]_:: tau_b = (P - Q) / sqrt((P + Q + T) * (P + Q + U)) tau_c = 2 (P - Q) / (n**2 * (m - 1) / m) where P is the number of concordant pairs, Q the number of discordant pairs, T the number of ties only in `x`, and U the number of ties only in `y`. If a tie occurs for the same pair in both `x` and `y`, it is not added to either T or U. n is the total number of samples, and m is the number of unique values in either `x` or `y`, whichever is smaller. References ---------- .. [1] Maurice G. Kendall, "A New Measure of Rank Correlation", Biometrika Vol. 30, No. 1/2, pp. 81-93, 1938. .. [2] Maurice G. Kendall, "The treatment of ties in ranking problems", Biometrika Vol. 33, No. 3, pp. 239-251. 1945. .. [3] Gottfried E. Noether, "Elements of Nonparametric Statistics", John Wiley & Sons, 1967. .. [4] Peter M. Fenwick, "A new data structure for cumulative frequency tables", Software: Practice and Experience, Vol. 24, No. 3, pp. 327-336, 1994. .. [5] Maurice G. Kendall, "Rank Correlation Methods" (4th Edition), Charles Griffin & Co., 1970. Examples -------- >>> from scipy import stats >>> x1 = [12, 2, 1, 12, 2] >>> x2 = [1, 4, 7, 1, 0] >>> res = stats.kendalltau(x1, x2) >>> res.statistic -0.47140452079103173 >>> res.pvalue 0.2827454599327748 For a more detailed example, see :ref:`hypothesis_kendalltau`. zBAll inputs to `kendalltau` must be of the same size, found x-size and y-size rrrT)r4use_tiesrz@nan_policy='omit' is currently compatible only with variant='b'.c.[R"U5RSSS9nXS:n[XS- -S-R 55[XS- -US- -R 55[XS- -SU-S--R 554$)NrFrrrrrS)rbincountrrr)rankscnts rcount_rank_tie"kendalltau..count_rank_tieskk% ''e'<'lS!G_)..01S"H%q16689S"H%3388:;= =rrNrr mergesortrrrFrrrYz&Unknown variant of the method chosen: z. variant must be 'b' or 'c'.rexactz(Ties found, exact method cannot be used.rLr asymptoticrSrrzUnknown method z1 specified. Use 'auto', 'exact' or 'asymptotic'.r) rrrrrrrrrrrrriargsortr_rintprdiffnonzerorrrrr"rsetrr_kendall_p_exactrr)"rrrr4rMrr$cnxnpxcnynpyrrrUrpermdisobsrTntiextiex0x1ytiey0y1tot con_minus_distau minclassesrrrfr,s" rriri$s!b 1 A 1 Avv//0vvhl166(LM M VV166 0&& Q+HCQ+HC:#L f}v   k1 0&& *.   a    a  c>**17BD D&GW% %= 66D ::a=D 7AGq dAabEQsVO#$++"''+:A ::ak *D 7AGq dAabEQsVO#$++"''+:A q C %%qu#21QR5AcrF?;TA BC ''"**S/!$ % , ,W5 , AC sQw1$))+ ,D!!$LD"b!!$LD"b !8  "C s{dck 0&& $J%,q3w6M#~bggcDj11BGGC$J4GG CSVc#a&k2  oqJqL!9*!DEA'K778 8 **RS# 'Cdai419CDD  AI$!)$"**-c3s7*;q*@F!F qyTQY6W#4..tSWkJ <  2I QtVaZ 2%*b0D41$%')Bw!a%4!82D'EF BGGCL (Q D?6(3445 5 SWfRj 1C"gCO JrcP[R"U5R5n[R"U5R5nURUR:wa%[ SURSUR35eUR(d?[ [R [R 5n[R UlU$[R"[R"U55(a [U5n[R"[R"U55(a [U5nURUR:waSUR[R:wa [U5nUR[R:wa [U5nObUR[R[R[R[R4;a[U5n[U5nUSLa@[!XSX45[!XSX45-S- n[ U[R 5nXelU$USLa.[R""UR[R$S9nOfUbc[R"U5R5nURUR:wa%[ SURSUR35e[!XX#U5n[ U[R 5nXelU$) a Compute a weighted version of Kendall's :math:`\tau`. The weighted :math:`\tau` is a weighted version of Kendall's :math:`\tau` in which exchanges of high weight are more influential than exchanges of low weight. The default parameters compute the additive hyperbolic version of the index, :math:`\tau_\mathrm h`, which has been shown to provide the best balance between important and unimportant elements [1]_. The weighting is defined by means of a rank array, which assigns a nonnegative rank to each element (higher importance ranks being associated with smaller values, e.g., 0 is the highest possible rank), and a weigher function, which assigns a weight based on the rank to each element. The weight of an exchange is then the sum or the product of the weights of the ranks of the exchanged elements. The default parameters compute :math:`\tau_\mathrm h`: an exchange between elements with rank :math:`r` and :math:`s` (starting from zero) has weight :math:`1/(r+1) + 1/(s+1)`. Specifying a rank array is meaningful only if you have in mind an external criterion of importance. If, as it usually happens, you do not have in mind a specific rank, the weighted :math:`\tau` is defined by averaging the values obtained using the decreasing lexicographical rank by (`x`, `y`) and by (`y`, `x`). This is the behavior with default parameters. Note that the convention used here for ranking (lower values imply higher importance) is opposite to that used by other SciPy statistical functions. Parameters ---------- x, y : array_like Arrays of scores, of the same shape. If arrays are not 1-D, they will be flattened to 1-D. rank : array_like of ints or bool, optional A nonnegative rank assigned to each element. If it is None, the decreasing lexicographical rank by (`x`, `y`) will be used: elements of higher rank will be those with larger `x`-values, using `y`-values to break ties (in particular, swapping `x` and `y` will give a different result). If it is False, the element indices will be used directly as ranks. The default is True, in which case this function returns the average of the values obtained using the decreasing lexicographical rank by (`x`, `y`) and by (`y`, `x`). weigher : callable, optional The weigher function. Must map nonnegative integers (zero representing the most important element) to a nonnegative weight. The default, None, provides hyperbolic weighing, that is, rank :math:`r` is mapped to weight :math:`1/(r+1)`. additive : bool, optional If True, the weight of an exchange is computed by adding the weights of the ranks of the exchanged elements; otherwise, the weights are multiplied. The default is True. Returns ------- res: SignificanceResult An object containing attributes: statistic : float The weighted :math:`\tau` correlation index. pvalue : float Presently ``np.nan``, as the null distribution of the statistic is unknown (even in the additive hyperbolic case). See Also -------- kendalltau : Calculates Kendall's tau. spearmanr : Calculates a Spearman rank-order correlation coefficient. theilslopes : Computes the Theil-Sen estimator for a set of points (x, y). Notes ----- This function uses an :math:`O(n \log n)`, mergesort-based algorithm [1]_ that is a weighted extension of Knight's algorithm for Kendall's :math:`\tau` [2]_. It can compute Shieh's weighted :math:`\tau` [3]_ between rankings without ties (i.e., permutations) by setting `additive` and `rank` to False, as the definition given in [1]_ is a generalization of Shieh's. NaNs are considered the smallest possible score. .. versionadded:: 0.19.0 References ---------- .. [1] Sebastiano Vigna, "A weighted correlation index for rankings with ties", Proceedings of the 24th international conference on World Wide Web, pp. 1166-1176, ACM, 2015. .. [2] W.R. Knight, "A Computer Method for Calculating Kendall's Tau with Ungrouped Data", Journal of the American Statistical Association, Vol. 61, No. 314, Part 1, pp. 436-439, 1966. .. [3] Grace S. Shieh. "A weighted Kendall's tau statistic", Statistics & Probability Letters, Vol. 39, No. 1, pp. 17-24, 1998. Examples -------- >>> import numpy as np >>> from scipy import stats >>> x = [12, 2, 1, 12, 2] >>> y = [1, 4, 7, 1, 0] >>> res = stats.weightedtau(x, y) >>> res.statistic -0.56694968153682723 >>> res.pvalue nan >>> res = stats.weightedtau(x, y, additive=False) >>> res.statistic -0.62205716951801038 NaNs are considered the smallest possible score: >>> x = [12, 2, 1, 12, 2] >>> y = [1, 4, 7, 1, np.nan] >>> res = stats.weightedtau(x, y) >>> res.statistic -0.56694968153682723 This is exactly Kendall's tau: >>> x = [12, 2, 1, 12, 2] >>> y = [1, 4, 7, 1, 0] >>> res = stats.weightedtau(x, y, weigher=lambda x: 1) >>> res.statistic -0.47140452079103173 >>> x = [12, 2, 1, 12, 2] >>> y = [1, 4, 7, 1, 0] >>> stats.weightedtau(x, y, rank=None) SignificanceResult(statistic=-0.4157652301037516, pvalue=nan) >>> stats.weightedtau(y, x, rank=None) SignificanceResult(statistic=-0.7181341329699028, pvalue=nan) zCAll inputs to `weightedtau` must be of the same size, found x-size rOTNrFrz and rank-size )rrrrrrrrrrrrrint32float32rEraranger_)rrrweigheradditiver$rts rrjrjsDJ 1 A 1 Avv))* QVVHFG G 66 0&&  xxq  QK xxq  QK ww!'' 77bhh  A 77bhh  A 77288RXXrzz2::F F A A t| qT7 = qT7 = > !bff-  u}yyrww/ zz$%%' 99  !xtyykC  Q4( ;C S"&& )CO JrTtestResultBaserc<^\rSrSrSrSU4SjjrSSjrSrU=r$) TtestResultia Result of a t-test. See the documentation of the particular t-test function for more information about the definition of the statistic and meaning of the confidence interval. Attributes ---------- statistic : float or array The t-statistic of the sample. pvalue : float or array The p-value associated with the given alternative. df : float or array The number of degrees of freedom used in calculation of the t-statistic; this is one less than the size of the sample (``a.shape[axis]-1`` if there are no masked elements or omitted NaNs). Methods ------- confidence_interval Computes a confidence interval around the population statistic for the given confidence level. The confidence interval is returned in a ``namedtuple`` with fields `low` and `high`. c >[T U]XUS9 X@lXPlX`lUcUOUUlUR UlUc[X5Ul gUUl g)Nr) rrr_standard_error _estimate _statistic_npr_dtyper8_xp) rrrrrstandard_errorestimate statistic_nprrs rrTtestResult.__init__sX r2'-!*6*>YLoo 9;?95rc[URURXRURUR 5up#X R -UR-nX0R -UR-n[X#S9$)a Parameters ---------- confidence_level : float The confidence level for the calculation of the population mean confidence interval. Default is 0.95. Returns ------- ci : namedtuple The confidence interval is returned in a ``namedtuple`` with fields `low` and `high`. r) _t_confidence_intervalrrrrrrrr)rrrWrXs rrTtestResult.confidence_intervalsp+477D4F4F+;=N=N+/;;B (((4>>9***T^^;!c55r)rrrrrrNNrrrs@rr~r~s<(, L66rr~c [R"U5nU[R"U5nUR(aUSO[Rn[ XX#XES9$)Nrrrrr)rrisfiniterrr~)rrrrrrs rpack_TtestResultr sR-- ,Kbkk+67K$/$4$4+a."&&K yR&4 IIrcURURURURURUR 4$r)rrrrrrr$s runpack_TtestResultrs6 MM3::svvs/?/?    00rrr)r rrrc [U5n[XUS9upURUnUS- nUS:Xa[U5n[ XXXS9$UR XS9n UR U5nURS:aURXS9OUnX- n [XSS9n URX- 5n [R"S S S 9 URX5nURS:XaUS OUnSSS5 [UR UWR S 95n[#XXES9nURS:XaUS OUnUR%UR U5UR5nURS:XaUS OUnS SSS.Un[ UUUUXUR U5US9$![an [S5U eSn A ff=f!,(df  N=f)aCalculate the T-test for the mean of ONE group of scores. This is a test for the null hypothesis that the expected value (mean) of a sample of independent observations `a` is equal to the given population mean, `popmean`. Parameters ---------- a : array_like Sample observations. popmean : float or array_like Expected value in null hypothesis. If array_like, then its length along `axis` must equal 1, and it must otherwise be broadcastable with `a`. axis : int or None, optional Axis along which to compute test; default is 0. If None, compute over the whole array `a`. nan_policy : {'propagate', 'raise', 'omit'}, optional Defines how to handle when input contains nan. The following options are available (default is 'propagate'): * 'propagate': returns nan * 'raise': throws an error * 'omit': performs the calculations ignoring nan values alternative : {'two-sided', 'less', 'greater'}, optional Defines the alternative hypothesis. The following options are available (default is 'two-sided'): * 'two-sided': the mean of the underlying distribution of the sample is different than the given population mean (`popmean`) * 'less': the mean of the underlying distribution of the sample is less than the given population mean (`popmean`) * 'greater': the mean of the underlying distribution of the sample is greater than the given population mean (`popmean`) Returns ------- result : `~scipy.stats._result_classes.TtestResult` An object with the following attributes: statistic : float or array The t-statistic. pvalue : float or array The p-value associated with the given alternative. df : float or array The number of degrees of freedom used in calculation of the t-statistic; this is one less than the size of the sample (``a.shape[axis]``). .. versionadded:: 1.10.0 The object also has the following method: confidence_interval(confidence_level=0.95) Computes a confidence interval around the population mean for the given confidence level. The confidence interval is returned in a ``namedtuple`` with fields `low` and `high`. .. versionadded:: 1.10.0 Notes ----- The statistic is calculated as ``(np.mean(a) - popmean)/se``, where ``se`` is the standard error. Therefore, the statistic will be positive when the sample mean is greater than the population mean and negative when the sample mean is less than the population mean. Examples -------- Suppose we wish to test the null hypothesis that the mean of a population is equal to 0.5. We choose a confidence level of 99%; that is, we will reject the null hypothesis in favor of the alternative if the p-value is less than 0.01. When testing random variates from the standard uniform distribution, which has a mean of 0.5, we expect the data to be consistent with the null hypothesis most of the time. >>> import numpy as np >>> from scipy import stats >>> rng = np.random.default_rng() >>> rvs = stats.uniform.rvs(size=50, random_state=rng) >>> stats.ttest_1samp(rvs, popmean=0.5) TtestResult(statistic=2.456308468440, pvalue=0.017628209047638, df=49) As expected, the p-value of 0.017 is not below our threshold of 0.01, so we cannot reject the null hypothesis. When testing data from the standard *normal* distribution, which has a mean of 0, we would expect the null hypothesis to be rejected. >>> rvs = stats.norm.rvs(size=50, random_state=rng) >>> stats.ttest_1samp(rvs, popmean=0.5) TtestResult(statistic=-7.433605518875, pvalue=1.416760157221e-09, df=49) Indeed, the p-value is lower than our threshold of 0.01, so we reject the null hypothesis in favor of the default "two-sided" alternative: the mean of the population is *not* equal to 0.5. However, suppose we were to test the null hypothesis against the one-sided alternative that the mean of the population is *greater* than 0.5. Since the mean of the standard normal is less than 0.5, we would not expect the null hypothesis to be rejected. >>> stats.ttest_1samp(rvs, popmean=0.5, alternative='greater') TtestResult(statistic=-7.433605518875, pvalue=0.99999999929, df=49) Unsurprisingly, with a p-value greater than our threshold, we would not reject the null hypothesis. Note that when working with a confidence level of 99%, a true null hypothesis will be rejected approximately 1% of the time. >>> rvs = stats.uniform.rvs(size=(100, 50), random_state=rng) >>> res = stats.ttest_1samp(rvs, popmean=0.5, axis=1) >>> np.sum(res.pvalue < 0.01) 1 Indeed, even though all 100 samples above were drawn from the standard uniform distribution, which *does* have a population mean of 0.5, we would mistakenly reject the null hypothesis for one of them. `ttest_1samp` can also compute a confidence interval around the population mean. >>> rvs = stats.norm.rvs(size=50, random_state=rng) >>> res = stats.ttest_1samp(rvs, popmean=0) >>> ci = res.confidence_interval(confidence_level=0.95) >>> ci ConfidenceInterval(low=-0.3193887540880017, high=0.2898583388980972) The bounds of the 95% confidence interval are the minimum and maximum values of the parameter `popmean` for which the p-value of the test would be 0.05. >>> res = stats.ttest_1samp(rvs, popmean=ci.low) >>> np.testing.assert_allclose(res.pvalue, 0.05) >>> res = stats.ttest_1samp(rvs, popmean=ci.high) >>> np.testing.assert_allclose(res.pvalue, 0.05) Under certain assumptions about the population from which a sample is drawn, the confidence interval with confidence level 95% is expected to contain the true population mean in 95% of sample replications. >>> rvs = stats.norm.rvs(size=(50, 1000), loc=1, random_state=rng) >>> res = stats.ttest_1samp(rvs, popmean=0) >>> ci = res.confidence_interval() >>> contains_pop_mean = (ci.low < 1) & (ci.high > 1) >>> contains_pop_mean.sum() 953 rrrrr z#`popmean.shape[axis]` must equal 1.Nr.rrrrrrrr)rrrrrr)r8rrrr~rrrrprrgrrrrrArrr')rpopmeanrrrrrrrrrdrrrr roalternative_nums rrlrls|  B1r*GA  A QBAvqk3*-= = 7717 DG**W%4;LL14D"**W*0' A Q"A GGAENE Hh 7 IIa VVq[AbEa 8 2::b:8 9D q 3DyyA~484D B 1B77a<BRB!a@MO q$2?&+$&JJqMb ::' G>?QFG 8 7s$2F)F< F9( F44F9< G cUc UROUnUc [U5OUn[R"U5[R"U5pUS:dUS:a Sn[ U5eUS:a?Un[R "[R *[R"X55upOUS:aASU- n[R "[R"X5[R 5upOUS:XaeSU- S- n U SU - 4n[R"US/S/[R"U5R--5n[R"X5upO)[R "U[R5up{XpURXS9nURS:XaUSOUnURXS9n U RS:XaU SOU n X4$)Nrr4`confidence_level` must be a number between 0 and 1.rrr) rr8rrrrr!rstdtritrrr) rrrrrrrrrWrXtail_probabilitynanss rrrs}AGG%E!z rB JJrNBJJqM!/!3H!!Q ''1GH T q  ''(>G T   00!3 a 00 0 JJq1#BJJrN$7$7 77 8OOB* T%%a0T **S* &CXX]#b'C ::d: (DyyA~484D 9rcUc [XU5OUnX- n[R"SSS9 URXb5nSSS5 [R"W5n[R"U5n [ U[ R"U 5U[S9n UR XRS9n URS:XaUSOUnU RS:XaU SOU n Xz4$!,(df  N=f)Nrrrrrr) r8rrrrrrrrr) mean1mean2rrrrrrt_npdf_npros r_ttest_ind_from_statsrs13u -B A Hh 7 IIa  8 ::a=D JJrNE t]__U3[R HD ::d'': *D1"!AyyA~484D 7N 8 7s C C-c\Uc [X5OUnX- nX#- n[R"SSS9 XV-S-US-US- - US-US- - -- nSSS5 URUR W5UR S5U5nUR XV-5nXx4$!,(df  NU=f)Nrrrrr)r8rrrrrr) v1rv2rrvn1vn2rrs r_unequal_var_ttest_denomrs$&J BB 'C 'C Hh 7i!^sAva036R!V3DD E 8 "((2, 2 3B GGCI E 9 8 7s B B+cJUc [X5OUnURS5nURURUS:H5XP5nURURUS:H5XR5nX-S- nUS- U-US- U--U- nURUSU- SU- --5nXh4$)Nr rror)r8rrr) rrrrrrursvarrs r_equal_var_ttest_denomr&s$&J BB ::b>D "**R1W%t 0B "**R1W%t 0B 3B !VrMR!VrM )R /D GGDC"HsRx/0 1E 9rTtest_indResultc([XX45nURU5nURU5nURU5nURU5nU(a[US-X$S-XXS9upO[US-X$S-XXS9up[ XXU5n [ U 6$)aQ T-test for means of two independent samples from descriptive statistics. This is a test for the null hypothesis that two independent samples have identical average (expected) values. Parameters ---------- mean1 : array_like The mean(s) of sample 1. std1 : array_like The corrected sample standard deviation of sample 1 (i.e. ``ddof=1``). nobs1 : array_like The number(s) of observations of sample 1. mean2 : array_like The mean(s) of sample 2. std2 : array_like The corrected sample standard deviation of sample 2 (i.e. ``ddof=1``). nobs2 : array_like The number(s) of observations of sample 2. equal_var : bool, optional If True (default), perform a standard independent 2 sample test that assumes equal population variances [1]_. If False, perform Welch's t-test, which does not assume equal population variance [2]_. alternative : {'two-sided', 'less', 'greater'}, optional Defines the alternative hypothesis. The following options are available (default is 'two-sided'): * 'two-sided': the means of the distributions are unequal. * 'less': the mean of the first distribution is less than the mean of the second distribution. * 'greater': the mean of the first distribution is greater than the mean of the second distribution. .. versionadded:: 1.6.0 Returns ------- statistic : float or array The calculated t-statistics. pvalue : float or array The two-tailed p-value. See Also -------- scipy.stats.ttest_ind Notes ----- The statistic is calculated as ``(mean1 - mean2)/se``, where ``se`` is the standard error. Therefore, the statistic will be positive when `mean1` is greater than `mean2` and negative when `mean1` is less than `mean2`. This method does not check whether any of the elements of `std1` or `std2` are negative. If any elements of the `std1` or `std2` parameters are negative in a call to this method, this method will return the same result as if it were passed ``numpy.abs(std1)`` and ``numpy.abs(std2)``, respectively, instead; no exceptions or warnings will be emitted. References ---------- .. [1] https://en.wikipedia.org/wiki/T-test#Independent_two-sample_t-test .. [2] https://en.wikipedia.org/wiki/Welch%27s_t-test Examples -------- Suppose we have the summary data for two samples, as follows (with the Sample Variance being the corrected sample variance):: Sample Sample Size Mean Variance Sample 1 13 15.0 87.5 Sample 2 11 12.0 39.0 Apply the t-test to this data (with the assumption that the population variances are equal): >>> import numpy as np >>> from scipy.stats import ttest_ind_from_stats >>> ttest_ind_from_stats(mean1=15.0, std1=np.sqrt(87.5), nobs1=13, ... mean2=12.0, std2=np.sqrt(39.0), nobs2=11) Ttest_indResult(statistic=0.9051358093310269, pvalue=0.3751996797581487) For comparison, here is the data from which those summary statistics were taken. With this data, we can compute the same result using `scipy.stats.ttest_ind`: >>> a = np.array([1, 3, 4, 6, 11, 13, 15, 19, 22, 24, 25, 26, 26]) >>> b = np.array([2, 4, 6, 9, 11, 13, 14, 15, 18, 19, 21]) >>> from scipy.stats import ttest_ind >>> ttest_ind(a, b) TtestResult(statistic=0.905135809331027, pvalue=0.3751996797581486, df=22.0) Suppose we instead have binary data and would like to apply a t-test to compare the proportion of 1s in two independent groups:: Number of Sample Sample Size ones Mean Variance Sample 1 150 30 0.2 0.161073 Sample 2 200 45 0.225 0.175251 The sample mean :math:`\hat{p}` is the proportion of ones in the sample and the variance for a binary observation is estimated by :math:`\hat{p}(1-\hat{p})`. >>> ttest_ind_from_stats(mean1=0.2, std1=np.sqrt(0.161073), nobs1=150, ... mean2=0.225, std2=np.sqrt(0.175251), nobs2=200) Ttest_indResult(statistic=-0.5627187905196761, pvalue=0.5739887114209541) For comparison, we could compute the t statistic and p-value using arrays of 0s and 1s and `scipy.stat.ttest_ind`, as above. >>> group1 = np.array([1]*30 + [0]*(150-30)) >>> group2 = np.array([1]*45 + [0]*(200-45)) >>> ttest_ind(group1, group2) TtestResult(statistic=-0.5627179589855622, pvalue=0.573989277115258, df=348.0) rr)r8rrrrr) rstd1nobs1rstd2nobs2 equal_varrrrrr$s rrnrn;s| e 2B JJu E ::d D JJu E ::d D*47E7EQ E,T1We1WeS  e EC C  rz-Use ``method`` to perform a permutation test.z1.17.0 permutations random_state)versiondeprecated_argscustom_message)rrrrrrtrimr4c [X5n U RS5Rn U RURS5(aU R X 5nU RURS5(aU R X5nSUs=::aS:d O [ S5e[ U [[-S-5(d Sn [ U 5e[U 5(dU b Sn [U 5e[X4US 9n U RU [XU S 95nURS:XaUS OUn[U5S:Xd[U5S:Xa [!XXXS 9$S SSS.nUb\US:waVSn [U 5(d [U 5eSn US:wa [U 5e[#XUX#UUUS9unnXUnnn[!UUUXUUS 9$U RUR$UURS9nU RUR$UURS9nUS:XaS[&R("SSS9 [+XSU S9n[+XSU S9nSSS5 U R-XS 9nU R-XS 9nO=Sn [U 5(d [U 5e[/XU5unnn[/XU5unnnU(a[1WUWUU S 9unnO[3WUWUU S 9unnU c[5UUUUU5unnO[7X8S9nX'UU 5unnU R;UUR$5nURS:XaUS OUnUU- n[!UUUXUUS 9$!,(df  GN =f)aH, Calculate the T-test for the means of *two independent* samples of scores. This is a test for the null hypothesis that 2 independent samples have identical average (expected) values. This test assumes that the populations have identical variances by default. Parameters ---------- a, b : array_like The arrays must have the same shape, except in the dimension corresponding to `axis` (the first, by default). axis : int or None, optional Axis along which to compute test. If None, compute over the whole arrays, `a`, and `b`. equal_var : bool, optional If True (default), perform a standard independent 2 sample test that assumes equal population variances [1]_. If False, perform Welch's t-test, which does not assume equal population variance [2]_. .. versionadded:: 0.11.0 nan_policy : {'propagate', 'raise', 'omit'}, optional Defines how to handle when input contains nan. The following options are available (default is 'propagate'): * 'propagate': returns nan * 'raise': throws an error * 'omit': performs the calculations ignoring nan values The 'omit' option is not currently available for permutation tests or one-sided asymptotic 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. .. deprecated:: 1.17.0 `permutations` is deprecated and will be removed in SciPy 1.7.0. Use the `n_resamples` argument of `PermutationMethod`, instead, and pass the instance as the `method` argument. 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). .. deprecated:: 1.17.0 `random_state` is deprecated and will be removed in SciPy 1.7.0. Use the `rng` argument of `PermutationMethod`, instead, and pass the instance as the `method` argument. alternative : {'two-sided', 'less', 'greater'}, optional Defines the alternative hypothesis. The following options are available (default is 'two-sided'): * 'two-sided': the means of the distributions underlying the samples are unequal. * 'less': the mean of the distribution underlying the first sample is less than the mean of the distribution underlying the second sample. * 'greater': the mean of the distribution underlying the first sample is greater than the mean of the distribution underlying the second sample. 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). method : ResamplingMethod, optional Defines the method used to compute the p-value. If `method` is an instance of `PermutationMethod`/`MonteCarloMethod`, the p-value is computed using `scipy.stats.permutation_test`/`scipy.stats.monte_carlo_test` with the provided configuration options and other appropriate settings. Otherwise, the p-value is computed by comparing the test statistic against a theoretical t-distribution. .. versionadded:: 1.15.0 Returns ------- result : `~scipy.stats._result_classes.TtestResult` An object with the following attributes: statistic : float or ndarray The t-statistic. pvalue : float or ndarray The p-value associated with the given alternative. df : float or ndarray The number of degrees of freedom used in calculation of the t-statistic. This is always NaN for a permutation t-test. .. versionadded:: 1.11.0 The object also has the following method: confidence_interval(confidence_level=0.95) Computes a confidence interval around the difference in population means for the given confidence level. The confidence interval is returned in a ``namedtuple`` with fields ``low`` and ``high``. When a permutation t-test is performed, the confidence interval is not computed, and fields ``low`` and ``high`` contain NaN. .. versionadded:: 1.11.0 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. (In the following, note that the argument `permutations` itself is deprecated, but a nearly identical test may be performed by creating an instance of `scipy.stats.PermutationMethod` with ``n_resamples=permutuations`` and passing it as the `method` argument.) When ``1 < permutations < binom(n, k)``, where * ``k`` is the number of observations in `a`, * ``n`` is the total number of observations in `a` and `b`, and * ``binom(n, k)`` is the binomial coefficient (``n`` choose ``k``), the data are pooled (concatenated), randomly assigned to either group `a` or `b`, and the t-statistic is calculated. This process is performed repeatedly (`permutation` times), generating a distribution of the t-statistic under the null hypothesis, and the t-statistic of the observed data is compared to this distribution to determine the p-value. Specifically, the p-value reported is the "achieved significance level" (ASL) as defined in 4.4 of [3]_. Note that there are other ways of estimating p-values using randomized permutation tests; for other options, see the more general `permutation_test`. When ``permutations >= binom(n, k)``, an exact test is performed: the data are partitioned between the groups in each distinct way exactly once. The permutation test can be computationally expensive and not necessarily more accurate than the analytical test, but it does not make strong assumptions about the shape of the underlying distribution. Use of trimming is commonly referred to as the trimmed t-test. At times called Yuen's t-test, this is an extension of Welch's t-test, with the difference being the use of winsorized means in calculation of the variance and the trimmed sample size in calculation of the statistic. Trimming is recommended if the underlying distribution is long-tailed or contaminated with outliers [4]_. The statistic is calculated as ``(np.mean(a) - np.mean(b))/se``, where ``se`` is the standard error. Therefore, the statistic will be positive when the sample mean of `a` is greater than the sample mean of `b` and negative when the sample mean of `a` is less than the sample mean of `b`. References ---------- .. [1] https://en.wikipedia.org/wiki/T-test#Independent_two-sample_t-test .. [2] https://en.wikipedia.org/wiki/Welch%27s_t-test .. [3] B. Efron and T. Hastie. Computer Age Statistical Inference. (2016). .. [4] Yuen, Karen K. "The Two-Sample Trimmed t for Unequal Population Variances." Biometrika, vol. 61, no. 1, 1974, pp. 165-170. JSTOR, www.jstor.org/stable/2334299. Accessed 30 Mar. 2021. .. [5] Yuen, Karen K., and W. J. Dixon. "The Approximate Behaviour and Performance of the Two-Sample Trimmed t." Biometrika, vol. 60, no. 2, 1973, pp. 369-374. JSTOR, www.jstor.org/stable/2334550. Accessed 30 Mar. 2021. Examples -------- >>> import numpy as np >>> from scipy import stats >>> rng = np.random.default_rng() Test with sample with identical means: >>> rvs1 = stats.norm.rvs(loc=5, scale=10, size=500, random_state=rng) >>> rvs2 = stats.norm.rvs(loc=5, scale=10, size=500, random_state=rng) >>> stats.ttest_ind(rvs1, rvs2) TtestResult(statistic=-0.4390847099199348, pvalue=0.6606952038870015, df=998.0) >>> stats.ttest_ind(rvs1, rvs2, equal_var=False) TtestResult(statistic=-0.4390847099199348, pvalue=0.6606952553131064, df=997.4602304121448) `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) TtestResult(statistic=-1.6370984482905417, pvalue=0.1019251574705033, df=998.0) >>> stats.ttest_ind(rvs1, rvs3, equal_var=False) TtestResult(statistic=-1.637098448290542, pvalue=0.10202110497954867, df=765.1098655246868) 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) TtestResult(statistic=-1.9481646859513422, pvalue=0.05186270935842703, df=598.0) >>> stats.ttest_ind(rvs1, rvs4, equal_var=False) TtestResult(statistic=-1.3146566100751664, pvalue=0.1913495266513811, df=110.41349083985212) 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) TtestResult(statistic=-2.8415950600298774, pvalue=0.0046418707568707885, df=598.0) >>> stats.ttest_ind(rvs1, rvs5, equal_var=False) TtestResult(statistic=-1.8686598649188084, pvalue=0.06434714193919686, df=109.32167496550137) 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) TtestResult(statistic=3.4463884028073513, pvalue=0.01369338726499547, df=6.0) rrrr.z/Trimming percentage should be 0 <= `trim` < .5.Nzj`method` must be an instance of `PermutationMethod`, an instance of `MonteCarloMethod`, or None (default).z?Use of resampling methods is compatible only with NumPy arrays.r rrrrrrz;Use of `permutations` is compatible only with NumPy arrays.z>Use of `permutations` is incompatible with with use of `trim`.)rrrrrrrrr)rrz3Use of `trim` is compatible only with NumPy arrays.)rr)r8rrrrrrr#r"r9NotImplementedErrorr,rrrr:r~_permutation_ttestrrrrgr_ttest_trim_var_mean_lenrrrdict_ttest_resamplingr')rrrrrrrrrr4r default_floatr result_shaperalternative_numsrrorrrrrrrm1rs ttest_kwargss rrmrms`l  BJJrN((M zz!'':&& IIa ' zz!'':&& IIa ' NNJKK f/2BBTI J J?!! B<1< >4 "8E1dr7G7T*/(D D AGGDM 1B AGGDM 1B qy [[( ;aA"-BaA"-B<WWQW " WWQW "G||%g. .-at< B-at< B*2r2rbA E,RRC E ~'Br;G4i; #A$\6R4 QWW %B77Q;BBBBwH q$23C3P&+h @@?< ;s $L?? Mcl^U4Sjn[U[5(a[O[nUR 5nU[LaOUR SS5=nb:[ RRU5nURUR4US'U"X44XbUS.UD6n U RU R4$)Nc4>[X4SU0TD6R$)Nr)rmr)rrrrs rr$_ttest_resampling..statistic:s9D9L9CCCrr;rr) rr#r&r%rrrrrr0rr) rrrrrr4rtestr;r$s ` rrr9sD!+63D E E ! ^^ F ::eT* *C 7))'',CJJ 2F5M w 2)& 2*0 2C ==#** $$rc[R"XS9nURUn[X1-5n[ XU5nUSU--n[ XUS9nXVU4$)zCVariance, mean, and length of winsorized input along specified axisr r)rrrr_calculate_winsorized_variancerc)rrrrgrrs rrrNs` A  A AH A 'qT2AQJA !%A 7Nrc\US:Xa [USUS9$[R"XS5n[R"[R"U5SS9nUSU/4USSU24'USU*S- /4USU*S24'[R "[USU-S-SS95n[R XT'U$) z;Calculates g-times winsorized variance along specified axisrr)rrrr .Nr)rgrrrrrr)rrra_win nans_indicesvar_wins rrrfs AvAAD)) KK $E66"((5/3L38_E#rr'NC1"q&M*E#rs(Ojje1q519B?@G FFG Nrc^^ [T5mURSm [R"T U5nX:aUU 4Sj[ U55nOUnS[ UT U- 55n/n[ USS9Hen[R"U5nUSU4n [R"U SS5n U SS U24n U SUS 24n UR[XU55 Mg [R"USS 9nXqU4$) z2Generation permutation distribution of t statisticrc3F># UHnTRT5v M g7fr) permutation)rIrrrs rrK._permutation_distribution_t..s&8#6a'22488#6r}c3N# UHn[R"U5v M g7fr)rr)rIr,s rrKrs$I#Ga..++#Gs#%2)batch.r^rNr ) r rrcombrGr r(rrrrH _calc_t_statr) datarsize_arrn_maxperm_generatort_statindices data_permrrrs ` @r_permutation_distribution_trs&l3L ::b>D LLv &E8#(#68 I#264;#GIF#N"=((7#g& KK 2q1 c7F7l # c67l # l134>^^F +F  &&rc URUnURUn[R"XS9n[R"XS9n[XSS9n[XSS9n U(d[ XX5upO[ XX5upXg- U - $)z4Calculate the t statistic along the given dimension.r rr.)rrrrgrr) rrrrnanbavg_aavg_bvar_avar_brrs rrrs~ B B GGA !E GGA !E A &E A &E +EuA5)%U? K rcUS:d*[R"U5(a[U5U:wa [S5e[ U5n[ XXCS9nUR Un [X4US9n [R"XS5n [XXUS9upn [R[RSS.n X"X5nX:aSOSnURSS9U-X/-- nUS :Xa[R"U5R5(ai[R"U5S:Xa([R "[R"5nUU4$[R"U[R"U5'UU4$) aS Calculates the T-test for the means of TWO INDEPENDENT samples of scores using permutation methods. This test is similar to `stats.ttest_ind`, except it doesn't rely on an approximate normality assumption since it uses a permutation test. This function is only called from ttest_ind when permutations is not None. Parameters ---------- a, b : array_like The arrays must be broadcastable, except along the dimension corresponding to `axis` (the zeroth, by default). axis : int, optional The axis over which to operate on a and b. permutations : int, optional Number of permutations used to calculate p-value. If greater than or equal to the number of distinct permutations, perform an exact test. equal_var : bool, optional If False, an equal variance (Welch's) t-test is conducted. Otherwise, an ordinary t-test is conducted. random_state : {None, int, `numpy.random.Generator`}, optional If `seed` is None the `numpy.random.Generator` singleton is used. If `seed` is an int, a new ``Generator`` instance is used, seeded with `seed`. If `seed` is already a ``Generator`` instance then that instance is used. Pseudorandom number generator state used for generating random permutations. Returns ------- statistic : float or array The calculated t-statistic. pvalue : float or array The p-value. rz,Permutations must be a non-negative integer.r r)rrrcjU[R"U5*:*U[R"U5:-$r)rrVrs rr$_permutation_ttest..s#!q z/a266!9n)Mr)rrrrr)rrrrr rrr*rr less_equal greater_equalrrrrrEr)rrrrrrrrt_stat_observedrmatrrr)cmps adjustmentpvaluess rrrsXRaBKK 55 -=GHH%l3L"1>O B !d 3C ++c $C"= "!##F%}}**MOG   8D*JxxQx*,1JKG[ RXXo%>%B%B%D%D 777 q jj(G W %%24GBHH_- . W %%rcpURUnU$![a [XRU5Sef=fr)r IndexErrorrr)rrrrs r_get_lenrs?5 GGDM H 5ffc*45s"5)r rrrrc[X- SX$SS9$)apCalculate the t-test on TWO RELATED samples of scores, a and b. This is a test for the null hypothesis that two related or repeated samples have identical average (expected) values. Parameters ---------- a, b : array_like The arrays must have the same shape. axis : int or None, optional Axis along which to compute test. If None, compute over the whole arrays, `a`, and `b`. nan_policy : {'propagate', 'raise', 'omit'}, optional Defines how to handle when input contains nan. The following options are available (default is 'propagate'): * 'propagate': returns nan * 'raise': throws an error * 'omit': performs the calculations ignoring nan values alternative : {'two-sided', 'less', 'greater'}, optional Defines the alternative hypothesis. The following options are available (default is 'two-sided'): * 'two-sided': the means of the distributions underlying the samples are unequal. * 'less': the mean of the distribution underlying the first sample is less than the mean of the distribution underlying the second sample. * 'greater': the mean of the distribution underlying the first sample is greater than the mean of the distribution underlying the second sample. .. versionadded:: 1.6.0 Returns ------- result : `~scipy.stats._result_classes.TtestResult` An object with the following attributes: statistic : float or array The t-statistic. pvalue : float or array The p-value associated with the given alternative. df : float or array The number of degrees of freedom used in calculation of the t-statistic; this is one less than the size of the sample (``a.shape[axis]``). .. versionadded:: 1.10.0 The object also has the following method: confidence_interval(confidence_level=0.95) Computes a confidence interval around the difference in population means for the given confidence level. The confidence interval is returned in a ``namedtuple`` with fields `low` and `high`. .. versionadded:: 1.10.0 Notes ----- Examples for use are scores of the same set of student in different exams, or repeated sampling from the same units. The test measures whether the average score differs significantly across samples (e.g. exams). If we observe a large p-value, for example greater than 0.05 or 0.1 then we cannot reject the null hypothesis of identical average scores. If the p-value is smaller than the threshold, e.g. 1%, 5% or 10%, then we reject the null hypothesis of equal averages. Small p-values are associated with large t-statistics. The t-statistic is calculated as ``np.mean(a - b)/se``, where ``se`` is the standard error. Therefore, the t-statistic will be positive when the sample mean of ``a - b`` is greater than zero and negative when the sample mean of ``a - b`` is less than zero. References ---------- https://en.wikipedia.org/wiki/T-test#Dependent_t-test_for_paired_samples Examples -------- >>> import numpy as np >>> from scipy import stats >>> rng = np.random.default_rng() >>> rvs1 = stats.norm.rvs(loc=5, scale=10, size=500, random_state=rng) >>> rvs2 = (stats.norm.rvs(loc=5, scale=10, size=500, random_state=rng) ... + stats.norm.rvs(scale=0.2, size=500, random_state=rng)) >>> stats.ttest_rel(rvs1, rvs2) TtestResult(statistic=-0.4549717054410304, pvalue=0.6493274702088672, df=499) >>> rvs3 = (stats.norm.rvs(loc=8, scale=10, size=500, random_state=rng) ... + stats.norm.rvs(scale=0.2, size=500, random_state=rng)) >>> stats.ttest_rel(rvs1, rvs3) TtestResult(statistic=-5.879467544540889, pvalue=7.540777129099917e-09, df=499) rT)rrrr-)rl)rrrrrs rrorosL quad $ &&rgr^gUUUUUU?)pearsonzlog-likelihoodz freeman-tukeyzmod-log-likelihoodneymanz cressie-readc[US5(aKURUS9n[U[R5(aUR S:Xa [ U5nU$Uc [U5nU$URUnU$)zCount the number of non-masked elements of an array. This function behaves like `np.ma.count`, but is much faster for ndarrays. rr r) hasattrrrrndarrayrrr:r)rrrnums r_m_countrsy q'gg4g  c2:: & &388q=c(C J <!*C J''$-C Jrc[RRU5(aQ[RR[R"X5[R"UR U5S9$UR X5$)N)r)rr isMaskedArray masked_arrayr'r)rrrs r_m_broadcast_torsa uu1uu!!"//!";')qvvu'E"G G ??1 $$rc[RRU5(a0URU5nU(aU$[R"U5$URXS9$r)rrrrr)rr preserve_maskrrs r_m_sumrsJ uu1eeDk#s8C8 66!6 rc[RRU5(a#[R"UR XS95$UR XUS9$)NrD)rrrrr)rrrrs r_m_meanrsD uu1zz!&&d&>?? 771(7 33rPower_divergenceResultc[XX#US9$)aCressie-Read power divergence statistic and goodness of fit test. This function tests the null hypothesis that the categorical data has the given frequencies, using the Cressie-Read power divergence statistic. Parameters ---------- f_obs : array_like Observed frequencies in each category. .. deprecated:: 1.14.0 Support for masked array input was deprecated in SciPy 1.14.0 and will be removed in version 1.16.0. f_exp : array_like, optional Expected frequencies in each category. By default the categories are assumed to be equally likely. .. deprecated:: 1.14.0 Support for masked array input was deprecated in SciPy 1.14.0 and will be removed in version 1.16.0. ddof : int, optional "Delta degrees of freedom": adjustment to the degrees of freedom for the p-value. The p-value is computed using a chi-squared distribution with ``k - 1 - ddof`` degrees of freedom, where `k` is the number of observed frequencies. The default value of `ddof` is 0. axis : int or None, optional The axis of the broadcast result of `f_obs` and `f_exp` along which to apply the test. If axis is None, all values in `f_obs` are treated as a single data set. Default is 0. lambda_ : float or str, optional The power in the Cressie-Read power divergence statistic. The default is 1. For convenience, `lambda_` may be assigned one of the following strings, in which case the corresponding numerical value is used: * ``"pearson"`` (value 1) Pearson's chi-squared statistic. In this case, the function is equivalent to `chisquare`. * ``"log-likelihood"`` (value 0) Log-likelihood ratio. Also known as the G-test [3]_. * ``"freeman-tukey"`` (value -1/2) Freeman-Tukey statistic. * ``"mod-log-likelihood"`` (value -1) Modified log-likelihood ratio. * ``"neyman"`` (value -2) Neyman's statistic. * ``"cressie-read"`` (value 2/3) The power recommended in [5]_. Returns ------- res: Power_divergenceResult An object containing attributes: statistic : float or ndarray The Cressie-Read power divergence test statistic. The value is a float if `axis` is None or if` `f_obs` and `f_exp` are 1-D. pvalue : float or ndarray The p-value of the test. The value is a float if `ddof` and the return value `stat` are scalars. See Also -------- chisquare Notes ----- This test is invalid when the observed or expected frequencies in each category are too small. A typical rule is that all of the observed and expected frequencies should be at least 5. Also, the sum of the observed and expected frequencies must be the same for the test to be valid; `power_divergence` raises an error if the sums do not agree within a relative tolerance of ``eps**0.5``, where ``eps`` is the precision of the input dtype. When `lambda_` is less than zero, the formula for the statistic involves dividing by `f_obs`, so a warning or error may be generated if any value in `f_obs` is 0. Similarly, a warning or error may be generated if any value in `f_exp` is zero when `lambda_` >= 0. The default degrees of freedom, k-1, are for the case when no parameters of the distribution are estimated. If p parameters are estimated by efficient maximum likelihood then the correct degrees of freedom are k-1-p. If the parameters are estimated in a different way, then the dof can be between k-1-p and k-1. However, it is also possible that the asymptotic distribution is not a chisquare, in which case this test is not appropriate. References ---------- .. [1] Lowry, Richard. "Concepts and Applications of Inferential Statistics". Chapter 8. https://web.archive.org/web/20171015035606/http://faculty.vassar.edu/lowry/ch8pt1.html .. [2] "Chi-squared test", https://en.wikipedia.org/wiki/Chi-squared_test .. [3] "G-test", https://en.wikipedia.org/wiki/G-test .. [4] Sokal, R. R. and Rohlf, F. J. "Biometry: the principles and practice of statistics in biological research", New York: Freeman (1981) .. [5] Cressie, N. and Read, T. R. C., "Multinomial Goodness-of-Fit Tests", J. Royal Stat. Soc. Series B, Vol. 46, No. 3 (1984), pp. 440-464. Examples -------- (See `chisquare` for more examples.) When just `f_obs` is given, it is assumed that the expected frequencies are uniform and given by the mean of the observed frequencies. Here we perform a G-test (i.e. use the log-likelihood ratio statistic): >>> import numpy as np >>> from scipy.stats import power_divergence >>> power_divergence([16, 18, 16, 14, 12, 12], lambda_='log-likelihood') (2.006573162632538, 0.84823476779463769) The expected frequencies can be given with the `f_exp` argument: >>> power_divergence([16, 18, 16, 14, 12, 12], ... f_exp=[16, 16, 16, 16, 16, 8], ... lambda_='log-likelihood') (3.3281031458963746, 0.6495419288047497) When `f_obs` is 2-D, by default the test is applied to each column. >>> obs = np.array([[16, 18, 16, 14, 12, 12], [32, 24, 16, 28, 20, 24]]).T >>> obs.shape (6, 2) >>> power_divergence(obs, lambda_="log-likelihood") (array([ 2.00657316, 6.77634498]), array([ 0.84823477, 0.23781225])) By setting ``axis=None``, the test is applied to all data in the array, which is equivalent to applying the test to the flattened array. >>> power_divergence(obs, axis=None) (23.31034482758621, 0.015975692534127565) >>> power_divergence(obs.ravel()) (23.31034482758621, 0.015975692534127565) `ddof` is the change to make to the default degrees of freedom. >>> power_divergence([16, 18, 16, 14, 12, 12], ddof=1) (2.0, 0.73575888234288467) The calculation of the p-values is done by broadcasting the test statistic with `ddof`. >>> power_divergence([16, 18, 16, 14, 12, 12], ddof=[0,1,2]) (2.0, array([ 0.84914504, 0.73575888, 0.5724067 ])) `f_obs` and `f_exp` are also broadcast. In the following, `f_obs` has shape (6,) and `f_exp` has shape (2, 6), so the result of broadcasting `f_obs` and `f_exp` has shape (2, 6). To compute the desired chi-squared statistics, we must use ``axis=1``: >>> power_divergence([16, 18, 16, 14, 12, 12], ... f_exp=[[16, 16, 16, 16, 16, 8], ... [8, 20, 20, 16, 12, 12]], ... axis=1) (array([ 3.5 , 9.25]), array([ 0.62338763, 0.09949846])) )f_exprrlambda__power_divergence)f_obsr rrr s rrtrtsP Udw WWrc4 [U5nURS5Rn[U[5(aOU[ ;a;[ [[ R555SSn[SU<SU35e[ UnOUcSnSn U "U5 [RRU5(aUOURU5nURURS5(aUO URn [RRU5(aURU 5OURX S9n[US 5(aUR[R 5OURXR S9n UGbU "U5 [RRU5(aUOURU5nURURS5(aUO URn [RRU5(aURU 5OURXS9n[#U R$UR$45n ['XUS 9n ['XUS 9nU(aUR)URUR5n UR+U 5R,S -n[R."S S 9 [1XSUS9n[1XSUS9nUR3UU- 5UR5UU5- nUR7UU:SS9nSSS5 W(aSUSW3n[U5eO([R."S S 9 [9XSUS9nSSS5 US:Xa X- S-U- nOaUS:XaS[:R<"XU- 5-nO>US:XaS[:R<"XU- 5-nOXU- U-S- -nUS U-US---n[1UUSUS9n[?UX6S9nURU5nURUS- U- 5n[AU5n[CUUSSUS9nURDS:XaUSOUnURDS:XaUSOUn[GUU5$!,(df  GNT=f!,(df  GN#=f)Nrrrzinvalid string for lambda_: z. Valid strings are c|[U[R5(aSn[R"U[ SS9 gg)Nz`power_divergence` and `chisquare` support for masked array input was deprecated in SciPy 1.14.0 and will be removed in version 1.16.0.rr)rrr$rrr/)argrs r warn_masked&_power_divergence..warn_maskedqs6 c2>> * *T  MM'#5! D +rrrrrr.rrRF)rrrr zFor 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: T)rrrrrrorrrr)$r8rrrr5_power_div_lambda_namesrNr_keysrrrrrrrrEr+rrrrTrUrrrVrrrrxlogyrrrrr)rr rrr  sum_checkrrnamesrr f_obs_floatbshape dtype_resrtol f_obs_sum f_exp_sum relative_diff diff_gt_tolrtermsstatnum_obsrrrs rr r cs  BJJrN((M'3 1 15::<=>qDE;G;G227:; ;)'2 EUU((//ERZZ5FEZZ Z@@MekkE$&EE$7$7$>$>U\\% **U*0 /6uf/E/E5<< + 5 ; E,,U33E9J!#EKK!D!D %++(*(;(;E(B(Be$jjj4 #K$5$5u{{#CD%kbA "5 u{{EKK@I88I&**C/DX.";SUV "55RP !# I(=!>!#Iy!A"B  ff]T%9fE / "F"F' * !o% [[ *EtCE+ !|"U* AgmmE5=99 BgmmE5=99%-'1A56 w'A+.. %d$2 >Du4/G ::d D GaK$& 'B r?D t)uQS TFyyA~484D!;;!+VBZF !$ //c/."+ *sAQ6 R6 R R)rc [XX#SUS9$)aPerform Pearson's chi-squared test. Pearson's chi-squared test [1]_ is a goodness-of-fit test for a multinomial distribution with given probabilities; that is, it assesses the null hypothesis that the observed frequencies (counts) are obtained by independent sampling of *N* observations from a categorical distribution with given expected 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 categories. 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. sum_check : bool, optional Whether to perform a check that ``sum(f_obs) - sum(f_exp) == 0``. If True, (default) raise an error when the relative difference exceeds the square root of the precision of the data type. See Notes for rationale and possible exceptions. Returns ------- res: Power_divergenceResult An object containing attributes: statistic : 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. pvalue : float or ndarray The p-value of the test. The value is a float if `ddof` and the result attribute `statistic` 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. :ref:`hypothesis_chisquare` : Extended example 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 [2]_, the total number of observations is recommended to be greater than 13, otherwise exact tests (such as Barnard's Exact test) should be used because they do not overreject. 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. For Pearson's chi-squared test, the total observed and expected counts must match for the p-value to accurately reflect the probability of observing such an extreme value of the statistic under the null hypothesis. This function may be used to perform other statistical tests that do not require the total counts to be equal. For instance, to test the null hypothesis that ``f_obs[i]`` is Poisson-distributed with expectation ``f_exp[i]``, set ``ddof=-1`` and ``sum_check=False``. This test follows from the fact that a Poisson random variable with mean and variance ``f_exp[i]`` is approximately normal with the same mean and variance; the chi-squared statistic standardizes, squares, and sums the observations; and the sum of ``n`` squared standard normal variables follows the chi-squared distribution with ``n`` degrees of freedom. References ---------- .. [1] "Pearson's chi-squared test". *Wikipedia*. https://en.wikipedia.org/wiki/Pearson%27s_chi-squared_test .. [2] 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 only the mandatory `f_obs` argument is given, it is assumed that the expected frequencies are uniform and given by the mean of the observed frequencies: >>> import numpy as np >>> from scipy.stats import chisquare >>> chisquare([16, 18, 16, 14, 12, 12]) Power_divergenceResult(statistic=2.0, pvalue=0.84914503608460956) The optional `f_exp` argument gives the expected frequencies. >>> chisquare([16, 18, 16, 14, 12, 12], f_exp=[16, 16, 16, 16, 16, 8]) Power_divergenceResult(statistic=3.5, pvalue=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) Power_divergenceResult(statistic=array([2. , 6.66666667]), pvalue=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) Power_divergenceResult(statistic=23.31034482758621, pvalue=0.015975692534127565) >>> chisquare(obs.ravel()) Power_divergenceResult(statistic=23.310344827586206, pvalue=0.01597569253412758) `ddof` is the change to make to the default degrees of freedom. >>> chisquare([16, 18, 16, 14, 12, 12], ddof=1) Power_divergenceResult(statistic=2.0, pvalue=0.7357588823428847) 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]) Power_divergenceResult(statistic=2.0, pvalue=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) Power_divergenceResult(statistic=array([3.5 , 9.25]), pvalue=array([0.62338763, 0.09949846])) For a more detailed example, see :ref:`hypothesis_chisquare`. r)r rrr rr )rr rrrs rrsrss` Ud%.) EEr KstestResultstatistic_locationstatistic_signc[U5n[R"SUS-5U- U- nUR5nXnX4U4$)aComputes D+ as used in the Kolmogorov-Smirnov test. Parameters ---------- cdfvals : array_like Sorted array of CDF values between 0 and 1 x: array_like Sorted array of the stochastic variable itself Returns ------- res: Pair with the following elements: - The maximum distance of the CDF values below Uniform(0, 1). - The location at which the maximum is reached. rrrrryr)cdfvalsrrdplusamaxloc_maxs r_compute_dplusr.ZsJ" G A YYsAE "Q & 0E <<>DgG K !!rc[U5nU[R"SU5U- - nUR5nXnX4U4$)ayComputes D- as used in the Kolmogorov-Smirnov test. Parameters ---------- cdfvals : array_like Sorted array of CDF values between 0 and 1 x: array_like Sorted array of the stochastic variable itself Returns ------- res: Pair with the following elements: - Maximum distance of the CDF values above Uniform(0, 1) - The location at which the maximum is reached. r r))r*rrdminusr,r-s r_compute_dminusr1rsF G A #q)!++F ==?DgG L' ""rc[XUUS9$)Nr&r')r%)rrr&r's r_tuple_to_KstestResultr4s  +='5 77rc</UQURPURP7$rr3rs r_KstestResult_to_tupler6s# ;C ;'' ;);); ;;r)rrrrEr4cUnSSSS.RUR5SU5nUS;a[SU<35e[U5n[R "U5nU"U/UQ76n[R "S5nUS:Xa6[Xp5up[U [RRX5U US 9$US:Xa7[Xp5up[U [RRX5U U*S 9$[Xp5up[Xp5upX:aU nU n UnOU nU n U*nUS :XaS nUS :Xa [RRX5nO_US :Xa7[RRU[R"U5-5nO"S [RRX5-n[R "USS5n[UUU US 9$)aF Performs the one-sample Kolmogorov-Smirnov test for goodness of fit. This test compares the underlying distribution F(x) of a sample against a given continuous distribution G(x). See Notes for a description of the available null and alternative hypotheses. Parameters ---------- x : array_like a 1-D array of observations of iid random variables. cdf : callable callable used to calculate the cdf. args : tuple, sequence, optional Distribution parameters, used with `cdf`. alternative : {'two-sided', 'less', 'greater'}, optional Defines the null and alternative hypotheses. Default is 'two-sided'. Please see explanations in the Notes below. method : {'auto', 'exact', 'approx', 'asymp'}, optional Defines the distribution used for calculating the p-value. The following options are available (default is 'auto'): * 'auto' : selects one of the other options. * 'exact' : uses the exact distribution of test statistic. * 'approx' : approximates the two-sided probability with twice the one-sided probability * 'asymp': uses asymptotic distribution of test statistic Returns ------- res: KstestResult An object containing attributes: statistic : float KS test statistic, either D+, D-, or D (the maximum of the two) pvalue : float One-tailed or two-tailed p-value. statistic_location : float Value of `x` corresponding with the KS statistic; i.e., the distance between the empirical distribution function and the hypothesized cumulative distribution function is measured at this observation. statistic_sign : int +1 if the KS statistic is the maximum positive difference between the empirical distribution function and the hypothesized cumulative distribution function (D+); -1 if the KS statistic is the maximum negative difference (D-). See Also -------- ks_2samp, kstest Notes ----- There are three options for the null and corresponding alternative hypothesis that can be selected using the `alternative` parameter. - `two-sided`: The null hypothesis is that the two distributions are identical, F(x)=G(x) for all x; the alternative is that they are not identical. - `less`: The null hypothesis is that F(x) >= G(x) for all x; the alternative is that F(x) < G(x) for at least one x. - `greater`: The null hypothesis is that F(x) <= G(x) for all x; the alternative is that F(x) > G(x) for at least one x. Note that the alternative hypotheses describe the *CDFs* of the underlying distributions, not the observed values. For example, suppose x1 ~ F and x2 ~ G. If F(x) > G(x) for all x, the values in x1 tend to be less than those in x2. Examples -------- Suppose we wish to test the null hypothesis that a sample is distributed according to the standard normal. We choose a confidence level of 95%; that is, we will reject the null hypothesis in favor of the alternative if the p-value is less than 0.05. When testing uniformly distributed data, we would expect the null hypothesis to be rejected. >>> import numpy as np >>> from scipy import stats >>> rng = np.random.default_rng() >>> stats.ks_1samp(stats.uniform.rvs(size=100, random_state=rng), ... stats.norm.cdf) KstestResult(statistic=0.5001899973268688, pvalue=1.1616392184763533e-23, statistic_location=0.00047625268963724654, statistic_sign=-1) Indeed, the p-value is lower than our threshold of 0.05, so we reject the null hypothesis in favor of the default "two-sided" alternative: the data are *not* distributed according to the standard normal. When testing random variates from the standard normal distribution, we expect the data to be consistent with the null hypothesis most of the time. >>> x = stats.norm.rvs(size=100, random_state=rng) >>> stats.ks_1samp(x, stats.norm.cdf) KstestResult(statistic=0.05345882212970396, pvalue=0.9227159037744717, statistic_location=-1.2451343873745018, statistic_sign=1) As expected, the p-value of 0.92 is not below our threshold of 0.05, so we cannot reject the null hypothesis. Suppose, however, that the random variates are distributed according to a normal distribution that is shifted toward greater values. In this case, the cumulative density function (CDF) of the underlying distribution tends to be *less* than the CDF of the standard normal. Therefore, we would expect the null hypothesis to be rejected with ``alternative='less'``: >>> x = stats.norm.rvs(size=100, loc=0.5, random_state=rng) >>> stats.ks_1samp(x, stats.norm.cdf, alternative='less') KstestResult(statistic=0.17482387821055168, pvalue=0.001913921057766743, statistic_location=0.3713830565352756, statistic_sign=-1) and indeed, with p-value smaller than our threshold, we reject the null hypothesis in favor of the alternative. rrrrrrrrrrzUnexpected value alternative=rr3rLrZasympr)r7rrrrrint8r.r%rksonerr1kstwo kstwobignrr)rrr<rr4rENr*np_oneDplus d_locationDminusdplus_locationdminus_locationDd_signros rrqrqsF D#)&AEEA -K::9[N;<< AA  A!mdmG WWQZFi*76E=#6#6#9#9%#C/9+13 3f,W8FM$7$7$:$:6$E/9,274 4 +76E-g9F ~ #  $  v~ w""%%a+ &&))!bggaj.9=&&))!// 774A D 4+5'- //rcSn[[R"X- 55nUS:aDSn[U5HnXU-- U- U-XU--U-S-- nM USU- -nUS-nUS:aMDSU-$)z 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. r rrrr)rrrrG)rrPrp1rs r_compute_prob_outside_squarerKMs2 A BHHQUOA q& qA!e)a-2%UQ):;B #'N Q q& q5LrcrX:aXpX-nX-nXU- U--n[U5Vs/sHosXG--U-S- U-PM nnUS:Xa[R"X-U5$[R"U5n SU S'[SU5Hdn[R"XU-U5n [U5H2n [R"XX- U-U - X{- 5n XX--n M4 XU'Mf Sn [U5H1n[R"XU- X- -X- 5n XU -nX- n M3 U $s snf)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. 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. rr)rGrbinomrr)rrrrmgnglxjrxjBBjrbin num_pathsterms r_count_paths_outside_methodrWssMT u1 B B !tbj.C+0: 6:arv:?1 r !:B 6 ax}}QUA&&  A AaD 1c] ]]2519a (qA--  1A 5qs;C * B! I 3ZmmQ!uW/5tcz  ) 7sD4cBX-U-n[[R"X5-55nUS-U- nUS:XaSUS4$S[Rp[R"SSS9 US:XaX:Xa [ X5nO[ XX&5nOX:Xa7[R"U5n [R"X - X -S-- 5nOj[R"SS9 [XX&5n S S S 5 [R"X-U5n W U :d[R"U 5(aSnOX- nS S S 5 U(aSU[R4$SUs=::aS ::dO SX84$SX84$!,(df  N=f!,(df  NP=f![[4a SnNgf=f) zAttempts to compute the exact 2sample probability. n1, n2 are the sample sizes g is the gcd(n1, n2) d is the computed max difference in ECDFs Returns (success, d, probability) rrTFr)roverr)rYNr)rrrFrrrKr!ryrWrWrrMisinfFloatingPointError OverflowError) rrrrrlcmr saw_fp_errorrojrangerUrTs r_attempt_exact_2kssampr`si 7b.C BHHQW A C# AAvQ|$ [[w 7k)87>D"U5n[R"USS5n[A[RB"U5UU[RD"U5S9$) a{ Performs the two-sample Kolmogorov-Smirnov test for goodness of fit. This test compares the underlying continuous distributions F(x) and G(x) of two independent samples. See Notes for a description of the available null and alternative hypotheses. Parameters ---------- data1, data2 : array_like, 1-Dimensional Two arrays of sample observations assumed to be drawn from a continuous distribution, sample sizes can be different. alternative : {'two-sided', 'less', 'greater'}, optional Defines the null and alternative hypotheses. Default is 'two-sided'. Please see explanations in the Notes below. method : {'auto', 'exact', 'asymp'}, optional Defines the method used for calculating the p-value. The following options are available (default is 'auto'): * 'auto' : use 'exact' for small size arrays, 'asymp' for large * 'exact' : use exact distribution of test statistic * 'asymp' : use asymptotic distribution of test statistic Returns ------- res: KstestResult An object containing attributes: statistic : float KS test statistic. pvalue : float One-tailed or two-tailed p-value. statistic_location : float Value from `data1` or `data2` corresponding with the KS statistic; i.e., the distance between the empirical distribution functions is measured at this observation. statistic_sign : int +1 if the empirical distribution function of `data1` exceeds the empirical distribution function of `data2` at `statistic_location`, otherwise -1. See Also -------- kstest, ks_1samp, epps_singleton_2samp, anderson_ksamp Notes ----- There are three options for the null and corresponding alternative hypothesis that can be selected using the `alternative` parameter. - `less`: The null hypothesis is that F(x) >= G(x) for all x; the alternative is that F(x) < G(x) for at least one x. The statistic is the magnitude of the minimum (most negative) difference between the empirical distribution functions of the samples. - `greater`: The null hypothesis is that F(x) <= G(x) for all x; the alternative is that F(x) > G(x) for at least one x. The statistic is the maximum (most positive) difference between the empirical distribution functions of the samples. - `two-sided`: The null hypothesis is that the two distributions are identical, F(x)=G(x) for all x; the alternative is that they are not identical. The statistic is the maximum absolute difference between the empirical distribution functions of the samples. Note that the alternative hypotheses describe the *CDFs* of the underlying distributions, not the observed values of the data. For example, suppose x1 ~ F and x2 ~ G. If F(x) > G(x) for all x, the values in x1 tend to be less than those in x2. If the KS statistic is large, then the p-value will be small, and this may be taken as evidence against the null hypothesis in favor of the alternative. If ``method='exact'``, `ks_2samp` attempts to compute an exact p-value, that is, the probability under the null hypothesis of obtaining a test statistic value as extreme as the value computed from the data. If ``method='asymp'``, the asymptotic Kolmogorov-Smirnov distribution is used to compute an approximate p-value. If ``method='auto'``, an exact p-value computation is attempted if both sample sizes are less than 10000; otherwise, the asymptotic method is used. In any case, if an exact p-value calculation is attempted and fails, a warning will be emitted, and the asymptotic p-value will be returned. The 'two-sided' 'exact' computation computes the complementary probability and then subtracts from 1. As such, the minimum probability it can return is about 1e-16. While the algorithm itself is exact, numerical errors may accumulate for large sample sizes. It is most suited to situations in which one of the sample sizes is only a few thousand. We generally follow Hodges' treatment of Drion/Gnedenko/Korolyuk [1]_. References ---------- .. [1] Hodges, J.L. Jr., "The Significance Probability of the Smirnov Two-Sample Test," Arkiv fiur Matematik, 3, No. 43 (1958), 469-486. Examples -------- Suppose we wish to test the null hypothesis that two samples were drawn from the same distribution. We choose a confidence level of 95%; that is, we will reject the null hypothesis in favor of the alternative if the p-value is less than 0.05. If the first sample were drawn from a uniform distribution and the second were drawn from the standard normal, we would expect the null hypothesis to be rejected. >>> import numpy as np >>> from scipy import stats >>> rng = np.random.default_rng() >>> sample1 = stats.uniform.rvs(size=100, random_state=rng) >>> sample2 = stats.norm.rvs(size=110, random_state=rng) >>> stats.ks_2samp(sample1, sample2) KstestResult(statistic=0.5454545454545454, pvalue=7.37417839555191e-15, statistic_location=-0.014071496412861274, statistic_sign=-1) Indeed, the p-value is lower than our threshold of 0.05, so we reject the null hypothesis in favor of the default "two-sided" alternative: the data were *not* drawn from the same distribution. When both samples are drawn from the same distribution, we expect the data to be consistent with the null hypothesis most of the time. >>> sample1 = stats.norm.rvs(size=105, random_state=rng) >>> sample2 = stats.norm.rvs(size=95, random_state=rng) >>> stats.ks_2samp(sample1, sample2) KstestResult(statistic=0.10927318295739348, pvalue=0.5438289009927495, statistic_location=-0.1670157701848795, statistic_sign=-1) As expected, the p-value of 0.54 is not below our threshold of 0.05, so we cannot reject the null hypothesis. Suppose, however, that the first sample were drawn from a normal distribution shifted toward greater values. In this case, the cumulative density function (CDF) of the underlying distribution tends to be *less* than the CDF underlying the second sample. Therefore, we would expect the null hypothesis to be rejected with ``alternative='less'``: >>> sample1 = stats.norm.rvs(size=105, loc=0.5, random_state=rng) >>> stats.ks_2samp(sample1, sample2, alternative='less') KstestResult(statistic=0.4055137844611529, pvalue=3.5474563068855554e-08, statistic_location=-0.13249370614972575, statistic_sign=-1) and indeed, with p-value smaller than our threshold, we reject the null hypothesis in favor of the alternative. )rLrZr:zInvalid value for mode: rrrr8r)rrrzInvalid value for alternative: i'z)Data passed to ks_2samp must not be emptyr)siderrrLrZr:z;Exact ks_2samp calculation not possible with samples sizes z and z. Switching to 'asymp'.rlrz>ks_2samp: Exact calculation unsuccessful. Switching to method=rvT)reverser^rr|r3)#rr7rrr is_masked compressedrrr"r searchsortedargminrrrr!riinforwrrrr`r9rrr=rrFrrr%rEr;)data1data2rr4rE MAX_AUTO_Nrrdata_allcdf1cdf2cddiffsargminSargmaxSloc_minSloc_maxSminSmaxSrrBrGrn1gn2grosuccessrrenr,expts rrrrrs~ D --3D6:;;#)&AEEA -K:::;-HIIJ uuu  " uuu  " GGENE GGENE QB QB 2{aDEE~~un-H ??5 9B >D ??5 9B >DkGii Gii G H H 77G$$a +D  Df !;t     B A 'C 'C FF7D v~b+3w  "((288$((3. .D MMM$eB4689G   w1"!Q LDD MM115a9:H%& ( wuRy%),d;1 Ua!e_ + % &&))!RXXb\:D aA19q1uAaC01ac1CCCGGD66$Q>rc US:XaSnUS;a[SU35e[XX#5upgnU(a [XaX$USS9$[XgXESS9$)a Performs the (one-sample or two-sample) Kolmogorov-Smirnov test for goodness of fit. The one-sample test compares the underlying distribution F(x) of a sample against a given distribution G(x). The two-sample test compares the underlying distributions of two independent samples. Both tests are valid only for continuous distributions. Parameters ---------- rvs : str, array_like, or callable If an array, it should be a 1-D array of observations of random variables. If a callable, it should be a function to generate random variables; it is required to have a keyword argument `size`. If a string, it should be the name of a distribution in `scipy.stats`, which will be used to generate random variables. cdf : str, array_like or callable If array_like, it should be a 1-D array of observations of random variables, and the two-sample test is performed (and rvs must be array_like). If a callable, that callable is used to calculate the cdf. If a string, it should be the name of a distribution in `scipy.stats`, which will be used as the cdf function. args : tuple, sequence, optional Distribution parameters, used if `rvs` or `cdf` are strings or callables. N : int, optional Sample size if `rvs` is string or callable. Default is 20. alternative : {'two-sided', 'less', 'greater'}, optional Defines the null and alternative hypotheses. Default is 'two-sided'. Please see explanations in the Notes below. method : {'auto', 'exact', 'approx', 'asymp'}, optional Defines the distribution used for calculating the p-value. The following options are available (default is 'auto'): * 'auto' : selects one of the other options. * 'exact' : uses the exact distribution of test statistic. * 'approx' : approximates the two-sided probability with twice the one-sided probability * 'asymp': uses asymptotic distribution of test statistic Returns ------- res: KstestResult An object containing attributes: statistic : float KS test statistic, either D+, D-, or D (the maximum of the two) pvalue : float One-tailed or two-tailed p-value. statistic_location : float In a one-sample test, this is the value of `rvs` corresponding with the KS statistic; i.e., the distance between the empirical distribution function and the hypothesized cumulative distribution function is measured at this observation. In a two-sample test, this is the value from `rvs` or `cdf` corresponding with the KS statistic; i.e., the distance between the empirical distribution functions is measured at this observation. statistic_sign : int In a one-sample test, this is +1 if the KS statistic is the maximum positive difference between the empirical distribution function and the hypothesized cumulative distribution function (D+); it is -1 if the KS statistic is the maximum negative difference (D-). In a two-sample test, this is +1 if the empirical distribution function of `rvs` exceeds the empirical distribution function of `cdf` at `statistic_location`, otherwise -1. See Also -------- ks_1samp, ks_2samp Notes ----- There are three options for the null and corresponding alternative hypothesis that can be selected using the `alternative` parameter. - `two-sided`: The null hypothesis is that the two distributions are identical, F(x)=G(x) for all x; the alternative is that they are not identical. - `less`: The null hypothesis is that F(x) >= G(x) for all x; the alternative is that F(x) < G(x) for at least one x. - `greater`: The null hypothesis is that F(x) <= G(x) for all x; the alternative is that F(x) > G(x) for at least one x. Note that the alternative hypotheses describe the *CDFs* of the underlying distributions, not the observed values. For example, suppose x1 ~ F and x2 ~ G. If F(x) > G(x) for all x, the values in x1 tend to be less than those in x2. Examples -------- Suppose we wish to test the null hypothesis that a sample is distributed according to the standard normal. We choose a confidence level of 95%; that is, we will reject the null hypothesis in favor of the alternative if the p-value is less than 0.05. When testing uniformly distributed data, we would expect the null hypothesis to be rejected. >>> import numpy as np >>> from scipy import stats >>> rng = np.random.default_rng() >>> stats.kstest(stats.uniform.rvs(size=100, random_state=rng), ... stats.norm.cdf) KstestResult(statistic=0.5001899973268688, pvalue=1.1616392184763533e-23, statistic_location=0.00047625268963724654, statistic_sign=-1) Indeed, the p-value is lower than our threshold of 0.05, so we reject the null hypothesis in favor of the default "two-sided" alternative: the data are *not* distributed according to the standard normal. When testing random variates from the standard normal distribution, we expect the data to be consistent with the null hypothesis most of the time. >>> x = stats.norm.rvs(size=100, random_state=rng) >>> stats.kstest(x, stats.norm.cdf) KstestResult(statistic=0.05345882212970396, pvalue=0.9227159037744717, statistic_location=-1.2451343873745018, statistic_sign=1) As expected, the p-value of 0.92 is not below our threshold of 0.05, so we cannot reject the null hypothesis. Suppose, however, that the random variates are distributed according to a normal distribution that is shifted toward greater values. In this case, the cumulative density function (CDF) of the underlying distribution tends to be *less* than the CDF of the standard normal. Therefore, we would expect the null hypothesis to be rejected with ``alternative='less'``: >>> x = stats.norm.rvs(size=100, loc=0.5, random_state=rng) >>> stats.kstest(x, stats.norm.cdf, alternative='less') KstestResult(statistic=0.17482387821055168, pvalue=0.001913921057766743, statistic_location=0.3713830565352756, statistic_sign=-1) and indeed, with p-value smaller than our threshold, we reject the null hypothesis in favor of the alternative. For convenience, the previous test can be performed using the name of the distribution as the second argument. >>> stats.kstest(x, "norm", alternative='less') KstestResult(statistic=0.17482387821055168, pvalue=0.001913921057766743, statistic_location=0.3713830565352756, statistic_sign=-1) The examples above have all been one-sample tests identical to those performed by `ks_1samp`. Note that `kstest` can also perform two-sample tests identical to those performed by `ks_2samp`. For example, when two samples are drawn from the same distribution, we expect the data to be consistent with the null hypothesis most of the time. >>> sample1 = stats.laplace.rvs(size=105, random_state=rng) >>> sample2 = stats.laplace.rvs(size=95, random_state=rng) >>> stats.kstest(sample1, sample2) KstestResult(statistic=0.11779448621553884, pvalue=0.4494256912629795, statistic_location=0.6138814275424155, statistic_sign=1) As expected, the p-value of 0.45 is not below our threshold of 0.05, so we cannot reject the null hypothesis. two_sidedrr9zUnexpected alternative: T)r<rr4r-)rr4r-)rr~rqrr)rrr<r?rr4xvalsyvalss rrprp slpk!! ::3K=ABB*3T=E# %6 6 Ek! ##rc[R"U5n[R"[RSUSSUSS:gS45Sn[R"U5R [R 5n[R "UR5nUS:aS$SUS-U- R5US-U- - - $) a+Tie correction factor for Mann-Whitney U and Kruskal-Wallis H tests. Parameters ---------- rankvals : array_like A 1-D sequence of ranks. Typically this will be the array returned by `~scipy.stats.rankdata`. Returns ------- factor : float Correction factor for U or H. See Also -------- rankdata : Assign ranks to the data mannwhitneyu : Mann-Whitney rank test kruskal : Kruskal-Wallis H test References ---------- .. [1] Siegel, S. (1956) Nonparametric Statistics for the Behavioral Sciences. New York: McGraw-Hill. Examples -------- >>> from scipy.stats import tiecorrect, rankdata >>> tiecorrect([1, 2.5, 2.5, 4]) 0.9 >>> ranks = rankdata([1, 3, 2, 4, 5, 7, 2, 8, 4]) >>> ranks array([ 1. , 4. , 2.5, 5.5, 7. , 8. , 2.5, 9. , 5.5]) >>> tiecorrect(ranks) 0.9833333333333333 TrNrrrrrl) rrrar^r`rrErr)rankvalsrrrTrs rruru sJ ''( C **RUU4QRCH!4d:; >> import numpy as np >>> from scipy.stats import ranksums >>> rng = np.random.default_rng() >>> sample1 = rng.uniform(-1, 1, 200) >>> sample2 = rng.uniform(-0.5, 1.5, 300) # a shifted distribution >>> ranksums(sample1, sample2) RanksumsResult(statistic=-7.887059, pvalue=3.09390448e-15) # may vary >>> ranksums(sample1, sample2, alternative='less') RanksumsResult(statistic=-7.750585297581713, pvalue=4.573497606342543e-15) # may vary >>> ranksums(sample1, sample2, alternative='greater') RanksumsResult(statistic=-7.750585297581713, pvalue=0.9999999999999954) # may vary The p-value of less than ``0.05`` indicates that this test rejects the hypothesis at the 5% significance level. Nrr rro(@rr) maprrrrryrrrrr) rrrrrrrankedrdexpectedr,rs rrvrv sH rzzA6 "DA QB QBnnaV$G g Fs A qqAU1W~#H a!566A MO[R @F !B% ,,r KruskalResult)rc [[[RU55n[ U5nUS:a [ S5e[R"[[[U555n[R "U5n[U5n[U5nUS:Xa [ S5e[R"[R"U5SS5nSn[U5H n U[XWU XyS-5X9- - nM" [R"U[S9n SXS--- U-SU S--- n US- n X-n [U 5n [!XS S [S 9n[#X5$) aCompute the Kruskal-Wallis H-test for independent samples. The Kruskal-Wallis H-test tests the null hypothesis that the population median of all of the groups are equal. It is a non-parametric version of ANOVA. The test works on 2 or more independent samples, which may have different sizes. Note that rejecting the null hypothesis does not indicate which of the groups differs. Post hoc comparisons between groups are required to determine which groups are different. Parameters ---------- sample1, sample2, ... : array_like Two or more arrays with the sample measurements can be given as arguments. Samples must be one-dimensional. nan_policy : {'propagate', 'raise', 'omit'}, optional Defines how to handle when input contains nan. The following options are available (default is 'propagate'): * 'propagate': returns nan * 'raise': throws an error * 'omit': performs the calculations ignoring nan values Returns ------- statistic : float The Kruskal-Wallis H statistic, corrected for ties. pvalue : float The p-value for the test using the assumption that H has a chi square distribution. The p-value returned is the survival function of the chi square distribution evaluated at H. See Also -------- f_oneway : 1-way ANOVA. mannwhitneyu : Mann-Whitney rank test on two samples. friedmanchisquare : Friedman test for repeated measurements. Notes ----- Due to the assumption that H has a chi square distribution, the number of samples in each group must not be too small. A typical rule is that each sample must have at least 5 measurements. References ---------- .. [1] W. H. Kruskal & W. W. Wallis, "Use of Ranks in One-Criterion Variance Analysis", Journal of the American Statistical Association, Vol. 47, Issue 260, pp. 583-621, 1952. .. [2] https://en.wikipedia.org/wiki/Kruskal-Wallis_one-way_analysis_of_variance Examples -------- >>> from scipy import stats >>> x = [1, 3, 5, 7, 9] >>> y = [2, 4, 6, 8, 10] >>> stats.kruskal(x, y) KruskalResult(statistic=0.2727272727272734, pvalue=0.6015081344405895) >>> x = [1, 1, 1] >>> y = [2, 2, 2] >>> z = [2, 2] >>> stats.kruskal(x, y, z) KruskalResult(statistic=7.0, pvalue=0.0301973834223185) rz+Need at least two groups in stats.kruskal()rz$All numbers are identical in kruskalrrrrlrFr)r_rrrrrrryruinsertrrGrrrrrr)rrrrrrtiesrrrtotalnrrrrs rrwrwQ!sDF3rzz7+,GWJA~FGG 4C)*+AnnW%G g F f D qy?@@ "))A,1%A D :  tAcF 34qt;;VVAU #F 1*%&-VaZ0@@A aBIA r?D i5R PF  ##rFriedmanchisquareResult)rrc[U5nUS:a[SUS35e[US5n[SU5Hn[X5U:wdM[S5e [R"U5R nUR [5n[[U55Hn[XC5XC'M SnUHFn[[R"U[RS95upxUHn XYX-S- -- nM MH SXQX-S- -U-- - n [R"URSS9S -5n S X-US--- U -SU-US--- U - n [US- 5n [XS S [S 9n[X5$)aCompute the Friedman test for repeated samples. The Friedman test tests the null hypothesis that repeated samples of the same individuals have the same distribution. It is often used to test for consistency among samples obtained in different ways. For example, if two sampling techniques are used on the same set of individuals, the Friedman test can be used to determine if the two sampling techniques are consistent. Parameters ---------- sample1, sample2, sample3... : array_like Arrays of observations. All of the arrays must have the same number of elements. At least three samples must be given. Returns ------- statistic : float The test statistic, correcting for ties. pvalue : float The associated p-value assuming that the test statistic has a chi squared distribution. See Also -------- :ref:`hypothesis_friedmanchisquare` : Extended example Notes ----- Due to the assumption that the test statistic has a chi squared distribution, the p-value is only reliable for n > 10 and more than 6 repeated samples. References ---------- .. [1] https://en.wikipedia.org/wiki/Friedman_test .. [2] Demsar, J. (2006). Statistical comparisons of classifiers over multiple data sets. Journal of Machine Learning Research, 7, 1-30. Examples -------- >>> import numpy as np >>> rng = np.random.default_rng(seed=18) >>> x = rng.random((6, 10)) >>> from scipy.stats import friedmanchisquare >>> res = friedmanchisquare(x[0], x[1], x[2], x[3], x[4], x[5]) >>> res.statistic, res.pvalue (11.428571428571416, 0.043514520866727614) The p-value is less than 0.05; however, as noted above, the results may not be reliable since we have a small number of repeated samples. For a more detailed example, see :ref:`hypothesis_friedmanchisquare`. rlz@At least 3 sets of samples must be given for Friedman test, got rvrrz*Unequal N in friedmanchisquare. Aborting.rr rrrFr)rrrGrr?TrrryrrrErrrr)rrrrrrrrrepnumrrYrrrrs rrxrx!sr G A1u334#Q89 9 GAJA 1a[ wz?a IJ J 99W   D ;;u D 3t9 47# D !"((1BJJ"?@ A qM !D DqsQwKM ""A 66$((("A% &Dac#d*QqS!A#Y6!;I q1u D i5UW XF "9 55rBrunnerMunzelResultc`[U5n[U5n[[R"X455nUSUnXuXV-n [R"U5n [R"U 5n [U5n [U5n [R"U 5n[R"U 5n[R "[R "X- U - U-S55nUUS- -n[R "[R "X- U - U-S55nUUS- -nXV-X- -nUXV-[R"UU-UU--5--nUS:Xa[R "UU-UU--S5n[R "UU-S5US- - nU[R "UU-S5US- - - nUU- nUS:Xa"US:XaSn[R"U[SS9 [U5nOUS:Xa [5nO [S 5e[U*X2[S 9n[UU5$) 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 rrorrzp-value cannot be estimated with `distribution='t' because degrees of freedom parameter is undefined (0/0). Try using `distribution='normal'rrr0z&distribution should be 't' or 'normal'r)rryrrrrpowerrrrrrArrrr)rrrrrnxnyrankcrankcxrankcy rankcx_mean rankcy_meanrankxranky rankx_mean ranky_meanSxSywbfndf_numerdf_denomrrrs rrr"sZ QB QB R^^QF+ ,E 1R[F be_F''&/K''&/K QKE QKEJJ +5 BCH IB"q&LB +5 BCH IB"q&LB 7k/ 0DRWR"r' 12 22Ds88BGb2g-s388BGS)R!V4BHHR"Wc*b1f55   MA AG MM'>a @&r*  !$  46 6 TE<>> from scipy.stats import combine_pvalues >>> pvalues = [0.1, 0.05, 0.02, 0.3] >>> combine_pvalues(pvalues) SignificanceResult(statistic=20.828626352604235, pvalue=0.007616871850449092) When the individual p-values carry different weights, consider Stouffer's method. >>> weights = [1, 2, 3, 4] >>> res = combine_pvalues(pvalues, method='stouffer', weights=weights) >>> res.pvalue 0.009578891494533616 Notes ----- If this function is applied to tests with a discrete statistics such as any rank test or contingency-table test, it will yield systematically wrong results, e.g. Fisher's method will systematically overestimate the p-value [1]_. This problem becomes less severe for large sample sizes when the discrete distributions become approximately continuous. The differences between the methods can be best illustrated by their statistics and what aspects of a combination of p-values they emphasise when considering significance [2]_. For example, methods emphasising large p-values are more sensitive to strong false and true negatives; conversely methods focussing on small p-values are sensitive to positives. * The statistics of Fisher's method (also known as Fisher's combined probability test) [3]_ is :math:`-2\sum_i \log(p_i)`, which is equivalent (as a test statistics) to the product of individual p-values: :math:`\prod_i p_i`. Under the null hypothesis, this statistics follows a :math:`\chi^2` distribution. This method emphasises small p-values. * Pearson's method uses :math:`-2\sum_i\log(1-p_i)`, which is equivalent to :math:`\prod_i \frac{1}{1-p_i}` [2]_. It thus emphasises large p-values. * Mudholkar and George compromise between Fisher's and Pearson's method by averaging their statistics [4]_. Their method emphasises extreme p-values, both close to 1 and 0. * Stouffer's method [5]_ uses Z-scores and the statistic: :math:`\sum_i \Phi^{-1} (p_i)`, where :math:`\Phi` is the CDF of the standard normal distribution. The advantage of this method is that it is straightforward to introduce weights, which can make Stouffer's method more powerful than Fisher's method when the p-values are from studies of different size [6]_ [7]_. * Tippett's method uses the smallest p-value as a statistic. (Mind that this minimum is not the combined p-value.) Fisher's method may be extended to combine p-values from dependent tests [8]_. Extensions such as Brown's method and Kost's method are not currently implemented. .. versionadded:: 0.15.0 References ---------- .. [1] Kincaid, W. M., "The Combination of Tests Based on Discrete Distributions." Journal of the American Statistical Association 57, no. 297 (1962), 10-19. .. [2] Heard, N. and Rubin-Delanchey, P. "Choosing between methods of combining p-values." Biometrika 105.1 (2018): 239-246. .. [3] https://en.wikipedia.org/wiki/Fisher%27s_method .. [4] George, E. O., and G. S. Mudholkar. "On the convolution of logistic random variables." Metrika 30.1 (1983): 1-13. .. [5] https://en.wikipedia.org/wiki/Fisher%27s_method#Relation_to_Stouffer.27s_Z-score_method .. [6] Whitlock, M. C. "Combining probability from independent tests: the weighted Z-method is superior to Fisher's approach." Journal of Evolutionary Biology 18, no. 5 (2005): 1368-1373. .. [7] Zaykin, Dmitri V. "Optimally weighted Z-test is a powerful method for combining probabilities in meta-analysis." Journal of Evolutionary Biology 24, no. 8 (2011): 1836-1841. .. [8] https://en.wikipedia.org/wiki/Extensions_of_Fisher%27s_method rrrr}r^r rrFrrrmudholkar_georgerlrSr{)rrtippettstoufferz>> import numpy as np >>> import scipy.stats as stats >>> p = 0.75 # quantile of interest >>> q = 0 # hypothesized value of the quantile >>> x = np.exp(np.arange(0, 1.01, 0.01)) >>> res = stats.quantile_test(x, q=q, p=p, alternative='less') >>> lb, ub = res.confidence_interval() >>> lb, ub (-inf, 2.293318740264183) >>> res = stats.quantile_test(x, q=q, p=p, alternative='two-sided') >>> lb, ub = res.confidence_interval(0.9) >>> lb, ub (1.9542373206359396, 2.293318740264183) rrrrrrr)rrrrrrr4rMrrr!rrppfr) rrrrrrbdr low_index high_indexrWrXs rr&QuantileTestResult.confidence_intervald#siB'' GG GGDGG  F [[  q $4$9LGW% %FF VV & $$A66'CRVVAYJ$.N1=D I %$$ABFF1I*I"+q.!,bffC66D K '%%*ABFF1I*I"+q.!,bffCRVVAYJ$.N1=D!#t,,rrNr)rrrrrrrrrrr_r5rrrrrrrrrrrA#sT4 M#/L$s)/'B'E"B"?-rrcb[R"U5nSnURS:wd4[R"UR[R 5(d [ U5e[R"U5SnSnURS:wd4[R"UR[R 5(d [ U5e[R"U5SnSnURS:wd US:dUS::a [ U5e1SknSU3nX5;a [ U5eXX#4$) Nz/`x` must be a one-dimensional array of numbers.rrz`q` must be a scalar.rz-`p` must be a float strictly between 0 and 1.>rrrz`alternative` must be one of )rrrrrrrr)rqrrr alternativess rquantile_test_ivr#s aA?Gvv{"--;;!!  BA%Gvv{"--;;!!  BA=Gvv{a1fQ!!3L-l^>> import numpy as np >>> from scipy import stats >>> rng = np.random.default_rng(6981396440634228121) >>> rvs = stats.uniform.rvs(size=100, random_state=rng) >>> stats.quantile_test(rvs, q=0.5, p=0.5) QuantileTestResult(statistic=45, statistic_type=1, pvalue=0.36820161732669576) As expected, the p-value is not below our threshold of 0.01, so we cannot reject the null hypothesis. When testing data from the standard *normal* distribution, which has a median of 0, we would expect the null hypothesis to be rejected. >>> rvs = stats.norm.rvs(size=100, random_state=rng) >>> stats.quantile_test(rvs, q=0.5, p=0.5) QuantileTestResult(statistic=67, statistic_type=2, pvalue=0.0008737198369123724) Indeed, the p-value is lower than our threshold of 0.01, so we reject the null hypothesis in favor of the default "two-sided" alternative: the median of the population is *not* equal to 0.5. However, suppose we were to test the null hypothesis against the one-sided alternative that the median of the population is *greater* than 0.5. Since the median of the standard normal is less than 0.5, we would not expect the null hypothesis to be rejected. >>> stats.quantile_test(rvs, q=0.5, p=0.5, alternative='greater') QuantileTestResult(statistic=67, statistic_type=1, pvalue=0.9997956114162866) Unsurprisingly, with a p-value greater than our threshold, we would not reject the null hypothesis in favor of the chosen alternative. The quantile test can be used for any quantile, not only the median. For example, we can test whether the third quartile of the distribution underlying the sample is greater than 0.6. >>> rvs = stats.uniform.rvs(size=100, random_state=rng) >>> stats.quantile_test(rvs, q=0.6, p=0.75, alternative='greater') QuantileTestResult(statistic=64, statistic_type=1, pvalue=0.00940696592998271) The p-value is lower than the threshold. We reject the null hypothesis in favor of the alternative: the third quartile of the distribution underlying our sample is greater than 0.6. `quantile_test` can also compute confidence intervals for any quantile. >>> rvs = stats.norm.rvs(size=100, random_state=rng) >>> res = stats.quantile_test(rvs, q=0.6, p=0.75) >>> ci = res.confidence_interval(confidence_level=0.95) >>> ci ConfidenceInterval(low=0.284491604437432, high=0.8912531024914844) When testing a one-sided alternative, the confidence interval contains all observations such that if passed as `q`, the p-value of the test would be greater than 0.05, and therefore the null hypothesis would not be rejected. For example: >>> rvs.sort() >>> q, p, alpha = 0.6, 0.75, 0.95 >>> res = stats.quantile_test(rvs, q=q, p=p, alternative='less') >>> ci = res.confidence_interval(confidence_level=alpha) >>> for x in rvs[rvs <= ci.high]: ... res = stats.quantile_test(rvs, q=x, p=p, alternative='less') ... assert res.pvalue > 1-alpha >>> for x in rvs[rvs > ci.high]: ... res = stats.quantile_test(rvs, q=x, p=p, alternative='less') ... assert res.pvalue < 1-alpha Also, if a 95% confidence interval is repeatedly generated for random samples, the confidence interval will contain the true quantile value in approximately 95% of replications. >>> dist = stats.rayleigh() # our "unknown" distribution >>> p = 0.2 >>> true_stat = dist.ppf(p) # the true value of the statistic >>> n_trials = 1000 >>> quantile_ci_contains_true_stat = 0 >>> for i in range(n_trials): ... data = dist.rvs(size=100, random_state=rng) ... res = stats.quantile_test(data, p=p) ... ci = res.confidence_interval(0.95) ... if ci[0] < true_stat < ci[1]: ... quantile_ci_contains_true_stat += 1 >>> quantile_ci_contains_true_stat >= 950 True This works with any distribution and any quantile, as long as the samples are i.i.d. )rrrrrrrr)rrrrrr) rrrr4rMrrrr]rr)rrrrr,x_starp_starH1T1T2rYrrrr sorted_idxs rr{r{#s!l-Q1BAv +   B *   B AA a"A V|bd  yr  { 559add26l+ZZ( 7:a=111a8 a=(*A~(*A~ %   rcr[U5[U5pT[U5n[U5nURS:dURS:a [S5eURUR:wa [S5eURS:XaURS:Xa [ SXX#5$[ X5up[ X5upUR SUR S:wa [S5e[R"[R"U55[R"[R"U55- (a[R$[R"[R"U55(a?[R"[R"U55(a[R$[R"[R"SU454U-5n[R"[R "U54U-5n[R""Xg45n[R$"U5n['XSS9n U R)5n Uc[R*"USU- 5OU[R,"U5- n Uc[R*"USU- 5OU[R,"U5- n [R."X4SS9n [1UR2U S 9n[5U *U[R*[R4S 9nUR6*$) uz Compute the Wasserstein-1 distance between two N-D discrete distributions. The Wasserstein distance, also called the Earth mover's distance or the optimal transport distance, is a similarity metric between two probability distributions [1]_. In the discrete case, the Wasserstein distance can be understood as the cost of an optimal transport plan to convert one distribution into the other. The cost is calculated as the product of the amount of probability mass being moved and the distance it is being moved. A brief and intuitive introduction can be found at [2]_. .. versionadded:: 1.13.0 Parameters ---------- u_values : 2d array_like A sample from a probability distribution or the support (set of all possible values) of a probability distribution. Each element along axis 0 is an observation or possible value, and axis 1 represents the dimensionality of the distribution; i.e., each row is a vector observation or possible value. v_values : 2d array_like A sample from or the support of a second distribution. u_weights, v_weights : 1d array_like, optional Weights or counts corresponding with the sample or probability masses corresponding with the support values. Sum of elements must be positive and finite. If unspecified, each value is assigned the same weight. Returns ------- distance : float The computed distance between the distributions. Notes ----- Given two probability mass functions, :math:`u` and :math:`v`, the first Wasserstein distance between the distributions using the Euclidean norm is: .. math:: l_1 (u, v) = \inf_{\pi \in \Gamma (u, v)} \int \| x-y \|_2 \mathrm{d} \pi (x, y) where :math:`\Gamma (u, v)` is the set of (probability) distributions on :math:`\mathbb{R}^n \times \mathbb{R}^n` whose marginals are :math:`u` and :math:`v` on the first and second factors respectively. For a given value :math:`x`, :math:`u(x)` gives the probability of :math:`u` at position :math:`x`, and the same for :math:`v(x)`. This is also called the optimal transport problem or the Monge problem. Let the finite point sets :math:`\{x_i\}` and :math:`\{y_j\}` denote the support set of probability mass function :math:`u` and :math:`v` respectively. The Monge problem can be expressed as follows, Let :math:`\Gamma` denote the transport plan, :math:`D` denote the distance matrix and, .. math:: x = \text{vec}(\Gamma) \\ c = \text{vec}(D) \\ b = \begin{bmatrix} u\\ v\\ \end{bmatrix} The :math:`\text{vec}()` function denotes the Vectorization function that transforms a matrix into a column vector by vertically stacking the columns of the matrix. The transport plan :math:`\Gamma` is a matrix :math:`[\gamma_{ij}]` in which :math:`\gamma_{ij}` is a positive value representing the amount of probability mass transported from :math:`u(x_i)` to :math:`v(y_i)`. Summing over the rows of :math:`\Gamma` should give the source distribution :math:`u` : :math:`\sum_j \gamma_{ij} = u(x_i)` holds for all :math:`i` and summing over the columns of :math:`\Gamma` should give the target distribution :math:`v`: :math:`\sum_i \gamma_{ij} = v(y_j)` holds for all :math:`j`. The distance matrix :math:`D` is a matrix :math:`[d_{ij}]`, in which :math:`d_{ij} = d(x_i, y_j)`. Given :math:`\Gamma`, :math:`D`, :math:`b`, the Monge problem can be transformed into a linear programming problem by taking :math:`A x = b` as constraints and :math:`z = c^T x` as minimization target (sum of costs) , where matrix :math:`A` has the form .. math:: \begin{array} {rrrr|rrrr|r|rrrr} 1 & 1 & \dots & 1 & 0 & 0 & \dots & 0 & \dots & 0 & 0 & \dots & 0 \cr 0 & 0 & \dots & 0 & 1 & 1 & \dots & 1 & \dots & 0 & 0 &\dots & 0 \cr \vdots & \vdots & \ddots & \vdots & \vdots & \vdots & \ddots & \vdots & \vdots & \vdots & \vdots & \ddots & \vdots \cr 0 & 0 & \dots & 0 & 0 & 0 & \dots & 0 & \dots & 1 & 1 & \dots & 1 \cr \hline 1 & 0 & \dots & 0 & 1 & 0 & \dots & \dots & \dots & 1 & 0 & \dots & 0 \cr 0 & 1 & \dots & 0 & 0 & 1 & \dots & \dots & \dots & 0 & 1 & \dots & 0 \cr \vdots & \vdots & \ddots & \vdots & \vdots & \vdots & \ddots & \vdots & \vdots & \vdots & \vdots & \ddots & \vdots \cr 0 & 0 & \dots & 1 & 0 & 0 & \dots & 1 & \dots & 0 & 0 & \dots & 1 \end{array} By solving the dual form of the above linear programming problem (with solution :math:`y^*`), the Wasserstein distance :math:`l_1 (u, v)` can be computed as :math:`b^T y^*`. The above solution is inspired by Vincent Herrmann's blog [3]_ . For a more thorough explanation, see [4]_ . 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] Lili Weng, "What is Wasserstein distance?", Lil'log, https://lilianweng.github.io/posts/2017-08-20-gan/#what-is-wasserstein-distance. .. [3] Hermann, Vincent. "Wasserstein GAN and the Kantorovich-Rubinstein Duality". https://vincentherrmann.github.io/blog/wasserstein/. .. [4] Peyré, Gabriel, and Marco Cuturi. "Computational optimal transport." Center for Research in Economics and Statistics Working Papers 2017-86 (2017). See Also -------- wasserstein_distance: Compute the Wasserstein-1 distance between two 1D discrete distributions. Examples -------- Compute the Wasserstein distance between two three-dimensional samples, each with two observations. >>> from scipy.stats import wasserstein_distance_nd >>> wasserstein_distance_nd([[0, 2, 3], [1, 2, 5]], [[3, 2, 3], [4, 2, 5]]) 3.0 Compute the Wasserstein distance between two two-dimensional distributions with three and two weighted observations, respectively. >>> wasserstein_distance_nd([[0, 2.75], [2, 209.3], [0, 0]], ... [[0.2, 0.322], [4.5, 25.1808]], ... [0.4, 5.2, 0.114], [0.8, 1.5]) 174.15840245217169 rzHInvalid input values. The inputs must have either one or two dimensions.z9Invalid input values. Dimensions of inputs must be equal.rziInvalid input values. If two-dimensional, `u_values` and `v_values` must have the same number of columns.)rrr )rub)rY constraintsbounds)rrrr _cdf_distance_validate_distributionrrrrZr!rr block_diagr`hstackeyer? coo_arrayr rrrrr rr fun)u_valuesv_values u_weights v_weightsrr A_upper_part A_lower_partrrFcostp_up_vrropt_ress rr}r}%sqv x=#h-qx Hx H}}qHMMA-23 3}} %"# #}}hmmq0QIII0EH0EH~~aHNN1--./ /  vvbhhx !BFF288H+=$>>vv " # #rxx/A(B(Bvv $$bggq!fo%81%<=L==&**Q-!2Q!67L |23AA a0A 779D'."''!QqS/IbffY>O4OC&."''!QqS/IbffY>O4OC z*A#QSST2KaR[266'2669JKG KK<rc[SXX#5$)a| Compute the Wasserstein-1 distance between two 1D discrete distributions. The Wasserstein distance, also called the Earth mover's distance or the optimal transport distance, is a similarity metric between two probability distributions [1]_. In the discrete case, the Wasserstein distance can be understood as the cost of an optimal transport plan to convert one distribution into the other. The cost is calculated as the product of the amount of probability mass being moved and the distance it is being moved. A brief and intuitive introduction can be found at [2]_. .. versionadded:: 1.0.0 Parameters ---------- u_values : 1d array_like A sample from a probability distribution or the support (set of all possible values) of a probability distribution. Each element is an observation or possible value. v_values : 1d array_like A sample from or the support of a second distribution. u_weights, v_weights : 1d array_like, optional Weights or counts corresponding with the sample or probability masses corresponding with the support values. Sum of elements must be positive and finite. If unspecified, each value is assigned the same weight. Returns ------- distance : float The computed distance between the distributions. Notes ----- Given two 1D probability mass functions, :math:`u` and :math:`v`, the first Wasserstein distance between the distributions 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. For a given value :math:`x`, :math:`u(x)` gives the probability of :math:`u` at position :math:`x`, and the same for :math:`v(x)`. 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 [3]_ 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] Lili Weng, "What is Wasserstein distance?", Lil'log, https://lilianweng.github.io/posts/2017-08-20-gan/#what-is-wasserstein-distance. .. [3] Ramdas, Garcia, Cuturi "On Wasserstein Two Sample Testing and Related Families of Nonparametric Tests" (2015). :arXiv:`1509.02237`. See Also -------- wasserstein_distance_nd: Compute the Wasserstein-1 distance between two N-D discrete distributions. 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)rrrrrs rr|r|%sr H EErcJ[R"S5[SXX#5-$)uI Compute the energy distance between two 1D distributions. .. versionadded:: 1.0.0 Parameters ---------- u_values, v_values : array_like Values observed in the (empirical) distribution. u_weights, v_weights : array_like, optional Weight for each value. If unspecified, each value is assigned the same weight. `u_weights` (resp. `v_weights`) must have the same length as `u_values` (resp. `v_values`). If the weight sum differs from 1, it must still be positive and finite so that the weights can be normalized to sum to 1. Returns ------- distance : float The computed distance between the distributions. Notes ----- The energy distance between two distributions :math:`u` and :math:`v`, whose respective CDFs are :math:`U` and :math:`V`, equals to: .. math:: D(u, v) = \left( 2\mathbb E|X - Y| - \mathbb E|X - X'| - \mathbb E|Y - Y'| \right)^{1/2} where :math:`X` and :math:`X'` (resp. :math:`Y` and :math:`Y'`) are independent random variables whose probability distribution is :math:`u` (resp. :math:`v`). Sometimes the square of this quantity is referred to as the "energy distance" (e.g. in [2]_, [4]_), but as noted in [1]_ and [3]_, only the definition above satisfies the axioms of a distance function (metric). As shown in [2]_, for one-dimensional real-valued variables, the energy distance is linked to the non-distribution-free version of the Cramér-von Mises distance: .. math:: D(u, v) = \sqrt{2} l_2(u, v) = \left( 2 \int_{-\infty}^{+\infty} (U-V)^2 \right)^{1/2} Note that the common Cramér-von Mises criterion uses the distribution-free version of the distance. See [2]_ (section 2), for more details about both versions of the distance. The input distributions can be empirical, therefore coming from samples whose values are effectively inputs of the function, or they can be seen as generalized functions, in which case they are weighted sums of Dirac delta functions located at the specified values. References ---------- .. [1] Rizzo, Szekely "Energy distance." Wiley Interdisciplinary Reviews: Computational Statistics, 8(1):27-38 (2015). .. [2] Szekely "E-statistics: The energy of statistical samples." Bowling Green State University, Department of Mathematics and Statistics, Technical Report 02-16 (2002). .. [3] "Energy distance", https://en.wikipedia.org/wiki/Energy_distance .. [4] Bellemare, Danihelka, Dabney, Mohamed, Lakshminarayanan, Hoyer, Munos "The Cramer Distance as a Solution to Biased Wasserstein Gradients" (2017). :arXiv:`1705.10743`. Examples -------- >>> from scipy.stats import energy_distance >>> energy_distance([0], [2]) 2.0000000000000004 >>> energy_distance([0, 8], [0, 8], [3, 1], [2, 2]) 1.0000000000000002 >>> energy_distance([0.7, 7.4, 2.4, 6.8], [1.4, 8. ], ... [2.1, 4.2, 7.4, 8. ], [7.6, 8.8]) 0.88003340976158217 r)rrrrs rr~r~;&s(d 771: a&/< <= 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)rrrrrE)rs rrArA's$P M"((3bjj*IJ KKrcN[X5up[R"X-U5$)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`). )rrr)rrs rrrE's#,1#GA 66!#t rc[X5up[R"X5n[R"U5(dUR [ 5U-$[ U5U-$)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`). )rrrrrr)rrrds rrr_'sK*1#GA qA ;;q>>xx""Qx!|r)rrcSnX;a[SUS35e[R"U5nUcUR5nSnURS:XaAUS:Xa[ O[R "S5n[R"URUS9$[XS5ups[R"XRS5n[XQ5nU(aeUS :Xa[R"U5O"[R"U5RSS 9n UR[ S S 9n[RX'[R"XS5nU$) ai Assign ranks to data, dealing with ties appropriately. By default (``axis=None``), the data array is first flattened, and a flat array of ranks is returned. Separately reshape the rank array to the shape of the data array if desired (see Examples). Ranks begin at 1. The `method` argument controls how ranks are assigned to equal values. See [1]_ for further discussion of ranking methods. Parameters ---------- a : array_like The array of values to be ranked. method : {'average', 'min', 'max', 'dense', 'ordinal'}, optional The method used to assign ranks to tied elements. The following methods are available (default is 'average'): * 'average': The average of the ranks that would have been assigned to all the tied values is assigned to each value. * 'min': The minimum of the ranks that would have been assigned to all the tied values is assigned to each value. (This is also referred to as "competition" ranking.) * 'max': The maximum of the ranks that would have been assigned to all the tied values is assigned to each value. * 'dense': Like 'min', but the rank of the next highest element is assigned the rank immediately after those assigned to the tied elements. * 'ordinal': All values are given a distinct rank, corresponding to the order that the values occur in `a`. axis : {None, int}, optional Axis along which to perform the ranking. If ``None``, the data array is first flattened. nan_policy : {'propagate', 'omit', 'raise'}, optional Defines how to handle when input contains nan. The following options are available (default is 'propagate'): * 'propagate': propagates nans through the rank calculation * 'omit': performs the calculations ignoring nan values * 'raise': raises an error .. note:: When `nan_policy` is 'propagate', the output is an array of *all* nans because ranks relative to nans in the input are undefined. When `nan_policy` is 'omit', nans in `a` are ignored when ranking the other values, and the corresponding locations of the output are nan. .. versionadded:: 1.10 Returns ------- ranks : ndarray An array of size equal to the size of `a`, containing rank scores. References ---------- .. [1] "Ranking", https://en.wikipedia.org/wiki/Ranking Examples -------- >>> import numpy as np >>> from scipy.stats import rankdata >>> rankdata([0, 2, 3, 2]) array([ 1. , 2.5, 4. , 2.5]) >>> rankdata([0, 2, 3, 2], method='min') array([ 1, 2, 4, 2]) >>> rankdata([0, 2, 3, 2], method='max') array([ 1, 3, 4, 3]) >>> rankdata([0, 2, 3, 2], method='dense') array([ 1, 2, 3, 2]) >>> rankdata([0, 2, 3, 2], method='ordinal') array([ 1, 2, 4, 3]) >>> rankdata([[0, 2], [3, 2]]).reshape(2,2) array([[1. , 2.5], [4. , 2.5]]) >>> rankdata([[0, 2, 2], [3, 2, 5]], axis=1) array([[1. , 2.5, 2.5], [2. , 1. , 3. ]]) >>> rankdata([0, 2, 3, np.nan, -2, np.nan], nan_policy="propagate") array([nan, nan, nan, nan, nan, nan]) >>> rankdata([0, 2, 3, np.nan, -2, np.nan], nan_policy="omit") array([ 2., 3., 4., nan, 1., nan]) )averager"rdenseordinalzunknown method ""rrrlongrrr Fr)rrrrrrremptyrrswapaxes _rankdatarrrr) rr4rrmethodsrrrrSi_nans rryry|'sn1 7  !"%a( IIeV $ , ,U 3E  "E" HHU% (!x Lrc^^^TS:dTS:a [S5e[R"T5mTb![R"TTR5mUUU4SjnTS:a,[R "TTS9n[R "T5nO+[R "TTS9n[R"T5nXE:XaU$[X4US9nUR$)a Compute the expectile at the specified level. Expectiles are a generalization of the expectation in the same way as quantiles are a generalization of the median. The expectile at level `alpha = 0.5` is the mean (average). See Notes for more details. Parameters ---------- a : array_like Array containing numbers whose expectile is desired. alpha : float, default: 0.5 The level of the expectile; e.g., ``alpha=0.5`` gives the mean. weights : array_like, optional An array of weights associated with the values in `a`. The `weights` must be broadcastable to the same shape as `a`. Default is None, which gives each value a weight of 1.0. An integer valued weight element acts like repeating the corresponding observation in `a` that many times. See Notes for more details. Returns ------- expectile : ndarray The empirical expectile at level `alpha`. See Also -------- numpy.mean : Arithmetic average numpy.quantile : Quantile Notes ----- In general, the expectile at level :math:`\alpha` of a random variable :math:`X` with cumulative distribution function (CDF) :math:`F` is given by the unique solution :math:`t` of: .. math:: \alpha E((X - t)_+) = (1 - \alpha) E((t - X)_+) \,. Here, :math:`(x)_+ = \max(0, x)` is the positive part of :math:`x`. This equation can be equivalently written as: .. math:: \alpha \int_t^\infty (x - t)\mathrm{d}F(x) = (1 - \alpha) \int_{-\infty}^t (t - x)\mathrm{d}F(x) \,. The empirical expectile at level :math:`\alpha` (`alpha`) of a sample :math:`a_i` (the array `a`) is defined by plugging in the empirical CDF of `a`. Given sample or case weights :math:`w` (the array `weights`), it reads :math:`F_a(x) = \frac{1}{\sum_i w_i} \sum_i w_i 1_{a_i \leq x}` with indicator function :math:`1_{A}`. This leads to the definition of the empirical expectile at level `alpha` as the unique solution :math:`t` of: .. math:: \alpha \sum_{i=1}^n w_i (a_i - t)_+ = (1 - \alpha) \sum_{i=1}^n w_i (t - a_i)_+ \,. For :math:`\alpha=0.5`, this simplifies to the weighted average. Furthermore, the larger :math:`\alpha`, the larger the value of the expectile. As a final remark, the expectile at level :math:`\alpha` can also be written as a minimization problem. One often used choice is .. math:: \operatorname{argmin}_t E(\lvert 1_{t\geq X} - \alpha\rvert(t - X)^2) \,. References ---------- .. [1] W. K. Newey and J. L. Powell (1987), "Asymmetric Least Squares Estimation and Testing," Econometrica, 55, 819-847. .. [2] T. Gneiting (2009). "Making and Evaluating Point Forecasts," Journal of the American Statistical Association, 106, 746 - 762. :doi:`10.48550/arXiv.0912.0902` Examples -------- >>> import numpy as np >>> from scipy.stats import expectile >>> a = [1, 4, 2, -1] >>> expectile(a, alpha=0.5) == np.mean(a) True >>> expectile(a, alpha=0.2) 0.42857142857142855 >>> expectile(a, alpha=0.8) 2.5714285714285716 >>> weights = [1, 3, 1, 1] rrz6The expectile level alpha must be in the range [0, 1].cn>[R"[R"TU:*T- 5UT- -TS9$)Nr)rrrV)rrrrs r first_orderexpectile..first_order(s/zz"&&!q&E!12a!er)rr9rc [XX#U5nUupp#n[R"U5n[R"X`RS9n[ [R "U[[SURS-555U5n[XS9n URSn SU SU S24'[R"X-SS9n U(aUS :aU S S===U S-sss&[RXS&XS- $) a Compute L-moments of a sample from a continuous distribution The L-moments of a probability distribution are summary statistics with uses similar to those of conventional moments, but they are defined in terms of the expected values of order statistics. Sample L-moments are defined analogously to population L-moments, and they can serve as estimators of population L-moments. They tend to be less sensitive to extreme observations than conventional moments. Parameters ---------- sample : array_like The real-valued sample whose L-moments are desired. order : array_like, optional The (positive integer) orders of the desired L-moments. Must be a scalar or non-empty 1D array. Default is [1, 2, 3, 4]. axis : int or None, default=0 If an int, the axis of the input along which to compute the statistic. The statistic of each axis-slice (e.g. row) of the input will appear in a corresponding element of the output. If None, the input will be raveled before computing the statistic. sorted : bool, default=False Whether `sample` is already sorted in increasing order along `axis`. If False (default), `sample` will be sorted. standardize : bool, default=True Whether to return L-moment ratios for orders 3 and higher. L-moment ratios are analogous to standardized conventional moments: they are the non-standardized L-moments divided by the L-moment of order 2. Returns ------- lmoments : ndarray The sample L-moments of order `order`. See Also -------- moment References ---------- .. [1] D. Bilkova. "L-Moments and TL-Moments as an Alternative Tool of Statistical Data Analysis". Journal of Applied Mathematics and Physics. 2014. :doi:`10.4236/jamp.2014.210104` .. [2] J. R. M. Hosking. "L-Moments: Analysis and Estimation of Distributions Using Linear Combinations of Order Statistics". Journal of the Royal Statistical Society. 1990. :doi:`10.1111/j.2517-6161.1990.tb01775.x` .. [3] "L-moment". *Wikipedia*. https://en.wikipedia.org/wiki/L-moment. Examples -------- >>> import numpy as np >>> from scipy import stats >>> rng = np.random.default_rng(328458568356392) >>> sample = rng.exponential(size=100000) >>> stats.lmoment(sample) array([1.00124272, 0.50111437, 0.3340092 , 0.16755338]) Note that the first four standardized population L-moments of the standard exponential distribution are 1, 1/2, 1/3, and 1/6; the sample L-moments provide reasonable estimates. rrrrr.Nr r)rrrryrrrQrrGrrrrr) rr5rr9rr< n_momentsrprkbkrlmomss rrr(sH vdK @D/3,F4u I )<<0A r~~auQ A '>!?@! DC V B RABsABwK FF38" %Ey1} ab U1X E"I q>rLinregressResult)slope interceptrvaluerstderrintercept_stderr)extra_field_namesc 2SnUcSn[R"U[SS9 [R"U5nUR SS:XaUupOgUR SS:XaUR upOE[SUR S 35e[R"U5n[R"U5nURS:XdURS:Xa [S 5e[R"U5[R"U5:Xa[U5S:a [S 5e[U5n[R"US5n[R"US5n[R"XSS 9RuppUS :XdU S :XaS n O,U [R"X-5- n U S:aSn OU S:aSn X- n X}U-- nUS:XaUSUS:XaSnOS nS nS nOUS- nU [R"USU - U-SU -U--- 5-n[!U5n[#UUU[S9nUR$S:XaUSOUn[R"SU S-- U -U- U- 5nU[R"XS--5-n['XU UUUS9$)aK Calculate a linear least-squares regression for two sets of measurements. Parameters ---------- x, y : array_like Two sets of measurements. Both arrays should have the same length N. If only `x` is given (and ``y=None``), then it must be a two-dimensional array where one dimension has length 2. The two sets of measurements are then found by splitting the array along the length-2 dimension. In the case where ``y=None`` and `x` is a 2xN array, ``linregress(x)`` is equivalent to ``linregress(x[0], x[1])``. .. deprecated:: 1.14.0 Inference of the two sets of measurements from a single argument `x` is deprecated will result in an error in SciPy 1.16.0; the sets must be specified separately as `x` and `y`. alternative : {'two-sided', 'less', 'greater'}, optional Defines the alternative hypothesis. Default is 'two-sided'. The following options are available: * 'two-sided': the slope of the regression line is nonzero * 'less': the slope of the regression line is less than zero * 'greater': the slope of the regression line is greater than zero .. versionadded:: 1.7.0 Returns ------- result : ``LinregressResult`` instance The return value is an object with the following attributes: slope : float Slope of the regression line. intercept : float Intercept of the regression line. rvalue : float The Pearson correlation coefficient. The square of ``rvalue`` is equal to the coefficient of determination. pvalue : float The p-value for a hypothesis test whose null hypothesis is that the slope is zero, using Wald Test with t-distribution of the test statistic. See `alternative` above for alternative hypotheses. stderr : float Standard error of the estimated slope (gradient), under the assumption of residual normality. intercept_stderr : float Standard error of the estimated intercept, under the assumption of residual normality. See Also -------- scipy.optimize.curve_fit : Use non-linear least squares to fit a function to data. scipy.optimize.leastsq : Minimize the sum of squares of a set of equations. Notes ----- For compatibility with older versions of SciPy, the return value acts like a ``namedtuple`` of length 5, with fields ``slope``, ``intercept``, ``rvalue``, ``pvalue`` and ``stderr``, so one can continue to write:: slope, intercept, r, p, se = linregress(x, y) With that style, however, the standard error of the intercept is not available. To have access to all the computed values, including the standard error of the intercept, use the return value as an object with attributes, e.g.:: result = linregress(x, y) print(result.intercept, result.intercept_stderr) Examples -------- >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from scipy import stats >>> rng = np.random.default_rng() Generate some data: >>> x = rng.random(10) >>> y = 1.6*x + rng.random(10) Perform the linear regression: >>> res = stats.linregress(x, y) Coefficient of determination (R-squared): >>> print(f"R-squared: {res.rvalue**2:.6f}") R-squared: 0.717533 Plot the data along with the fitted line: >>> plt.plot(x, y, 'o', label='original data') >>> plt.plot(x, res.intercept + res.slope*x, 'r', label='fitted line') >>> plt.legend() >>> plt.show() Calculate 95% confidence interval on slope and intercept: >>> # Two-sided inverse Students t-distribution >>> # p - probability, df - degrees of freedom >>> from scipy.stats import t >>> tinv = lambda p, df: abs(t.ppf(p/2, df)) >>> ts = tinv(0.05, len(x)-2) >>> print(f"slope (95%): {res.slope:.6f} +/- {ts*res.stderr:.6f}") slope (95%): 1.453392 +/- 0.743465 >>> print(f"intercept (95%): {res.intercept:.6f}" ... f" +/- {ts*res.intercept_stderr:.6f}") intercept (95%): 0.616950 +/- 0.544475 g#B ;NzInference of the two sets of measurements from a single "argument `x` is deprecated will result in an error in "SciPy 1.16.0; the sets must be specified separately as "`x` and `y`.rrrrzZIf only `x` is given as input, it has to be of shape (2, N) or (N, 2); provided shape was rvzInputs must not be empty.zBCannot calculate a linear regression if all x values are identicalrr rrYrr)r%r&r'rr(r))rrr/rrrrrrr,rrrcovflatrrArrr$)rrrrrrrrssxmssxymrssymrr%r&ro slope_stderrr)rrr s rrkrkC)sl Dy"  g1a@ JJqM 771:?DAq WWQZ1_33DAq$$%GG9A/0 0 JJqM JJqMvv{affk455 wwqzRWWQZCFQJ9: : AA GGAt E GGAt E 66!Q/44D s{dck  BGGDK( ( s7A XA LEe #IAv Q41Q4<DD  U sQw~a$?@A Ar"1dKB799>tBxtwwAqDD047"<= ("''$/*BB %Q#' -= ??r)rrrrrrc`Uc [U5OUn[XSS9nUbURX%S9OUn[U5(a+[ U5S:XdUb[ U5S:Xa [ XXS9$[ XSS9upURS:XdUc[O[n[ U5S:Xao[R"5 [R"S 5 URXUS 9nSSS5 [ W5S:wa[R"U[S S 9 U$[!XSUS 9upUb[!X$SUS 9upX-n URS:XdUc["O[$nU (aUS:XaUR'U5n UbXR'U5-n UR)UR+XS95(a[R"U[S S 9 UcUR-U5OUnUR/XRSUR0S9U5nUR/XRSUR0S9U5nUcURXUS 9$UR3X!S9n UR3X-US9n[4R6"S S S9 X- nSSS5 U(akUcS[9UR:5-nO=[=U[>5(dU4OUn[AUR:5nUHnSUU'M URCWU5nWRS:XaUS$U$!,(df  GN4=f!,(df  N=f)a Compute the arithmetic mean along the specified axis. Parameters ---------- x : real array Array containing real numbers whose mean is desired. axis : int or tuple of ints, default: None If an int or tuple of ints, the axis or axes of the input along which to compute the statistic. The statistic of each axis-slice (e.g. row) of the input will appear in a corresponding element of the output. If ``None``, the input will be raveled before computing the statistic. weights : real array, optional If specified, an array of weights associated with the values in `x`; otherwise ``1``. If `weights` and `x` do not have the same shape, the arrays will be broadcasted before performing the calculation. See Notes for details. keepdims : boolean, optional If this is set to ``True``, the axes which are reduced are left in the result as dimensions with length one. With this option, the result will broadcast correctly against the input array. nan_policy : {'propagate', 'omit', 'raise'}, default: 'propagate' Defines how to handle input NaNs. - ``propagate``: if a NaN is present in the axis slice (e.g. row) along which the statistic is computed, the corresponding entry of the output will be NaN. - ``omit``: NaNs will be omitted when performing the calculation. If insufficient data remains in the axis slice along which the statistic is computed, the corresponding entry of the output will be NaN. - ``raise``: if a NaN is present, a ``ValueError`` will be raised. dtype : dtype, optional Type to use in computing the mean. For integer inputs, the default is the default float type of the array library; for floating point inputs, the dtype is that of the input. Returns ------- out : array The mean of each slice Notes ----- Let :math:`x_i` represent element :math:`i` of data `x` and let :math:`w_i` represent the corresponding element of `weights` after broadcasting. Then the (weighted) mean :math:`\bar{x}_w` is given by: .. math:: \bar{x}_w = \frac{ \sum_{i=0}^{n-1} w_i x_i } { \sum_{i=0}^{n-1} w_i } where :math:`n` is the number of elements along a slice. Note that this simplifies to the familiar :math:`(\sum_i x_i) / n` when the weights are all ``1`` (default). The behavior of this function with respect to weights is somewhat different from that of `np.average`. For instance, `np.average` raises an error when `axis` is not specified and the shapes of `x` and the `weights` array are not the same; `xp_mean` simply broadcasts the two. Also, `np.average` raises an error when weights sum to zero along a slice; `xp_mean` computes the appropriate result. The intent is for this function's interface to be consistent with the rest of `scipy.stats`. Note that according to the formula, including NaNs with zero weights is not the same as *omitting* NaNs with ``nan_policy='omit'``; in the former case, the NaNs will continue to propagate through the calculation whereas in the latter case, the NaNs are excluded entirely. NTrrrr)rrr)force_floatingrrrDrr) xp_omit_okayrrr rrr)"r8r7rr9r:rBr>rr.r0rrrrrr-rr/r1rrrrrrrrrrrrrr_r)rrrrrrrrr$rrcontains_nan_wnan_maskrwsum final_shapeaxesrs rrr *sR "z rBt,A292Ebjjj.7G||q$0WW5E5JQdFF%aFJA*+1 $) qzQ  $ $ &  ! !( +''!':C' 3<1  MM'#5! D #ALOL)'DUWX#4 &'VVq[DL %  f,88A;   ) )H 66"&&&- . . MM'#5! D%,_",,q/' HHXzz!177z;Q ?((8ZZZ%A7Kwwqhw77 66'6 %D 66!+D6 )D Hh 7i 8 <QWW-K#-T8"<"# UHnTRUv M g7frry)rIrrs rrK_xp_var..*s3d!''!*dsrrrDr)r8r7rrrr[rconjr:riterablerrWrrrrrrrrr)rrrrrrrrrx_mean x_mean_conjrfrr7factors` rrr*s~ "z rB$At% GF A / / /D$**D1A Qr *F&(jj?Q&R&R2776? 6' E( Ef ECQ < A [[   3d33A A JJq J *  yy!cii8HFF8FBBAAL1,qJ,.?BFFS hh!m3r7,,rc&\rSrSrSrSrSrSrg)ri*c.[R"U5$rrndtrrrs rr_SimpleNormal.cdf*s||Arc0[R"U*5$rrErGs rr_SimpleNormal.sf*s||QBrc0[R"U5*$r)rrrGs rr_SimpleNormal.isf*s a   rrN)rrrrrrrrrrrrr*s  !rrc&\rSrSrSrSrSrSrg)ri*cXlgrrrrs rr_SimpleChi2.__init__*rcD[R"URU5$r)rchdtrrrGs rr_SimpleChi2.cdf*}}TWWa((rcD[R"URU5$r)rchdtrcrrGs rr_SimpleChi2.sf*s~~dggq))rrNrrrrrrrrrrrrr*)*rrc0\rSrSrSSS.SjrSrSrSrg)ri*Nrc4XlX lX0lX@lgrrrrr<)rrrrr<s rr_SimpleBeta.__init__*s rc\URc URbgURcSO URnURcSO URn[R"URUR X- U- 5$[R"URUR U5$Nrr)rr<rbetaincrrrrrr<s rr_SimpleBeta.cdf*sy 88 4::#9xx'!TXXC+AE??466466AGU?C Ctvvtvvq11rc\URc URbgURcSO URnURcSO URn[R"URUR X- U- 5$[R"URUR U5$r`)rr<rbetainccrrrbs rr_SimpleBeta.sf*s} 88 4::#9xx'!TXXC+AE##DFFDFFQWeOD D22rr]rYrrrrr*s%) 23rrc&\rSrSrSrSrSrSrg)rAi*cXlgrrrOs rr_SimpleStudentT.__init__+rQrcD[R"URU5$rrstdtrrrrs rr_SimpleStudentT.cdf+rUrcF[R"URU*5$rrkrms rr_SimpleStudentT.sf+s}}TWWqb))rrNrYrrrrArA*rZrrA)rNNrx)rrF)NTTN)Nrqrr)NrTrr)rrr)rrNN)rTr)rTTr)rrTr)TN)rrr)rr)rrN)rr)rQNNF)rQNN)rrr)rrrr)N)KrrlinearF)rr)r)rrrr)Nrrr)TNTr)Trr)rTrNr)NrrN)T)Nrr)rrrL)rrL)rrrrL)r)rrr)r}N)r)F)r.)Nr(rrrr collectionsrcollections.abcrnumpyrrrrscipyr scipy.spatialr scipy.optimizer r scipy._lib._utilr rrrrrscipy._lib.deprecationr scipy.specialrrrrr_stats_mstats_commonrrr_statsrrr dataclassesrr _hypotestsr _stats_pythranr! _resamplingr"r#r$r%r&r'r(_axis_nan_policyr)r*r+r,r-r.r/r0r1 _binomtestr2rscipy._lib._bunchr3r4r5r6scipy._lib._array_apir7r8r9r:r;r<r=r> scipy._libr?rr@__all__rrrrrBrCrDrrrErrrFrGrHrIrJrKr:r=rArLr[rIrgrMrNrrOrrrPrrQrrRrSrTrrUrrrrVr rWrXrYr r[r\rZr^erfinvrr6r]rFrCr_rSr`rarbrcrjrprtrrdrrrrrrrrrerfrr&r'r.rgrhrirjr|r~rrrlrrrrrrn_ttest_ind_dep_msgrmrrrrrrrrorrrrrrrtr rsr%r.r1r4r6rqKs_2sampResultrKrWr`rrr~rrprurrvrrwrrxrrrzrrr{r}r|r~rrrrArrryrrrrrrrr$rkrrrrrrArrrrs# &  "$$$)155> +JJ>>('=,,,III G/&1   .. #.!%"$'+:'';(3X'>D qA4&YKAM?AM?`qA4&YKA^CD^CA^CBqA4&YKAtzHAzHz &7 8  #,4EJ2LMM-MM-`24D$N14"00 00f1n5P5Pn1n9-9-x1n8-8-v1n.F.Fb1n99B+68W%Q f4f4 & f4R59:%)T6!r1 ^0  ^0B1 g0  g0T,)* Z1B&,.EF.ACb%Db%J 46MN,QGo)Ho)d02IJ*a1EI/FI/X,4@O1AO1n>HMMb(PVVr.NP;? KI\?+, J+Z?+, I%`Vr1; ; | . RCjq[[G|M `phs 3c 9DIIcN JK1!2E :;F).P Pf,"#299C$/W~.0MNB4JSlTnQ/h,.EF +F (d.DF\#F\#~   T5 *51N'  N'b '1T 8  4ufoF&';(3X'>DZ'Zz#.dQHh \1D\1~M8J$@D 0-8%CL\~$/c{aHy@$$5%0($;dVE=6/=6@I0 *a*<K@: K@:F!H" $.0GH6AK!\EH-;^,L+=?*a*<K+d Tg@K? g@T %*0 H.2#'L">B<@#.L&^ *a*<!%'d&'d&R (% 4 $$<$;=hXV\0~QEdQEh!+x1H"68H!IK "0#.7<0A*@B68$p/%Bp/f#LGT-`0A*@B68$s8%Bs8l:? 0%<>1T$OU6PU6p!!6!8:-;>A(v(<v(r,9+dSp/Ap/Tp/f a-a- a-H 2s Jd K\YFxS%L>%LP4:q$;qqh9x{t{| 4F)AQ >P%TP Pf%%7&:8J7KM F?R +DJ-Z1u4*-*-Z ! ! * *332 * *r