(ph;Sr/SQrSSKrSSKJr SSKJr SSKJrJr SSK r SSK r SSK r SSK J r SSKJr SS KJrJr SS KJr SSKJr SSKrSSKJs Jr SS KJrJrJr S r!S r"Sr#Sr$Sr%Sr&SeSjr'SfSjr(\ "SS5r)SgSjr*ShSjr+Sr,Sr-Sr.SiSjr/SjSjr0SkSjr1Sr2\ "SS 5r3S!r4SlS"jr5SmS#jrSnS$jr\"S%S&S'/5r6S(r7\ "S)S*5r8SoS+jr9\9r:\ "S,S*5r;SpS-jr<\ "S.S*5r=SoS/jr>\ "S0S*5r?SqS1jr@\ "S2S*5rAS3rB\BrC\"S4S55SrS6j5rD\"S4S55SsS7j5rE\ErF\"S4S55SrS8j5rGStS9jrHSuS:jrIS;rJSvS<jrK\KR(a\KR\J-\KlSwS=jrLSxS>jrM\MrNSyS?jrO\OR(a\OR\J-\OlSzS@jrP\PR(a\PR\J-\PlSzSAjrQ\QR(a\QR\J-\QlS{SBjrRSCrSSuSDjrTS|SEjrUS}SFjrVS}SGjrWS|SHjrXS~SIjrYSSJjrZSSK.SLjr[SSMjr\ShSNjr]SSOjr^\ "SPSQ5r_SSRjr`SlSSjra\ "STS*5rbSoSUjrc\ "SVS*5rdSoSWjre\ "SXS*5rfSgSYjrgSSZjrhSS[jriSS\jrj\jrkS]rlSS^jrm\ "S_S*5rnS`ro\ "SaS*5rpSbrq\ "ScS*5rrSSdjrsg)zA An extension of scipy.stats._stats_py to support masked arrays ): argstoarraycount_tied_groupsdescribef_oneway find_repeatsfriedmanchisquare kendalltaukendalltau_seasonalkruskal kruskalwallis ks_twosampks_2sampkurtosis kurtosistestks_1sampkstest linregress mannwhitneyumeppfmodemoment mquantilesmsign normaltestobrientransformpearsonrplotting_positionspointbiserialrrankdatascoreatpercentilesemsen_seasonal_slopesskewskewtest spearmanr siegelslopes theilslopestmaxtmeantmintrimtrimbothtrimtailtrimatrimr trimmed_mean trimmed_std trimmed_stde trimmed_vartsem ttest_1samp ttest_onesamp ttest_ind ttest_reltvar variation winsorize brunnermunzelN)ndarray)maskednomask) namedtuple) distributions)_rename_parameter _contains_nan)_make_tuple_bunch) _find_repeatsr&r%ct[R"U5nUc"U5nSnX4$UnX4$Nr<ma asanyarrayravel)aaxisoutaxiss L/var/www/html/venv/lib/python3.13/site-packages/scipy/stats/_mstats_basic.py _chk_asarrayrQ9s@ aA | HHQK : :c[R"U5n[R"U5nUc/[R"U5n[R"U5nSnOUnXU4$rHrI)rMbrNrOs rP _chk2_asarrayrUDsQ aA aA | HHQK HHQK =rRc[R"U5n[R"U5nURURp2X#:wa[SUSUS35eXU4$)Nz+The size of the input array should match! (z <> ))rJrKsize ValueError)rMrTnanbs rP _chk_sizer\Ps` aA aA x TbT,- - ":rRcUS:Xa [RRX5nOqUS:Xa![RRX*5nOJUS:Xa9[RRU[R"U5*5S-nO [ S5eUR S:XaUSnUR S:XaUSnX4$)z+Common code between all 3 t-test functions.lessgreater two-sidedz4alternative must be 'less', 'greater' or 'two-sided'r<)special_ufuncsstdtrnpabsrYndim)dft alternativepvals rP _ttest_finishrmZsf$$R+  !$$R,  #$$R"&&)4Q6<= = vv{ bE yyA~Bx 7NrRcB[U5S:XaM[US[5(d5[R"US5nUR S:wa [ S5eO[U5n[UVs/sHn[U5PM sn5n[R"[R"X$4[S9SS9n[U5Hup5XQUS[U524'M [U[R"[R"UR 55'U$s snf) a" Constructs a 2D array from a group of sequences. Sequences are filled with missing values to match the length of the longest sequence. Parameters ---------- *args : sequences Group of sequences. Returns ------- argstoarray : MaskedArray A ( `m` x `n` ) masked array, where `m` is the number of arguments and `n` the length of the longest argument. Notes ----- `numpy.ma.vstack` has identical behavior, but is called with a sequence of sequences. Examples -------- A 2D masked array constructed from a group of sequences is returned. >>> from scipy.stats.mstats import argstoarray >>> argstoarray([1, 2, 3], [4, 5, 6]) masked_array( data=[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], mask=[[False, False, False], [False, False, False]], fill_value=1e+20) The returned masked array filled with missing values when the lengths of sequences are different. >>> argstoarray([1, 3], [4, 5, 6]) masked_array( data=[[1.0, 3.0, --], [4.0, 5.0, 6.0]], mask=[[False, False, True], [False, False, False]], fill_value=1e+20) rAr<razThe input should be 2DdtypeTmaskN)len isinstancer=rJasarrayrhrYmaxarrayrfemptyfloat enumerater> logical_notisfinite_data)argsoutputnkmvs rPrrps` 4yA~ja'::DG$ ;;! 56 6  I &AQ& '"((A56TBt_EQ !1Wc!fW9 %9?F2>>"++fll3 45 M 's1Dc[R"[R"U5[RS9n[R "X5nU(aUR5n[U5$![ a SnN0f=f)azFind repeats in arr and return a tuple (repeats, repeat_count). The input is cast to float64. Masked values are discarded. Parameters ---------- arr : sequence Input array. The array is flattened if it is not 1D. Returns ------- repeats : ndarray Array of repeated values. counts : ndarray Array of counts. Examples -------- >>> from scipy.stats import mstats >>> mstats.find_repeats([2, 1, 2, 3, 2, 2, 5]) (array([2.]), array([4])) In the above example, 2 repeats 4 times. >>> mstats.find_repeats([[10, 20, 1, 2], [5, 5, 4, 4]]) (array([4., 5.]), array([2, 2])) In the above example, both 4 and 5 repeat 2 times. roF) rfrurJ compressedfloat64may_share_memoryAttributeErrorcopyrF)arrcompr need_copys rPrrsjB JJr}}S) >> from scipy.stats import mstats >>> import numpy as np >>> z = [0, 0, 0, 2, 2, 2, 3, 3, 4, 5, 6] >>> mstats.count_tied_groups(z) {2: 1, 3: 2} In the above example, the ties were 0 (3x), 2 (3x) and 3 (2x). >>> z = np.ma.array([0, 0, 1, 2, 2, 2, 3, 3, 4, 5, 6]) >>> mstats.count_tied_groups(z) {2: 2, 3: 1} >>> z[[1,-1]] = np.ma.masked >>> mstats.count_tied_groups(z, use_missing=True) {2: 2, 3: 1} rA)rJgetmasksumrrrrsdictziprfunique itertoolsrepeatupdateKeyError)x use_missingnmaskeddatatiescountsntiess rPrrsDjjm!G ==  "D!$'NT E 4yyS6*I,<,C?c SSjn[R"USS9nUcHURS:a0U"UR5U5R UR 5$U"X5$[R "X1X5R[5$)aReturns the rank (also known as order statistics) of each data point along the given axis. If some values are tied, their rank is averaged. If some values are masked, their rank is set to 0 if use_missing is False, or set to the average rank of the unmasked values if use_missing is True. Parameters ---------- data : sequence Input data. The data is transformed to a masked array axis : {None,int}, optional Axis along which to perform the ranking. If None, the array is first flattened. An exception is raised if the axis is specified for arrays with a dimension larger than 2 use_missing : bool, optional Whether the masked values have a rank of 0 (False) or equal to the average rank of the unmasked values (True). FcUR5n[R"UR[S9nUR 5n[R "SUS-5X4SU'U(aUS-S- X4US'OSX4US'[UR55nUSH*nX:HRS5nX7R5X7'M, U$)NrorA@r<F) countrfrxrXryargsortarangerrfilledmean)rrrrkidxrepeatsr conditions rP_rank1drankdata.._rank1d%s JJL XXdiiu -llnii!A#&r7 Q3(B12wKB12wKtyy{+A**51IM..0BM rRrrAF) rJrwrhrLreshapeshapeapply_along_axisviewr=)rrNrrs rPrrst*" 88Du %D | 99q=4::<5==djjI I4- -""7AFFwOOrR ModeResult)rrc[XSS9$)a Returns an array of the modal (most common) value in the passed array. Parameters ---------- a : array_like n-dimensional array of which to find mode(s). axis : int or None, optional Axis along which to operate. Default is 0. If None, compute over the whole array `a`. Returns ------- mode : ndarray Array of modal values. count : ndarray Array of counts for each mode. Notes ----- For more details, see `scipy.stats.mode`. Examples -------- >>> import numpy as np >>> from scipy import stats >>> from scipy.stats import mstats >>> m_arr = np.ma.array([1, 1, 0, 0, 0, 0], mask=[0, 0, 1, 1, 1, 0]) >>> mstats.mode(m_arr) # note that most zeros are masked ModeResult(mode=array([1.]), count=array([2.])) T)rNkeepdims)_mode)rMrNs rPrrCsB  --rRc6[X5upSnUcOU"[R"U55n[R"US5[R"US54nO[R"X1U5nUbU(ax[ UR 5nSXQ'[S5/UR-nSXa'U[U5RU5nSXa'U[U5RU5nXx4nO[R"XAS5n[U6$)Nc[U5upUR(dgUR(a"XR5UR 54$UR 5S4$)Nr<r<rA)rrhrXargmaxrvmin)rMrepcnts rP_mode1D_mode.._mode1DksH O xx XX %swwy1 1EEGQ< rRr<rA)rQrJrLrwrlistrslicerhtuplerrfmoveaxisr) rMrNrrrnewshapeslicesmodesrs rPrrgs1#GA  |!%((6!9%rxxq ':;$$WA6  xAGG}HHNDk]V[[0FFL5=)11(;EFLE&M*228>> import numpy as np >>> from scipy import stats >>> from scipy.stats import mstats >>> mstats.pearsonr([1, 2, 3, 4, 5], [10, 9, 2.5, 6, 4]) (-0.7426106572325057, 0.1505558088534455) 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. >>> s = 0.5 >>> x = stats.norm.rvs(size=500) >>> e = stats.norm.rvs(scale=s, size=500) >>> y = x + e >>> mstats.pearsonr(x, y) (0.9029601878969703, 8.428978827629898e-185) # may vary 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) >>> mstats.pearsonr(x, y) (-0.016172891856853524, 0.7182823678751942) # may vary 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) >>> mstats.pearsonr(x, y) (0.8537091583771509, 3.183461621422181e-143) # may vary 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. rar<rq) r\rLrJmask_orrrr>scipystats _stats_pyr masked_arrayr)ryrrris rPrrs|!IQ1ggi 2::a="**Q-0ALA 1B Av ;; ) )*557*557 99rRc.^U(d [S5e[X5upUbB[X5upUS:Xa[R"X45nO[R"X45nUS:Xa UR nUS:Xa[R "U5nU4SjnURSn U S:XaU"U5$[R"X4[S9n [R"X4[S9n [U S- 5Hin [U S-U 5HSn U"USS2X/45nURXU 4'URXU 4'URXU 4'URXU 4'MU Mk [R R"R%X5nXl U$) a Calculates a Spearman rank-order correlation coefficient and the p-value to test for non-correlation. The Spearman correlation is a nonparametric measure of the linear relationship between two datasets. Unlike the Pearson correlation, the Spearman correlation does not assume that both datasets are normally distributed. Like other correlation coefficients, this one varies between -1 and +1 with 0 implying no correlation. Correlations of -1 or +1 imply a monotonic relationship. Positive correlations imply that as `x` increases, so does `y`. Negative correlations imply that as `x` increases, `y` decreases. Missing values are discarded pair-wise: if a value is missing in `x`, the corresponding value in `y` is masked. The p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Spearman correlation at least as extreme as the one computed from these datasets. The p-values are not entirely reliable but are probably reasonable for datasets larger than 500 or so. Parameters ---------- x, y : 1D or 2D array_like, y 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. use_ties : bool, optional DO NOT USE. Does not do anything, keyword is only left in place for backwards compatibility reasons. 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. 'propagate' returns nan, 'raise' throws an error, 'omit' performs the calculations ignoring nan values. Default is 'propagate'. alternative : {'two-sided', 'less', 'greater'}, optional Defines the alternative hypothesis. Default is 'two-sided'. The following options are available: * 'two-sided': the correlation is nonzero * 'less': the correlation is negative (less than zero) * 'greater': the correlation is positive (greater than zero) .. versionadded:: 1.7.0 Returns ------- res : SignificanceResult An object containing attributes: statistic : float or ndarray (2-D square) Spearman correlation matrix or correlation coefficient (if only 2 variables are given as parameters). Correlation matrix is square with length equal to total number of variables (columns or rows) in ``a`` and ``b`` combined. pvalue : float The p-value for a hypothesis test whose null hypothesis is that two sets of data are linearly uncorrelated. See `alternative` above for alternative hypotheses. `pvalue` has the same shape as `statistic`. References ---------- [CRCProbStat2000] section 14.7 z3`use_ties=False` is not supported in SciPy >= 1.2.0Nr<rAomitcL>[R"USS9nXRRSS9)SS24n[R"UR 5(d][ RRR[R[R5n[RUl U$[R"U5nURSnUS- [URSS9S5- nUS:a [!S5e[#USS9n[R$"USS9R n[R&"SS 9 U[R("XFS -S U- -- R+S55-nSSS5 [-UWT 5upxURS :Xa<[ RRRUS US 5nUS Ul U$[ RRRXh5nXal U$!,(df  N=f) Nr<rNrAraz'The input must have at least 3 entries!F)rowvarignore)divider)rararAr<)rJ mask_rowcolsrranyrfrrrrSignificanceResultnan correlationrrintrrYrcorrcoeferrstatesqrtcliprm) rresrn_obsdofx_rankedrsrjprobrks rP_spearmanr_2cols#spearmanr.._spearmanr_2colss OOAA & vvzzqz!!1$ %vvaff~~++''::266266JC ffCOJ JJqM ai#aeeemA.// 7FG GAA& [[% 0 5 5[[ )RWWcfR%89??BCCA*  Q 4 88v ++''::2d8;?:GC hCOJ++''::2DC OJ!* )s 4H H#raro)rYrQrJ column_stackvstackTmasked_invalidrrfonesryzerosrangerpvaluerrrr)rruse_tiesrN nan_policyrkaxisout_rn_varsrrvar1var2resultrs ` rPr$r$?suR NOOa&JA}A$ a<'A 1&!A!| CCV   a 'VWWQZF {"" WWf%U 3xx(6&1*%Dd1ff-)!A|O*<=!'!3!3:!'!3!3:#)==4Z #)==4Z .&kk##66r@ rRc (XUS- -S-U- :nUS:Hn[[XUS- -S-U- 55nUS::a[SUS35eUS:dSU-XS- -:a[SUS XS- -S 35eUS:XaS nSnGOUS:XaS nS nGOUS:Xa(US :aS[R"U5- OSnUS- nGOUS:XaBUS:aS[R"US- 5- OSnUS- [R"U5- nGOZSU-XS- -:Xa US:XaS nGOBUS :a[ R "US-5nS USS&[SUS-5H6n[ R"U5nX::dM XxS===USUS-U- -sss&M8 S[ R"U5-[R"U5- nUS[R"U5- nO[ R "US-5nS USS&[SUS-5H9n[ R"U5U- nX::dM#XxS===USUS-U- -sss&M; [ R"U5nUSS- nUS:waX4:XaUS-nO SUS- - W-n[ R"USS5nU$)NrArar_r<zn (z) must be positivezc (z#) must satisfy 0 <= 4c <= n(n-1) = .r?rr`) rrrYmath factorialrfrrcumsumrr) rcrk in_right_tailalternative_greaterr p_mass_at_cnewjs rP_kendall_p_exactrsac7Q,**M&)3 CqsGa>!$$S1f a*+c's4>>!A#&&ssDNN1-- 1Q3K;6 ShhqsmAaq1A))C.CvB3v!A;&266#;t~~a00"gdnnQ// hhqsmAaq!A#A))C."CvB3v!A;&vvc{"gai k!  / AIDtAv: +D 774A D KrRc  [X5upnUR5UR5p[R"[R"U5[R"U55nU[ LaF[R "XSS9n[R "XSS9nU[UR55-nUS:a][RRR[R[R5n[RUlU$[R "[#XS9S5n [R "[#XS9S5n U R%5n XXp[R"['[)U 5S- 5V s/sH9n XS-SX:XS-SX:-R+S5R5PM; sn [,S9n [R"['[)U 5S- 5V s/sH9n XS-SX:XS-SX:-R+S5R5PM; sn [,S9n[/U5n[/U5nU(a[R"UR15VVs/sHunnUU-US- -PM snn[,S9n[R"UR15VVs/sHunnUU-US- -PM snn[,S9n[R2"XfS- -U- S - XfS- -U- -S - 5nO XfS- -S - nX- U- nUS :XaU(dU(a [5S 5eUS :Xa4U(d+U(d$US ::dUS- -S - U - 5S::aS nOSnU(dU(dUS :Xa[9XmU5nGOUS:XGatXfS- -SU-S--nU(GaU[R"UR15VVs/sHunnUU-US- -SU-S--S-PM snn5-nU[R"UR15VVs/sHunnUU-US- -SU-S--S-PM snn5-n[R"UR15VVs/sHunnUU-US- -PM snn[,S9[R"UR15VVs/sHunnUU-US- -PM snn[,S9-nUS U-US- --nUS:a[R"UR15VVs/sHunnUU-US- -US- -PM snn[,S9[R"UR15VVs/sHunnUU-US- -US- -PM snn[,S9-nUSU-US- -US- --nOSnOS=nnUS-nUUU-- nX- [R2"U5- n[RRR;U[<R>U5nO[5S[AU5-S-5e[RRRUSUS5nUUlU$s sn fs sn fs snnfs snnfs snnfs snnfs snnfs snnfs snnfs snnf)ac Computes Kendall's rank correlation tau on two variables *x* and *y*. Parameters ---------- x : sequence First data list (for example, time). y : sequence Second data list. use_ties : {True, False}, optional Whether ties correction should be performed. use_missing : {False, True}, optional Whether missing data should be allocated a rank of 0 (False) or the average rank (True) method : {'auto', 'asymptotic', 'exact'}, optional Defines which method is used to calculate the p-value [1]_. '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. 'auto' is the default and selects the appropriate method based on a trade-off between speed and accuracy. 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. References ---------- .. [1] Maurice G. Kendall, "Rank Correlation Methods" (4th Edition), Charles Griffin & Co., 1970. T)rrrrarr<rANrorexactz(Ties found, exact method cannot be used.auto! asymptoticr"@g2@zUnknown method z1 specified, please use auto, exact or asymptotic.rb)!r\flattenrJrrr?rwrrrrrrrfrr masked_equalrrrrsrryritemsrrYrr _get_pvaluerBnormstr)rrrrmethodrkrrrrxryriCDxtiesytiesrrcorr_xcorr_ydenomtaurvar_sv1v2zs rPrrsb!IQ1iik199; 2::a="**Q-0A HHQT * HHQT * S\1ukk##66rvvrvvF&& !=q AB !=q AB **,C s2wqy)+)AqST(RU"rA#$x"%'78@@CGGI)+27 9A s2wqy)+)AqST(RU"R!X%56>>qAEEG)+27 9A a E a E > u!1ac >eL > u!1ac >eLaC+qA#wv~>rABQ3  3%-C euCDD e!r'SqsGCKM5Ja5OF!F 6W#4k2 < Q31Q  RVVu{{}M}eqQqS!A#Y!A.r1}MN NE RVVu{{}M}eqQqS!A#Y!A.r1}MN NE&&%++-@-A!A#qs)-@N&&%++-@-A!A#qs)-@NOB "Q$!* B1uVV%++-H-!AQqS!A#Y!_-H"')VV%++-H-!AQqS!A#Y!_-H"'))bdAaCj!A#&&KB   "r' S"''%. {{$$00M4F4F T*3v;68::; ; ++   2 23r7DH ECCO Jo++ ?>*NM@@IHs>AZ AZZ Z $Z! $Z' #Z- (Z3 Z9 Z? c ^^^[R"TSSSS9mTRupTRS5n[ U4Sj[ U555nUR 5nTR5n[ TR55n[ SUR555n[R"SU-US - -XfS - -U- -5S - n [TSSS 9n [R"X"4[S 9n [R"X"4[S 9n [R"U[S 9n [ U5GH m[ TS S 2T4R55n[ SUR555nUTUTS - -n[ TUS 5Hm[ UUU4Sj[ U555U TT4'U TT4SU S S 2T4U S S 2T4-R 5--XTS --UTS --- S- U TT4'U TT4U TT4'U TT4U TT4'M [R"UUU- -5S - U T'GM U R5n[U5[!U5S - -[R"U5- n[U5[!U5S - -[R"UR 55- n[U5[!U5S - -[R"U R 55- n["R$"[!UR&5[(R"S5- 5n["R$"[!U5[(R"S5- 5n["R$"[!U5[(R"S5- 5nUU-R 5nUUR+5S--nXM- XY- X]R 5- UUUUUS.nU$)z Computes a multivariate Kendall's rank correlation tau, for seasonal data. Parameters ---------- x : 2-D ndarray Array of seasonal data, with seasons in columns. TFrasubokrndminr<c3j># UH(n[TUSTU- 5RS5v M* g7frHrr).0r#rs rP &kendalltau_seasonal..s2;(QaeAaDj!%%a(((s03c3:# UHupX!-US- -v M g7frANrbr6rrs rPr7r8s8<%1AC1I<rrAr)rNrroNc3:# UHupX!-US- -v M g7fr:rbr;s rPr7r8s;N5AQS!A#YNr<c3># UH?n[TUS2T4TUT4- TUS2T4TUT4- -5R5v MA g7fNr5)r6r#rrrs rPr7r8sZ,"*Q!"Q$!A#12a41Q3@AEEGG"*sAA r@)z seasonal tauz global tauzglobal tau (alt)zseasonal p-valuezglobal p-value (indep)zglobal p-value (dep)z chi2 totalz chi2 trend)rJrwrrrrrrrrrrxrrydiagonalrrgrcerfcrrfr)rrrn_pS_sznS_totn_totr corr_ties denom_totRKcovmat denom_sznties_jcorr_jcmbvar_sznz_szn z_tot_ind z_tot_depprob_szn prob_tot_ind prob_tot_depchi2_totchi2_trdrrrs` @@rPr r sl $U!4A GGEQ ''!*C ;%(; ;E IIKE GGIE Q\\^ ,D84::<88I5%'*E7OI,EFGJI-A !c"A XXqe5 )F%(I 1X"1QqS6#4#4#67;FLLN;;!fc!fQhq1A,"'(,,AacFQqS6Aq1va!f}&9&9&;$;;!fQh<Q23467F1Q3KqsVAacF 1+F1Q3K wwsCJ/025 ! ooG %LCJqL )BGGG,< >> 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.mstats.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 Nr<rarAzZIf only `x` is given as input, it has to be of shape (2, N) or (N, 2), provided shape was zBCannot calculate a linear regression if all x values are identicalF)shrinkrq)slope interceptrvaluerstderrintercept_stderr)rJrwrrrYrrfamaxaminrsrrr?rrrrLinregressResult)rrrrs rPrrsV y HHQK 771:?DAq WWQZ1_33DAq33477)=> > HHQK HHQK A A wwqzRWWQZCFQJ9: : 2::a="**Q->A HHQ  HHQ  661"::))!&&!*affaRjAF M//dd7;D7;AEGF M%%affaff5 MrRcj[R"U5R5nUc#[R"[ U5[ S9nO`[R"U5R5n[ U5[ U5:wa$[ S[ U5S[ U5S35e[R"[R"U5[R"U55nU=Ul Ul UR5nUR5R[ 5n[XX#S9$)a Computes the Theil-Sen estimator for a set of points (x, y). `theilslopes` implements a method for robust linear regression. It computes the slope as the median of all slopes between paired values. Parameters ---------- y : array_like Dependent variable. x : array_like or None, optional Independent variable. If None, use ``arange(len(y))`` instead. alpha : float, optional Confidence degree between 0 and 1. Default is 95% confidence. Note that `alpha` is symmetric around 0.5, i.e. both 0.1 and 0.9 are interpreted as "find the 90% confidence interval". method : {'joint', 'separate'}, optional Method to be used for computing estimate for intercept. Following methods are supported, * 'joint': Uses np.median(y - slope * x) as intercept. * 'separate': Uses np.median(y) - slope * np.median(x) as intercept. The default is 'separate'. .. versionadded:: 1.8.0 Returns ------- result : ``TheilslopesResult`` instance The return value is an object with the following attributes: slope : float Theil slope. intercept : float Intercept of the Theil line. low_slope : float Lower bound of the confidence interval on `slope`. high_slope : float Upper bound of the confidence interval on `slope`. See Also -------- siegelslopes : a similar technique using repeated medians Notes ----- For more details on `theilslopes`, see `scipy.stats.theilslopes`. roIncompatible lengths ! (<>rW)alphar ) rJrurrrsryrYrr_maskrr\stats_theilslopes)rrrsr rs rPr&r&sj 1 Ay IIc!fE * JJqM ! ! # q6SV 7Axr#a&KL L 2::a="**Q-0AAGag A e$A Q >>rRcj[R"U5R5nUc#[R"[ U5[ S9nO`[R"U5R5n[ U5[ U5:wa$[ S[ U5S[ U5S35e[R"[R"U5[R"U55nU=Ul Ul UR5nUR5R[ 5n[XUS9$)aP Computes the Siegel estimator for a set of points (x, y). `siegelslopes` implements a method for robust linear regression using repeated medians to fit a line to the points (x, y). The method is robust to outliers with an asymptotic breakdown point of 50%. Parameters ---------- y : array_like Dependent variable. x : array_like or None, optional Independent variable. If None, use ``arange(len(y))`` instead. method : {'hierarchical', 'separate'} If 'hierarchical', estimate the intercept using the estimated slope ``slope`` (default option). If 'separate', estimate the intercept independent of the estimated slope. See Notes for details. Returns ------- result : ``SiegelslopesResult`` instance The return value is an object with the following attributes: slope : float Estimate of the slope of the regression line. intercept : float Estimate of the intercept of the regression line. See Also -------- theilslopes : a similar technique without repeated medians Notes ----- For more details on `siegelslopes`, see `scipy.stats.siegelslopes`. rorqrrrW)r ) rJrurLrrsryrYrrrtrr\stats_siegelslopes)rrr rs rPr%r%sP 1 Ay IIc!fE * JJqM   ! q6SV 7Axr#a&KL L 2::a="**Q-0AAGag A e$A a6 22rRSenSeasonalSlopesResult intra_slope inter_slopec v[R"USSSS9nURup[R"[ U5Vs/sH0nXS-SX- [ R "SX- 5SS2S4- PM2 sn5n[R"USS9n[R"USS9n[XV5$s snf) a Computes seasonal Theil-Sen and Kendall slope estimators. The seasonal generalization of Sen's slope computes the slopes between all pairs of values within a "season" (column) of a 2D array. It returns an array containing the median of these "within-season" slopes for each season (the Theil-Sen slope estimator of each season), and it returns the median of the within-season slopes across all seasons (the seasonal Kendall slope estimator). Parameters ---------- x : 2D array_like Each column of `x` contains measurements of the dependent variable within a season. The independent variable (usually time) of each season is assumed to be ``np.arange(x.shape[0])``. Returns ------- result : ``SenSeasonalSlopesResult`` instance The return value is an object with the following attributes: intra_slope : ndarray For each season, the Theil-Sen slope estimator: the median of within-season slopes. inter_slope : float The seasonal Kendall slope estimator: the median of within-season slopes *across all* seasons. See Also -------- theilslopes : the analogous function for non-seasonal data scipy.stats.theilslopes : non-seasonal slopes for non-masked arrays Notes ----- The slopes :math:`d_{ijk}` within season :math:`i` are: .. math:: d_{ijk} = \frac{x_{ij} - x_{ik}} {j - k} for pairs of distinct integer indices :math:`j, k` of :math:`x`. Element :math:`i` of the returned `intra_slope` array is the median of the :math:`d_{ijk}` over all :math:`j < k`; this is the Theil-Sen slope estimator of season :math:`i`. The returned `inter_slope` value, better known as the seasonal Kendall slope estimator, is the median of the :math:`d_{ijk}` over all :math:`i, j, k`. References ---------- .. [1] Hirsch, Robert M., James R. Slack, and Richard A. Smith. "Techniques of trend analysis for monthly water quality data." *Water Resources Research* 18.1 (1982): 107-121. Examples -------- Suppose we have 100 observations of a dependent variable for each of four seasons: >>> import numpy as np >>> rng = np.random.default_rng() >>> x = rng.random(size=(100, 4)) We compute the seasonal slopes as: >>> from scipy import stats >>> intra_slope, inter_slope = stats.mstats.sen_seasonal_slopes(x) If we define a function to compute all slopes between observations within a season: >>> def dijk(yi): ... n = len(yi) ... x = np.arange(n) ... dy = yi - yi[:, np.newaxis] ... dx = x - x[:, np.newaxis] ... # we only want unique pairs of distinct indices ... mask = np.triu(np.ones((n, n), dtype=bool), k=1) ... return dy[mask]/dx[mask] then element ``i`` of ``intra_slope`` is the median of ``dijk[x[:, i]]``: >>> i = 2 >>> np.allclose(np.median(dijk(x[:, i])), intra_slope[i]) True and ``inter_slope`` is the median of the values returned by ``dijk`` for all seasons: >>> all_slopes = np.concatenate([dijk(x[:, i]) for i in range(x.shape[1])]) >>> np.allclose(np.median(all_slopes), inter_slope) True Because the data are randomly generated, we would expect the median slopes to be nearly zero both within and across all seasons, and indeed they are: >>> intra_slope.data array([ 0.00124504, -0.00277761, -0.00221245, -0.00036338]) >>> inter_slope -0.0010511779872922058 TFrar1rANr<r) rJrwrrrrfrmedianrx)rrrr# szn_slopes szn_medslopesmedslopes rPr!r!(sT $U!4A GGEQ%*1X/%-stWQT\299Qqs+;AdF+CC%-/0JIIjq1Myy$/H "= ;; /s7B6Ttest_1sampResult) statisticrc[X5upURS:Xa [R[R4$UR US9nUR USS9nUR US9n[R"US- 5nUS- U-U- n[R"SSS9 XA- [R"X- 5- n SSS5 [UW U5up[X5$!,(df  N(=f) a Calculates the T-test for the mean of ONE group of scores. Parameters ---------- a : array_like sample observation popmean : float or array_like expected value in null hypothesis, if array_like than it must have the same shape as `a` excluding the axis dimension axis : int or None, optional Axis along which to compute test. If None, compute over the whole array `a`. 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`) .. versionadded:: 1.7.0 Returns ------- statistic : float or array t-statistic pvalue : float or array The p-value Notes ----- For more details on `ttest_1samp`, see `scipy.stats.ttest_1samp`. r<rrArNddofrrrinvalidN) rQrXrfrrvarrrJrKrrrmr) rMpopmeanrNrkrrrrisvarrjrs rPr4r4sN1#GAvv{ DA 4a A TA q3w B WMR D Hh 7 [BGGDH- - 8B;/GA Q %% 8 7s %C%% C3Ttest_indResultc[XU5upnURS:XdURS:Xa([[R[R5$UR U5UR U5peUR USS9UR USS9pURU5URU5pU(aR[R"X-S- 5n U S- U-U S- U--U - n [R"U SU - SU - --5n OXy- nX- n[R"SSS9 X-S-US-U S- - US-U S- - -- n S S S 5 [R"[R"W 5SU 5n [R"X-5n [R"SSS9 XV- U - nS S S 5 [U WU5unn[UU5$!,(df  N=f!,(df  N;=f) a| Calculates the T-test for the means of TWO INDEPENDENT samples of scores. 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, perform a standard independent 2 sample test that assumes equal population variances. If False, perform Welch's t-test, which does not assume equal population variance. .. versionadded:: 0.17.0 alternative : {'two-sided', 'less', 'greater'}, optional Defines the alternative hypothesis. The following options are available (default is 'two-sided'): * 'two-sided': the means of the distributions underlying the samples are unequal. * 'less': the mean of the distribution underlying the first sample is less than the mean of the distribution underlying the second sample. * 'greater': the mean of the distribution underlying the first sample is greater than the mean of the distribution underlying the second sample. .. versionadded:: 1.7.0 Returns ------- statistic : float or array The calculated t-statistic. pvalue : float or array The p-value. Notes ----- For more details on `ttest_ind`, see `scipy.stats.ttest_ind`. r<rArrrrrraN)rUrXrrfrrrrrJrKrrrisnanrm)rMrTrN equal_varrkx1x2r-r.n1n2rirr*vn1vn2rjrs rPr6r6s\qT*JA$vv{affkrvvrvv..t affTl4a(!%%T%*B qwwt} ]]27S= )Ar 2a4)#r)c"fs2vo./ee [[( ;)a36R!V#4sAva7H#HIB< XXbhhrlAr * " Hh 7 UeO 8B;/GAt 1d ##< ; 8 7s/ G0G- G*- G;Ttest_relResultc|[XU5upn[U5[U5:wa [S5eURS:XdURS:Xa([ [ R [ R 5$URU5n[R"US- 5nX- RS5nURU5nURUSS9n[R"X- 5n [ R"SSS9 Xy- n S S S 5 [UW U5up[ X5$!,(df  N(=f) a! Calculates the T-test on TWO RELATED samples of scores, a and b. 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`. 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.7.0 Returns ------- statistic : float or array t-statistic pvalue : float or array two-tailed p-value Notes ----- For more details on `ttest_rel`, see `scipy.stats.ttest_rel`. zunequal length arraysr<rdrArrrN)rUrsrYrXrrfrrrJrKr\rrrrrm) rMrTrNrkrrirdmrr*rjrs rPr7r7.sLqT*JA$ 1vQ011vv{affkrvvrvv..  A qu B  SA B 4a A GGAENE Hh 7 J 8B;/GA 1 ## 8 7s D-- D;MannwhitneyuResultcx[R"U5R5R[5n[R"U5R5R[5n[ [ R"X/55n[U5[U5pTXE-nUSUR5XDS--S- - n[XtU-U- 5nXE-U- nXE-S- n US-U- S- n [U5n U [SU R555S- -n XU-[XfS- -5- -n U(a US- U - [R"U 5- n OXy- [R"U 5- n [R "[#U 5[ R"S5- 5n [%X5$) a Computes the Mann-Whitney statistic Missing values in `x` and/or `y` are discarded. Parameters ---------- x : sequence Input y : sequence Input use_continuity : {True, False}, optional Whether a continuity correction (1/2.) should be taken into account. Returns ------- statistic : float The minimum of the Mann-Whitney statistics pvalue : float Approximate two-sided p-value assuming a normal distribution. NrArr(@c3:# UHupX!S-U- -v M g7frNrbr;s rPr7mannwhitneyu..6qDFr<rra)rJrurrr=rrf concatenatersrrvrrryrrcrBrgr)rruse_continuityranksnxnyntUumusigsqrr/rs rPrrlsm. 1   "''0A 1   "''0A R^^QE* +EAA B cr 2!t9R<'A A"uqyA  A %B URZ E U #D S66 6s ::E U5T# ##E X]bggen , Vrwwu~ % <<Arwwqz) *D a &&rR KruskalResultc"[U6n[R"[USS9S5nUR S5nUR S5nUR 5nSXUS--- US-U- R 5-SUS--- n[ U5nS [ S UR555[US-U- 5- - nUS:Xa [S 5eXh-n[U5S- n [RRXi5n [Xj5$) aQ Compute the Kruskal-Wallis H-test for independent samples Parameters ---------- sample1, sample2, ... : array_like Two or more arrays with the sample measurements can be given as arguments. 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 Notes ----- For more details on `kruskal`, see `scipy.stats.kruskal`. Examples -------- >>> from scipy.stats.mstats import kruskal Random samples from three different brands of batteries were tested to see how long the charge lasted. Results were as follows: >>> a = [6.3, 5.4, 5.7, 5.2, 5.0] >>> b = [6.9, 7.0, 6.1, 7.9] >>> c = [7.2, 6.9, 6.1, 6.5] Test the hypothesis that the distribution functions for all of the brands' durations are identical. Use 5% level of significance. >>> kruskal(a, b, c) KruskalResult(statistic=7.113812154696133, pvalue=0.028526948491942164) The null hypothesis is rejected at the 5% level of significance because the returned p-value is less than the critical value of 5%. Frr<rrrArarrc3:# UHupX!S-U- -v M g7frrbr;s rPr7kruskal..rr<z$All numbers are identical in kruskal)rrJrrrrrrryrYrsrBchi2sfr) r~rrsumrkngrpntotHrrrirs rPr r sV$ F OOHV? CE IIbME ;;r?D ;;=D T6]uax}1133aaj@A U #D S66 6uT1WT\7J JJAAv?@@FA VqB     'D  !!rRrr cSSSS.RUR5SU5n[RRR XX#US9$)a Computes the Kolmogorov-Smirnov test on one sample of masked values. Missing values in `x` are discarded. Parameters ---------- x : array_like a 1-D array of observations of random variables. cdf : str or callable If a string, it should be the name of a distribution in `scipy.stats`. If a callable, that callable is used to calculate the cdf. args : tuple, sequence, optional Distribution parameters, used if `cdf` is a string. alternative : {'two-sided', 'less', 'greater'}, optional Indicates the alternative hypothesis. Default is 'two-sided'. 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 approximation to exact distribution of test statistic * 'asymp' : use asymptotic distribution of test statistic Returns ------- d : float Value of the Kolmogorov Smirnov test p : float Corresponding p-value. r`r_r^rjglr<)r~rkr )getlowerrrrr)rcdfr~rkr s rPrrsZD$)&AEE1{,K ;; ) ) T6 * CCrRcSSSS.RUR5SU5n[RRR XUUS9$)a( Computes the Kolmogorov-Smirnov test on two samples. Missing values in `x` and/or `y` are discarded. Parameters ---------- data1 : array_like First data set data2 : array_like Second data set alternative : {'two-sided', 'less', 'greater'}, optional Indicates the alternative hypothesis. Default is 'two-sided'. 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 approximation to exact distribution of test statistic * 'asymp' : use asymptotic distribution of test statistic Returns ------- d : float Value of the Kolmogorov Smirnov test p : float Corresponding p-value. r`r_r^rr<rkr )rrrrrr )data1data2rkr s rPr r sYD$)&AEE1{,K ;; ) )%6A17 * 99rRcT[RRRXUX4S9$)aJ Parameters ---------- data1 : array_like data2 : str, callable or array_like args : tuple, sequence, optional Distribution parameters, used if `data1` or `data2` are strings. alternative : str, as documented in stats.kstest method : str, as documented in stats.kstest Returns ------- tuple of (K-S statistic, probability) r)rrrr)rrr~rkr s rPrr2s/$ ;; ' 'd4? ( PPrRc[R"U5nUR5 UbUS:XaU$Uup4UupVSnUbU(aXpU:-nOXpU:*-nUbU(aXpU:-nOXpU:-n[XR S5'U$)a Trims an array by masking the data outside some given limits. Returns a masked version of the input array. Parameters ---------- a : array_like Input array. limits : {None, tuple}, optional Tuple of (lower limit, upper limit) in absolute values. Values of the input array lower (greater) than the lower (upper) limit will be masked. A limit is None indicates an open interval. inclusive : (bool, bool) tuple, optional Tuple of (lower flag, upper flag), indicating whether values exactly equal to the lower (upper) limit are allowed. Examples -------- >>> from scipy.stats.mstats import trima >>> import numpy as np >>> a = np.arange(10) The interval is left-closed and right-open, i.e., `[2, 8)`. Trim the array by keeping only values in the interval. >>> trima(a, limits=(2, 8), inclusive=(True, False)) masked_array(data=[--, --, 2, 3, 4, 5, 6, 7, --, --], mask=[ True, True, False, False, False, False, False, False, True, True], fill_value=999999) )NNFT)rJru unshare_maskr>r)rMlimits inclusive lower_lim upper_limlower_inupper_inrs rPr-r-HsF 1 ANNFl2#Y$XI  i- (I y. )I  i- (I y. )I &At HrRc Sn[R"U5nUR5 UcU$UupVSnUb!US:dUS:a[US-SUS3-5eUb!US:dUS:a[US-SUS3-5eUupUc3URn U"UR 5XVX5R U 5$[R"XCXXhU 5$) a Trims an array by masking some proportion of the data on each end. Returns a masked version of the input array. Parameters ---------- a : sequence Input array. limits : {None, tuple}, optional Tuple of the percentages to cut on each side of the array, with respect to the number of unmasked data, as floats between 0. and 1. Noting n the number of unmasked data before trimming, the (n*limits[0])th smallest data and the (n*limits[1])th largest data are masked, and the total number of unmasked data after trimming is n*(1.-sum(limits)). The value of one limit can be set to None to indicate an open interval. inclusive : {(True,True) tuple}, optional Tuple of flags indicating whether the number of data being masked on the left (right) end should be truncated (True) or rounded (False) to integers. axis : {None,int}, optional Axis along which to trim. If None, the whole array is trimmed, but its shape is maintained. cjUR5nUR5nU(aAU(a[X-5nO![[R"X-55n[ XSU'UbGU(aU[XR-5- nO$U[[R"XR-55- n[ XUS'U$r?)rrrrfroundr>) rM low_limitup_limit low_inclusive up_inclusiverrlowidxupidxs rP_trimr1Dtrimr.._trimr1Ds GGIiik Y[)RXXik23$A'6lO  C O+C 455#A%&kNrR=The proportion to cut from the %s should be between 0. and 1.rr< beginning(got rWend)rJrurrYrrLrr) rMrrrNrlolimuplimerrmsgloincupincshps rPr.r.s4" 1 ANN ~NU LF  2:Vk1eE7!4DDE E  2:Ve^eWA.>>? ?NU |gg %e:BB3GG""81ENNrRaZ Parameters ---------- a : sequence Input array limits : {None, tuple}, optional If `relative` is False, tuple (lower limit, upper limit) in absolute values. Values of the input array lower (greater) than the lower (upper) limit are masked. If `relative` is True, tuple (lower percentage, upper percentage) to cut on each side of the array, with respect to the number of unmasked data. Noting n the number of unmasked data before trimming, the (n*limits[0])th smallest data and the (n*limits[1])th largest data are masked, and the total number of unmasked data after trimming is n*(1.-sum(limits)) In each case, the value of one limit can be set to None to indicate an open interval. If limits is None, no trimming is performed inclusive : {(bool, bool) tuple}, optional If `relative` is False, tuple indicating whether values exactly equal to the absolute limits are allowed. If `relative` is True, tuple indicating whether the number of data being masked on each side should be rounded (True) or truncated (False). relative : bool, optional Whether to consider the limits as absolute values (False) or proportions to cut (True). axis : int, optional Axis along which to trim. c8U(a [XX$S9$[XUS9$)aL Trims an array by masking the data outside some given limits. Returns a masked version of the input array. %s Examples -------- >>> from scipy.stats.mstats import trim >>> z = [ 1, 2, 3, 4, 5, 6, 7, 8, 9,10] >>> print(trim(z,(3,8))) [-- -- 3 4 5 6 7 8 -- --] >>> print(trim(z,(0.1,0.2),relative=True)) [-- 2 3 4 5 6 7 8 -- --] rrrNrr)r.r-rMrrrelativerNs rPr*r*s!$QFFQ;;rRc[XU4X#S9$)aG Trims the smallest and largest data values. Trims the `data` by masking the ``int(proportiontocut * n)`` smallest and ``int(proportiontocut * n)`` largest values of data along the given axis, where n is the number of unmasked values before trimming. Parameters ---------- data : ndarray Data to trim. proportiontocut : float, optional Percentage of trimming (as a float between 0 and 1). If n is the number of unmasked values before trimming, the number of values after trimming is ``(1 - 2*proportiontocut) * n``. Default is 0.2. inclusive : {(bool, bool) tuple}, optional Tuple indicating whether the number of data being masked on each side should be rounded (True) or truncated (False). axis : int, optional Axis along which to perform the trimming. If None, the input array is first flattened. r)r.)rproportiontocutrrNs rPr+r+s2 ?$ 11rRc[U5R5SnUS:XaUS4nOUS:XaSU4nO [S5e[XXCS9$)a Trims the data by masking values from one tail. Parameters ---------- data : array_like Data to trim. proportiontocut : float, optional Percentage of trimming. If n is the number of unmasked values before trimming, the number of values after trimming is ``(1 - proportiontocut) * n``. Default is 0.2. tail : {'left','right'}, optional If 'left' the `proportiontocut` lowest values will be masked. If 'right' the `proportiontocut` highest values will be masked. Default is 'left'. inclusive : {(bool, bool) tuple}, optional Tuple indicating whether the number of data being masked on each side should be rounded (True) or truncated (False). Default is (True, True). axis : int, optional Axis along which to perform the trimming. If None, the input array is first flattened. Default is None. Returns ------- trimtail : ndarray Returned array of same shape as `data` with masked tail values. r<rNrz/The tail argument should be in ('left','right'))rrNr)rr TypeErrorr.)rrtailrrNrs rPr,r,!sT> t9?? Q D s{!$' (IJJ 4 EErRc[U[5(d[U[5(aX4nU(a[XX$S9R US9$[ XUS9R US9$)z@Returns the trimmed mean of the data along the given axis. %s rrr)rtrryr.rr-rs rPr/r/Ns^ ve $ $*VE*B*B!QyCHHdHSSQy9>>D>IIrRc[U[5(d[U[5(aX4nU(a [XX$S9nO [ XUS9nUR XES9$)aReturns the trimmed variance of the data along the given axis. %s ddof : {0,integer}, optional Means Delta Degrees of Freedom. The denominator used during computations is (n-ddof). DDOF=0 corresponds to a biased estimate, DDOF=1 to an un- biased estimate of the variance. rrr)rtrryr.r-rrMrrrrNrouts rPr2r2asQ ve $ $*VE*B*B!AyCAi8 777 ((rRc[U[5(d[U[5(aX4nU(a [XX$S9nO [ XUS9nUR XES9$)a(Returns the trimmed standard deviation of the data along the given axis. %s ddof : {0,integer}, optional Means Delta Degrees of Freedom. The denominator used during computations is (n-ddof). DDOF=0 corresponds to a biased estimate, DDOF=1 to an un- biased estimate of the variance. rrr)rtrryr.r-r^rs rPr0r0zsQ ve $ $*VE*B*B!AiBAi8 777 ''rRc |Sn[R"USSS9nUR5 Uc6URUSS9[R"UR U55- $[ U[5(d[ U[5(aX4nUupVSnUb!US:dUS:a[US -S US 3-5eUb!US:dUS:a[US -S US 3-5eUupUcU"UR5XVX5$URS :a[SUR-5e[R"XCUXVX5$)a Returns the standard error of the trimmed mean along the given axis. Parameters ---------- a : sequence Input array limits : {(0.1,0.1), tuple of float}, optional tuple (lower percentage, upper percentage) to cut on each side of the array, with respect to the number of unmasked data. If n is the number of unmasked data before trimming, the values smaller than ``n * limits[0]`` and the values larger than ``n * `limits[1]`` are masked, and the total number of unmasked data after trimming is ``n * (1.-sum(limits))``. In each case, the value of one limit can be set to None to indicate an open interval. If `limits` is None, no trimming is performed. inclusive : {(bool, bool) tuple} optional Tuple indicating whether the number of data being masked on each side should be rounded (True) or truncated (False). axis : int, optional Axis along which to trim. Returns ------- trimmed_stde : scalar or ndarray cUR5nUR5nU(a8U(a[X-5nO[R"X-5n[ XSU'Ub>U(aU[XR-5- nOU[R"XR-5- n[ XUS'XWXSU'XWS- XUS'UR SS9n U SU- U- [R"[U55-- $)zCReturns the standard error of the trimmed mean for a 1D input data.NrAr) rrrrfrr>r^rrs) rMrrrrrrrrwinstds rP_trimmed_stde_1D&trimmed_stde.._trimmed_stde_1Ds GGIiik Y[))+.$A'6lO  C O+BHHQZ00#A%&kNK.gv,uQw<ef+A!I+h.A?@@rRTrr2rArrrr<rrrWrraz>Array 'a' must be at most two dimensional, but got a.ndim = %d) rJrwrr^rrrtrryrYrLrhr) rMrrrNrrrrrrs rPr1r1sK:A* T*ANN ~uu$Au&rwwqwwt}'=== ve $ $*VE*B*B!NU LF  2:Vk1eE7!4DDE E  2:Ve^eWA.>>? ?NU  %eBB 66A:356VV<= =""#31#(u< ?? IrRc0[XUS9RUS9$)a Compute the trimmed mean. 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 operate. If None, compute over the whole array. Default is None. Returns ------- tmean : float Notes ----- For more details on `tmean`, see `scipy.stats.tmean`. Examples -------- >>> import numpy as np >>> from scipy.stats import mstats >>> a = np.array([[6, 8, 3, 0], ... [3, 9, 1, 2], ... [8, 7, 8, 2], ... [5, 6, 0, 2], ... [4, 5, 5, 2]]) ... ... >>> mstats.tmean(a, (2,5)) 3.3 >>> mstats.tmean(a, (2,5), axis=0) masked_array(data=[4.0, 5.0, 4.0, 2.0], mask=[False, False, False, False], fill_value=1e+20) rr)r-r)rMrrrNs rPr(r( s ` Y 7 < <$ < GGrRc$UR[5R5nUcCUR)R 5n[ R RU5U-US- - $[XUS9n[ R RXcUS9$)a@ Compute the trimmed variance This function computes the sample variance of an array of values, while ignoring values which are outside of given `limits`. Parameters ---------- a : array_like Array of values. limits : None or (lower limit, upper limit), optional Values in the input array less than the lower limit or greater than the upper limit will be ignored. When limits is None, then all values are used. Either of the limit values in the tuple can also be None representing a half-open interval. The default value is None. inclusive : (bool, bool), optional A tuple consisting of the (lower flag, upper flag). These flags determine whether values exactly equal to the lower or upper limits are included. The default value is (True, True). axis : int or None, optional Axis along which to operate. If None, compute over the whole array. Default is zero. ddof : int, optional Delta degrees of freedom. Default is 1. Returns ------- tvar : float Trimmed variance. Notes ----- For more details on `tvar`, see `scipy.stats.tvar`. rrr) r\ryrLrrrrfrJrr)rMrrrNrrrs rPr8r8@ stH A ~ffWMMOuuyy|a2&& Y ?B 5599R9 ..rRcz[X5up[XS4US45n[RR XB5$)a Compute the trimmed minimum 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 Notes ----- For more details on `tmin`, see `scipy.stats.tmin`. Examples -------- >>> import numpy as np >>> from scipy.stats import mstats >>> a = np.array([[6, 8, 3, 0], ... [3, 2, 1, 2], ... [8, 1, 8, 2], ... [5, 3, 0, 2], ... [4, 7, 5, 2]]) ... >>> mstats.tmin(a, 5) masked_array(data=[5, 7, 5, --], mask=[False, False, False, True], fill_value=999999) NF)rQr-rJminimumreduce)rM lowerlimitrNrrs rPr)r)m s<V1#GA qt$y%&8 9B ::  R &&rRc|[X5up[USU4SU45n[RR XB5$)a Compute the trimmed maximum This function computes the maximum value of an array along a given axis, while ignoring values larger than a specified upper limit. Parameters ---------- a : array_like array of values upperlimit : None or float, optional Values in the input array greater than the given limit will be ignored. When upperlimit is None, then all values are used. The default value is None. axis : int or None, optional Axis along which to operate. Default is 0. If None, compute over the whole array `a`. inclusive : {True, False}, optional This flag determines whether values exactly equal to the upper limit are included. The default value is True. Returns ------- tmax : float, int or ndarray Notes ----- For more details on `tmax`, see `scipy.stats.tmax`. Examples -------- >>> import numpy as np >>> from scipy.stats import mstats >>> a = np.array([[6, 8, 3, 0], ... [3, 9, 1, 2], ... [8, 7, 8, 2], ... [5, 6, 0, 2], ... [4, 5, 5, 2]]) ... ... >>> mstats.tmax(a, 4) masked_array(data=[4, --, 3, 2], mask=[False, True, False, False], fill_value=999999) NF)rQr-rJmaximumr)rM upperlimitrNrrs rPr'r' s>^1#GA q4$ui&8 9B ::  R &&rRc[R"U5R5nUc?[UR 55nUR X4S9[R "U5- $[UR5X5n[R "URX4S95nU[R "UR 55- $)a0 Compute the trimmed standard error of the mean. This function finds the standard error of the mean for given values, ignoring values outside the given `limits`. Parameters ---------- a : array_like array of values limits : None or (lower limit, upper limit), optional Values in the input array less than the lower limit or greater than the upper limit will be ignored. When limits is None, then all values are used. Either of the limit values in the tuple can also be None representing a half-open interval. The default value is None. inclusive : (bool, bool), optional A tuple consisting of the (lower flag, upper flag). These flags determine whether values exactly equal to the lower or upper limits are included. The default value is (True, True). axis : int or None, optional Axis along which to operate. If None, compute over the whole array. Default is zero. ddof : int, optional Delta degrees of freedom. Default is 1. Returns ------- tsem : float Notes ----- For more details on `tsem`, see `scipy.stats.tsem`. r) rJrurLryrr^rr-rfr)rMrrrNrrrsds rPr3r3 sF 1 A ~ !'') uu$u*2771:55 qwwy& ,B T- .B  # ##rRc Sn[X5upu[R"U[R"U5S9nUcU$[ U[ 5(d[ U[5(aX4nUupSn Ub!US:dUS:a[U S-SUS3-5eU b!U S:dU S:a[U S -SU S3-5eUupUc4URn U"UR5XXXu5RU 5$[R"XdXXXU5 $) aReturns a Winsorized version of the input array. The (limits[0])th lowest values are set to the (limits[0])th percentile, and the (limits[1])th highest values are set to the (1 - limits[1])th percentile. Masked values are skipped. Parameters ---------- a : sequence Input array. limits : {None, tuple of float}, optional Tuple of the percentages to cut on each side of the array, with respect to the number of unmasked data, as floats between 0. and 1. Noting n the number of unmasked data before trimming, the (n*limits[0])th smallest data and the (n*limits[1])th largest data are masked, and the total number of unmasked data after trimming is n*(1.-sum(limits)) The value of one limit can be set to None to indicate an open interval. inclusive : {(True, True) tuple}, optional Tuple indicating whether the number of data being masked on each side should be truncated (True) or rounded (False). inplace : {False, True}, optional Whether to winsorize in place (True) or to use a copy (False) axis : {None, int}, optional Axis along which to trim. If None, the whole array is trimmed, but its shape is maintained. nan_policy : {'propagate', 'raise', 'omit'}, optional Defines how to handle when input contains nan. The following options are available (default is 'propagate'): * 'propagate': allows nan values and may overwrite or propagate them * 'raise': throws an error * 'omit': performs the calculations ignoring nan values Notes ----- This function is applied to reduce the effect of possibly spurious outliers by limiting the extreme values. Examples -------- >>> import numpy as np >>> from scipy.stats.mstats import winsorize A shuffled array contains integers from 1 to 10. >>> a = np.array([10, 4, 9, 8, 5, 3, 7, 2, 1, 6]) The 10% of the lowest value (i.e., ``1``) and the 20% of the highest values (i.e., ``9`` and ``10``) are replaced. >>> winsorize(a, limits=[0.1, 0.2]) masked_array(data=[8, 4, 8, 8, 5, 3, 7, 2, 2, 6], mask=False, fill_value=999999) cxUR5nUR5nU(a*[R"[R"U55n U(ajU(a[ X-5n O+[R "X-5R[ 5n U(aUS:Xa[XW - S- 5n XU XSU 'UbtU(aU[ Xr-5- n O.U[R "Xr-5R[ 5- n U(aUS:XaXU S- XU W *'U$XU S- XU S'U$)NrrA) rrrf count_nonzerorrrr\r) rMrr low_include up_include contains_nanrrr nan_countrrs rP _winsorize1Dwinsorize.._winsorize1D; s GGIiik ((!5I Y]+)-077< f 4Vy[]3F nA'6lO  C --BHHQ\299#>> f 4+,^+<eYJ'("#uqy>!2ef+rRrrrr<rrrWr) rDrJrwrfr{rtrryrYrrLrr)rMrrinplacerNrrrrrrrrrs rPr:r: s'z2 -Q;L 01A ~ vu % %:fe+D+D!NU LF  2:Vk1eE7!4DDE E  2:Ve^eWA.>>? ?NU |ggAGGIuU(66=gcl C""Q = 88BGGIrvvUCD D ;;v  vvdTv*8>?1d.?xx~q$''@s-E%rc4[R"U[R"U5- 5S:a [S5eUS:XdUS:Xa[ UR 5nXB UR RS;aUR RO[Rn[U5S:XaU"US:XaS5$S5$US:Xa[R"XES9$[R"XES9$U/nUnUS:a1US-(a US- S- nOUS-nURU5 US:aM1UcURUS S 9OUnX- nUS S:XaUR!5n OUS-n US SS 2Hn U S-n U S-(dMX-n M U RU5$) Nr<z&All moment parameters must be integersrArrrroraTrr)rfrgrrYrrrprrrrsrJrrappendrr) rMrrNrrrpn_list current_n a_zero_meansrs rPrr s vvfrxx''(1,ABB {fkQWW  K !  4 "** u:?! 5 55 539Q;BGGE/ 7%5 7 !m1}&q[!O Q MM) $ !m/3lqvvdTv*h ":?  "AQABA1A1uu  vvd|rRc^[X5upURXS9URU5- $)a Compute the coefficient of variation. The coefficient of variation is the standard deviation divided by the mean. This function is equivalent to:: np.std(x, axis=axis, ddof=ddof) / np.mean(x) The default for ``ddof`` is 0, but many definitions of the coefficient of variation use the square root of the unbiased sample variance for the sample standard deviation, which corresponds to ``ddof=1``. Parameters ---------- a : array_like Input array. axis : int or None, optional Axis along which to calculate the coefficient of variation. Default is 0. If None, compute over the whole array `a`. ddof : int, optional Delta degrees of freedom. Default is 0. Returns ------- variation : ndarray The calculated variation along the requested axis. Notes ----- For more details about `variation`, see `scipy.stats.variation`. Examples -------- >>> import numpy as np >>> from scipy.stats.mstats import variation >>> a = np.array([2,8,4]) >>> variation(a) 0.5345224838248487 >>> b = np.array([2,8,3,4]) >>> c = np.ma.masked_array(b, mask=[0,0,1,0]) >>> variation(c) 0.5345224838248487 In the example above, it can be seen that this works the same as `scipy.stats.variation` except 'stats.mstats.variation' ignores masked array elements. r)rQr^r)rMrNrs rPr9r9 s/b1#GA 555 !!&&, ..rRcF[X5upURUSS9n[USXS9n[USXS9nU[R"UR 5R URU5-S-:*n[R"SS9 [R"USXTS -- 5nS S S 5 U(dU[RLaU[RLaURU5nU)US:-n U R5(a[R"X5n[R"X5n[R"X5n[R"US - U-5US - - U-US -- n [R "WX5 W$!,(df  N=f) a Computes the skewness of a data set. Parameters ---------- a : ndarray data 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. Returns ------- skewness : ndarray The skewness of values along an axis, returning 0 where all values are equal. Notes ----- For more details about `skew`, see `scipy.stats.skew`. Trrarrrallr<?Nrr)rQrrrffinforp resolutionsqueezerrJrr>rrextractrplace) rMrNbiasrm2m3zerovalsr can_correctnvals rPr"r" sN21"GA 66$6 &D At 'B At 'B 288BHH%004<<3EEI ID  "xxa#g. # D )b .A GGDMeq1uo ??   ;*AK,BK,B77AcE19%qu-b0S8D HHT; - K # "s F F cd[X5upURUSS9n[USXS9n[USXS9nU[R"UR 5R URU5-S-:*n[R"SS9 [R"USXeS -- 5nS S S 5 U(dU[RLaU[RLaURU5n U)U S :-n U R5(a[R"X5n [R"X5n[R"X5nS U S- - U S - - X-S - U-US -- S U S - S --- -n [R"WXS-5 U(aWS - $W$!,(df  N=f)aq Computes 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. Returns ------- kurtosis : array The kurtosis of values along an axis. If all values are equal, return -3 for Fisher's definition and 0 for Pearson's definition. Notes ----- For more details about `kurtosis`, see `scipy.stats.kurtosis`. Trrarrrr(r<rNrrrAr@)rQrrrfr+rpr,r-rrJrr>rrr.r/) rMrNfisherr0rr1m4r3r4rr5r6s rPrr0 spJ1#GA 66$6 &D At 'B At 'B 288BHH%004<<3EEI ID  "xxa#g. # D )b .A GGDMeq1uo ??   ;*AK,BK,B!9ac?QSWbLS$8AaC#:$EFD HHT;S 1 ax  # "s F!! F/DescribeResult)nobsminmaxrvarianceskewnessrc4[X5upURU5n[RR XS9[R R XS94nUR U5nURXS9n[XUS9n[XUS9n [XEXgX5$)a Computes several descriptive statistics of the passed array. Parameters ---------- a : array_like Data array axis : int or None, optional Axis along which to calculate statistics. Default 0. If None, compute over the whole array `a`. ddof : int, optional degree of freedom (default 0); note that default ddof is different from the same routine in stats.describe bias : bool, optional If False, then the skewness and kurtosis calculations are corrected for statistical bias. Returns ------- nobs : int (size of the data (discarding missing values) minmax : (int, int) min, max mean : float arithmetic mean variance : float unbiased variance skewness : float biased skewness kurtosis : float biased kurtosis Examples -------- >>> import numpy as np >>> from scipy.stats.mstats import describe >>> ma = np.ma.array(range(6), mask=[0, 0, 0, 1, 1, 1]) >>> describe(ma) DescribeResult(nobs=np.int64(3), minmax=(masked_array(data=0, mask=False, fill_value=999999), masked_array(data=2, mask=False, fill_value=999999)), mean=np.float64(1.0), variance=np.float64(0.6666666666666666), skewness=masked_array(data=0., mask=False, fill_value=1e+20), kurtosis=np.float64(-1.5)) rr)r0) rQrrJrrrrrr"rr:) rMrNrr0rmmrrskkurts rPrrq sl1#GA  A **  A  )2::+<+._stdemed_1D sxwwt() I  !A#rA" $55a8 9cTA#Y&A./rRFTrrazDArray 'data' must be at most two dimensional, but got data.ndim = %d)rJrwrhrYr)rrNrGs rP stde_medianrI sj0 88DuD 1D 4  99q=68< BC C"";d;;rRSkewtestResultc[X5upUcUR5nSn[X5nURU5n[R "U5S:a"[ S[R "U5-5eU[R"US-US--SUS- -- 5-nSXD-S U--S - -US--US--US - US --US --US--- nS[R"SUS- -5-nS[R"S[R"U5-5- n[R"S US- - 5n [R"US:HSU5nU[R"XY- [R"XY- S-S-5-5-n [RRRU [R U5n [#U SU S5$)a# Tests whether the skew is different from the normal distribution. Parameters ---------- a : array_like The data to be tested axis : int or None, optional Axis along which statistics are calculated. Default is 0. If None, compute over the whole array `a`. 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 : array_like The computed z-score for this test. pvalue : array_like A p-value for the hypothesis test Notes ----- For more details about `skewtest`, see `scipy.stats.skewtest`. r<zFskewtest is not valid with less than 8 samples; %i samples were given.rAr@rar@Frr rrrb)rQrLr"rrfrrYrJrlogrrrrrrBrrJ) rMrNrkb2rrbeta2W2deltarsZrs rPr#r# sH1#GA | GGI aB  A vvay1} VVAY '( ( RWWqsQqSkc1Q3i0 11A !#bd(2+ ! $ac *#!}ac/BAaC/H IE bggaqk" "B bggc"&&*n% %E GGCAJ E aAA bffQWrww!|A~6677A [[ " " . .q-2D2Dk RF !B% ,,rRKurtosistestResultc Z[X5upURUS9n[R"U5S:a"[ S[R"U5-5e[R"U5S:a,[ R "S[R"U5-SS9 [XSS 9nS US - -US -- nS U-US - -US- -US -US--US--US--- nXE- [R"U5- nSX3-SU-- S--US-US--- [R"SUS--US--X3S- -US- -- 5-nSSU- S U- [R"S SUS-- -5---n S S SU -- - n S U[R"SU S- - 5--n [RRU 5(a [XS:H'O U S:Xa[n [RRU S:[R"S S U - - U - S5[R"S S U - - *U - S5*5n X- [R"SSU -- 5- n [RR R#U [$R&U5n[)U SUS5$)a Tests whether a dataset has normal kurtosis Parameters ---------- a : array_like array of the sample data axis : int or None, optional Axis along which to compute test. Default is 0. If None, compute over the whole array `a`. 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 : array_like The computed z-score for this test. pvalue : array_like The p-value for the hypothesis test Notes ----- For more details about `kurtosistest`, see `scipy.stats.kurtosistest`. rrzJkurtosistest requires at least 5 observations; %i observations were given.z=kurtosistest only valid for n>=20 ... continuing anyway, n=%ira) stacklevelF)r8r@rAg8@rrrrMrPrQg @rErrr<gUUUUUU?rb)rQrrfrrYwarningswarnrrJr isMaskedArrayr>rpowerrrrrrBrrX)rMrNrkrrSEvarb2r sqrtbeta1Aterm1r*term2rWrs rPrr sH1#GA TA vvay1} VVAY '( ( vvay2~ KbffUVi W !% (B QqS QqSA FAbDM1Q3 AaC!B$<1#5qs#; >> import numpy as np >>> from scipy.stats.mstats import mquantiles >>> a = np.array([6., 47., 49., 15., 42., 41., 7., 39., 43., 40., 36.]) >>> mquantiles(a) array([ 19.2, 40. , 42.8]) Using a 2D array, specifying axis and limit. >>> data = np.array([[ 6., 7., 1.], ... [ 47., 15., 2.], ... [ 49., 36., 3.], ... [ 15., 39., 4.], ... [ 42., 40., -999.], ... [ 41., 41., -999.], ... [ 7., -999., -999.], ... [ 39., -999., -999.], ... [ 43., -999., -999.], ... [ 40., -999., -999.], ... [ 36., -999., -999.]]) >>> print(mquantiles(data, axis=0, limit=(0, 50))) [[19.2 14.6 1.45] [40. 37.5 2.5 ] [42.8 40.05 3.55]] >>> data[:, 2] = -999. >>> print(mquantiles(data, axis=0, limit=(0, 50))) [[19.200000000000003 14.6 --] [40.0 37.5 --] [42.800000000000004 40.05 --]] c`[R"UR55n[U5nUS:Xa5[R "[R "[U5[S9SS9$US:Xa7[R "[R"X2R5[S9$XB-U-n[R"URSUS- 55R[5nXV- RSS5nSU- X6S- R5-XsUR5--$)Nr<roTrqrAr)rfrFrrsrJrwrxryresizerr?floorrr\rtolist)rrprralephrgammas rP _quantiles1D mquantiles.._quantiles1D s GGDOO% & F 688BHHSV59E E !V88BIIa1? ?q HHUZZ1Q3' ( / / 4q#5!qSLLN++eahhjM.AAArRFrrazArray should be 2D at most !r<rATr) rJrwrhrr>rrf atleast_1drur) rMralphapbetaprNlimitrqrrrnrs rPrr| sH B 88AE "D yy1}677 1X_a9 (.t$ $% bjj&'ABvIeO$$A DQ''  |4A >>rRc tUS:dUS:a[SUS35e[XS- /X4USS9R5$)zCalculate the score at the given 'per' percentile of the sequence a. For example, the score at per=50 is the median. This function is a shortcut to mquantile r<gY@z4The percentile should be between 0. and 100. ! (got rW)rrtrurvrN)rYrr-)rperrvrtrus rPrr sK aS4ZOPSuTUVWW dd(F! ++2795rRcl[R"USS9RSS5nUR5n[R "UR [S9nSXCS&[R"SUS-5U- US-U- U- - X@RSS 9SU'[R"X@RS 9$) a Returns plotting positions (or empirical percentile points) for the data. Plotting positions are defined as ``(i-alpha)/(n+1-alpha-beta)``, where: - i is the rank order statistics - n is the number of unmasked values along the given axis - `alpha` and `beta` are two parameters. Typical values for `alpha` and `beta` are: - (0,1) : ``p(k) = k/n``, linear interpolation of cdf (R, type 4) - (.5,.5) : ``p(k) = (k-1/2.)/n``, piecewise linear function (R, type 5) - (0,0) : ``p(k) = k/(n+1)``, Weibull (R type 6) - (1,1) : ``p(k) = (k-1)/(n-1)``, in this case, ``p(k) = mode[F(x[k])]``. That's R default (R type 7) - (1/3,1/3): ``p(k) = (k-1/3)/(n+1/3)``, then ``p(k) ~ median[F(x[k])]``. The resulting quantile estimates are approximately median-unbiased regardless of the distribution of x. (R type 8) - (3/8,3/8): ``p(k) = (k-3/8)/(n+1/4)``, Blom. The resulting quantile estimates are approximately unbiased if x is normally distributed (R type 9) - (.4,.4) : approximately quantile unbiased (Cunnane) - (.35,.35): APL, used with PWM - (.3175, .3175): used in scipy.stats.probplot Parameters ---------- data : array_like Input data, as a sequence or array of dimension at most 2. alpha : float, optional Plotting positions parameter. Default is 0.4. beta : float, optional Plotting positions parameter. Default is 0.4. Returns ------- positions : MaskedArray The calculated plotting positions. FrrArror<Nrrrq) rJrwrrrfrxrXryrrrt)rrsbetarplposs rPrr sT 88Du % - -a 3D A HHTYYe ,EE"I+-99Q!+>> import numpy as np >>> from scipy import stats >>> a = np.arange(20).reshape(5,4) >>> print(stats.mstats.sem(a)) [2.8284271247461903 2.8284271247461903 2.8284271247461903 2.8284271247461903] Find standard error across the whole array, using n degrees of freedom: >>> print(stats.mstats.sem(a, axis=None, ddof=0)) 1.2893796958227628 rr)rQrr^rJr)rMrNrrr%s rPr r [ sC^1#GA TA 4#bggaj0A HrRF_onewayResultc[U6n[U5nUR5nUS-R5UR5S-[ U5- - nURS5UR S5UR 5- S--R5nXE- nUS- nX2- nU[ U5- n U[ U5- n X- n [ R"XxU 5n [X5$)aZ Performs a 1-way ANOVA, returning an F-value and probability given any number of groups. From Heiman, pp.394-7. Usage: ``f_oneway(*args)``, where ``*args`` is 2 or more arrays, one per treatment group. Returns ------- statistic : float The computed F-value of the test. pvalue : float The associated p-value from the F-distribution. rarrA) rrsrrryrrcfdtrcr) r~rngroupsrsstotssbgsswgdfbgdfwgmsbmswfrs rPrr s"  D$iG ::D uT{ C uT{ C A ==Q 'D ! ""rRFriedmanchisquareResultc[U6R[5n[U5nUS:a[ SU-S-5e[ R "[USS9S5nUR[LaJ[ R"U5nUR5RUS5R[5nO URnUR up$UR"Vs/sHn[%U5PM nn[&R("UVVs/sHupxUR*S:dMUPM snn5n SU S-U - R-5[XBS-U- -5- - n [&R,"UR-S5XBS--S- - S -5n U S -XB-US--- S -U - n [/U [0R2R5XS- 55$s snfs snnf) aFriedman Chi-Square is a non-parametric, one-way within-subjects ANOVA. This function calculates the Friedman Chi-square test for repeated measures and returns the result, along with the associated probability value. Each input is considered a given group. Ideally, the number of treatments among each group should be equal. If this is not the case, only the first n treatments are taken into account, where n is the number of treatments of the smallest group. If a group has some missing values, the corresponding treatments are masked in the other groups. The test statistic is corrected for ties. Masked values in one group are propagated to the other groups. Returns ------- statistic : float the test statistic. pvalue : float the associated p-value. rzLess than 3 groups (%i): z%the Friedman test is NOT appropriate.r<rrrArrarr)rr\ryrsrYrJ masked_valuesrrtr? mask_colsrrrr=r}rrrrfrwrXrrrBrr) r~rrrankedrrowrrrrtie_correctionrchisqs rPrr s.   $ $U +D D A1u4q8@AB B  ht!4a 8F ||6!f%""$,,Qr277@ LLEQ,2HH5HS|C HG5 8879741affqjQ79 :D$'$,++-eA!tAvJ.???N 666::b>AsGBJ.2 3D 3JQqS "R ' 6E "5#0#5#5#8#8!#D FF69s"GG (G BrunnerMunzelResultc[R"U5R5R[5n[R"U5R5R[5n[ U5n[ U5nUS:XdUS:Xa([ [R[R5$[[R"X455nUSUnXdXE-n[R"U5n [R"U5n [U5n [U5n [R"U 5n [R"U 5n[R"[R"X{- U - U -S55nXS- -n[R"[R"X- U - U-S55nUUS- -nXE-X- -nUXE-[R"XO-UU--5--nUS:Xa[R"XO-UU--S5n[R"XO-S5US- - nU[R"UU-S5US- - - nUU- n[R R#UU5nO1US:Xa [R$R#U5nO ['S5eUS:XaO>> from scipy.stats.mstats import brunnermunzel >>> import numpy as np >>> x1 = [1, 2, np.nan, np.nan, 1, 1, 1, 1, 1, 1, 2, 4, 1, 1] >>> x2 = [3, 3, 4, 3, 1, 2, 3, 1, 1, 5, 4] >>> brunnermunzel(x1, x2) BrunnerMunzelResult(statistic=1.4723186918922935, pvalue=0.15479415300426624) # may vary r<rrArjnormalz&distribution should be 't' or 'normal'r_r^r`raz6alternative should be 'less', 'greater' or 'two-sided')rJrurrr=rsrrfrrrrrr_rrBrjrrrYr)rrrk distributionrrrankcrankcxrankcy rankcx_mean rankcy_meanrankxranky rankx_mean ranky_meanSxSywbfndf_numerdf_denomrirns rPr;r; sj 1   "''0A 1   "''0A QB QB Qw"'"26626622 R^^QE* +E 1R[F be_F''&/K''&/K QKE QKEJJ +5 BCH IBq&LB +5 BCH IB"q&LB 7k/ 0DRW"r' 12 22Ds88BGb2g-s388BGS)R!V4BHHR"Wc*b1f55   OO  b )  !    " "4 ( 46 6i   E  # 1Q3x  DF F tQ ''rRr)NF)r<)r<T)NTN propagater`)r`)TFrr`r?)Ngffffff?separate)N hierarchical)r<r`)r<Tr`)T)rbr`r)r`r)NTT)NrN)NrFN)皙?rN)rleftrN)皙?rrArATN)rrTNr<)rrN)Nrr<rA)Nr<T)NrFNrrr)r<TT)r<r<T))g?rg?皙?rNrb)rbrr)rr)r<rA)r`rj)t__doc____all__numpyrfr=numpy.marJr>r?rrr\ collectionsr@rBscipy._lib._utilrCrDscipy._lib._bunchrE scipy.specialrcscipy.stats._stats_pyrrr_stats_mstats_commonrFr&rur%rwrQrUr\rmrrrrrrrrrrr$rrr rYrrrxr!rr4r5rr6rr7rrrr r rr r rr-r.trimdocr*r+r,trim1r/r2r0r1rr(r8r)r'r3r:rrr9r"rr:rrIrJr#rXrrfrrrrrrr rrrrrr;rbrRrPrs 2# "=/))   ,<~* Z1h-P` &7 8 !.HB$ $ i9X?J%Xv@F?E&|~=@""8;EF0+fOdC?L63r,,E-:M,JLq1B<<,.EF8-v 46MND1N02IJ>BBF~?B 50,f 42 j,.EF#B%%>%<>-F`!!68OPc(rR