
    (ph?                         S r / SQrSSKrSSKJrJr  SSKJr  SSKJr  SSK	J
r  SSKJrJrJrJr  SS	 jrSS
 jrSS jr  SS jrSS jrSS jrSS jrSS jrSS jrSS jrg)zB
Additional statistics functions with support for masked arrays.

)
compare_medians_mshdquantileshdmedianhdquantiles_sdidealfourthsmedian_cihsmjcimquantiles_cimjrshtrimmed_mean_ci    N)float64ndarray)MaskedArray   )_mstats_basic)normbetatbinomc                 t   S n[         R                  " U S[        S9n [        R                  " [        R
                  " U5      5      nUb  U R                  S:X  a
  U" XU5      nO@U R                  S:  a  [        SU R                  -  5      e[         R                  " XBXU5      n[         R                  " USS9$ )at  
Computes quantile estimates with the Harrell-Davis method.

The quantile estimates are calculated as a weighted linear combination
of order statistics.

Parameters
----------
data : array_like
    Data array.
prob : sequence, optional
    Sequence of probabilities at which to compute the quantiles.
axis : int or None, optional
    Axis along which to compute the quantiles. If None, use a flattened
    array.
var : bool, optional
    Whether to return the variance of the estimate.

Returns
-------
hdquantiles : MaskedArray
    A (p,) array of quantiles (if `var` is False), or a (2,p) array of
    quantiles and variances (if `var` is True), where ``p`` is the
    number of quantiles.

See Also
--------
hdquantiles_sd

Examples
--------
>>> import numpy as np
>>> from scipy.stats.mstats import hdquantiles
>>>
>>> # Sample data
>>> data = np.array([1.2, 2.5, 3.7, 4.0, 5.1, 6.3, 7.0, 8.2, 9.4])
>>>
>>> # Probabilities at which to compute quantiles
>>> probabilities = [0.25, 0.5, 0.75]
>>>
>>> # Compute Harrell-Davis quantile estimates
>>> quantile_estimates = hdquantiles(data, prob=probabilities)
>>>
>>> # Display the quantile estimates
>>> for i, quantile in enumerate(probabilities):
...     print(f"{int(quantile * 100)}th percentile: {quantile_estimates[i]}")
25th percentile: 3.1505820231763066 # may vary
50th percentile: 5.194344084883956
75th percentile: 7.430626414674935

c                 4   [         R                  " [         R                  " U R                  5       R	                  [
        5      5      5      nUR                  n[         R                  " S[        U5      4[        5      nUS:  a#  [         R                  Ul        U(       a  U$ US   $ [         R                  " US-   5      [        U5      -  n[        R                  n[!        U5       He  u  pU" XdS-   U	-  US-   SU	-
  -  5      n
U
SS U
SS -
  n[         R"                  " X5      nXSU4'   [         R"                  " XU-
  S-  5      USU4'   Mg     US   USUS:H  4'   US   USUS:H  4'   U(       a$  [         R                  =USUS:H  4'   USUS:H  4'   U$ US   $ )zGComputes the HD quantiles for a 1D array. Returns nan for invalid data.   r   r   N)npsqueezesort
compressedviewr   sizeemptylenr   nanflatarangefloatr   cdf	enumeratedot)dataprobvarxsortednhdvbetacdfip_wwhd_means                M/var/www/html/venv/lib/python3.13/site-packages/scipy/stats/_mstats_extras.py_hd_1Dhdquantiles.<locals>._hd_1DP   sw   **RWWT__%6%;%;G%DEFLLXXqTmW-q5ffBG	a5LIIacNU1X%((t_EQqS!GacAaC[1B12CR AffQ(GqsGffQ1 45BqsG % #1:1dai<"2;1dai<24&&8Bq$!)|r!TQY,/I!u    Fcopydtyper   r   DArray 'data' must be at most two dimensional, but got data.ndim = %dr;   )
maarrayr   r   
atleast_1dasarrayndim
ValueErrorapply_along_axisfix_invalid)r)   r*   axisr+   r7   r2   results          r6   r   r      s    h< 88DuG4D
bjj&'A$))q.%99q= 68<		B C C$$V4C@>>&u--r9   c                 :    [        U S/XS9nUR                  5       $ )a  
Returns the Harrell-Davis estimate of the median along the given axis.

Parameters
----------
data : ndarray
    Data array.
axis : int, optional
    Axis along which to compute the quantiles. If None, use a flattened
    array.
var : bool, optional
    Whether to return the variance of the estimate.

Returns
-------
hdmedian : MaskedArray
    The median values.  If ``var=True``, the variance is returned inside
    the masked array.  E.g. for a 1-D array the shape change from (1,) to
    (2,).

      ?)rG   r+   )r   r   )r)   rG   r+   rH   s       r6   r   r   |   s!    , se$8F>>r9   c                 l   S n[         R                  " U S[        S9n [        R                  " [        R
                  " U5      5      nUc	  U" X5      nO?U R                  S:  a  [        SU R                  -  5      e[         R                  " X2X5      n[         R                  " USS9R                  5       $ )a  
The standard error of the Harrell-Davis quantile estimates by jackknife.

Parameters
----------
data : array_like
    Data array.
prob : sequence, optional
    Sequence of quantiles to compute.
axis : int, optional
    Axis along which to compute the quantiles. If None, use a flattened
    array.

Returns
-------
hdquantiles_sd : MaskedArray
    Standard error of the Harrell-Davis quantile estimates.

See Also
--------
hdquantiles

c                    [         R                  " U R                  5       5      n[        U5      n[         R                  " [        U5      [
        5      nUS:  a  [         R                  Ul        [         R                  " U5      [        US-
  5      -  n[        R                  n[        U5       H  u  pxU" XSU-  USU-
  -  5      n	U	SS U	SS -
  n
[         R                  " U5      n[         R                  " XSS -  5      USS& USS=== [         R                  " U
SSS2   USSS2   -  5      SSS2   -  sss& [         R                  " UR!                  5       US-
  -  5      XG'   M     U$ )z%Computes the std error for 1D arrays.r   r   Nr   r   )r   r   r   r!   r    r   r"   r#   r$   r%   r   r&   r'   
zeros_likecumsumsqrtr+   )r)   r*   r,   r-   hdsdvvr0   r1   r2   r3   r4   mx_s               r6   _hdsd_1D hdquantiles_sd.<locals>._hdsd_1D   s3   ''$//+,LxxD	7+q5DIYYq\E!A#J&((t_EQqS!QqS'*B12CR A --(CiiCRL 01CGH		!DbD'GEQrEN":;DbDAAHggcggi1q512DG % r9   Fr:   r   r=   r>   )r?   r@   r   r   rA   rB   rC   rD   rE   rF   ravel)r)   r*   rG   rS   r2   rH   s         r6   r   r      s    02 88DuG4D
bjj&'A$"99q= 68<		B C C$$XT=>>&u-3355r9   c                 H   [         R                  " U SS9n [        R                  " XX$S9nUR	                  U5      n[        R
                  " XX$S9nUR                  U5      S-
  n[        R                  " SUS-  -
  U5      n	[        R                  " XiU-  -
  XiU-  -   45      $ )a3  
Selected confidence interval of the trimmed mean along the given axis.

Parameters
----------
data : array_like
    Input data.
limits : {None, tuple}, optional
    None or a two item tuple.
    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. If ``n``
    is the number of unmasked data before trimming, then
    (``n * limits[0]``)th smallest data and (``n * limits[1]``)th
    largest data are masked.  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.

    Defaults to (0.2, 0.2).
inclusive : (2,) tuple of boolean, optional
    If relative==False, tuple indicating whether values exactly equal to
    the absolute limits are allowed.
    If relative==True, tuple indicating whether the number of data being
    masked on each side should be rounded (True) or truncated (False).

    Defaults to (True, True).
alpha : float, optional
    Confidence level of the intervals.

    Defaults to 0.05.
axis : int, optional
    Axis along which to cut. If None, uses a flattened version of `data`.

    Defaults to None.

Returns
-------
trimmed_mean_ci : (2,) ndarray
    The lower and upper confidence intervals of the trimmed data.

Fr>   )limits	inclusiverG   r          @)
r?   r@   mstatstrimrmeantrimmed_stdecountr   ppfr   )
r)   rW   rX   alpharG   trimmedtmeantstdedftppfs
             r6   r   r      s    T 88Du%Dll4)OGLLEYQE	t	q	 B5558BD88U%Z'Ez)9:;;r9   c                    S n[         R                  " U SS9n U R                  S:  a  [        SU R                  -  5      e[        R
                  " [        R                  " U5      5      nUc  U" X5      $ [         R                  " X2X5      $ )aT  
Returns the Maritz-Jarrett estimators of the standard error of selected
experimental quantiles of the data.

Parameters
----------
data : ndarray
    Data array.
prob : sequence, optional
    Sequence of quantiles to compute.
axis : int or None, optional
    Axis along which to compute the quantiles. If None, use a flattened
    array.

c                 v   [         R                  " U R                  5       5      n U R                  n[         R                  " U5      U-  S-   R                  [        5      n[        R                  n[         R                  " [        U5      [        5      n[         R                  " SUS-   [        S9U-  nUSU-  -
  n[        U5       Hn  u  pU" XiS-
  X)-
  5      U" XyS-
  X)-
  5      -
  n
[         R                  " X5      n[         R                  " XS-  5      n[         R                  " XS-  -
  5      XX'   Mp     U$ )NrJ   r   )r<   g      ?r   )r   r   r   r   r@   astypeintr   r&   r    r!   r   r$   r'   r(   rO   )r)   r2   r-   r*   r0   mjxyr1   mWC1C2s                r6   _mjci_1Dmjci.<locals>._mjci_1D  s    wwt()IIa#%--c2((XXc$i)IIa!7+a/1Ht_EQA#ac"WQs13%77AB'"BGGBQJ'BE	 %
 	r9   Fr>   r   r=   )r?   r@   rC   rD   r   rA   rB   rE   )r)   r*   rG   rq   r2   s        r6   r   r     s~       88Du%Dyy1} 248II> ? 	? 	bjj&'A  ""84;;r9   c                     [        USU-
  5      n[        R                  " SUS-  -
  5      n[        R                  " XSSUS9n[        XUS9nXTU-  -
  XTU-  -   4$ )a}  
Computes the alpha confidence interval for the selected quantiles of the
data, with Maritz-Jarrett estimators.

Parameters
----------
data : ndarray
    Data array.
prob : sequence, optional
    Sequence of quantiles to compute.
alpha : float, optional
    Confidence level of the intervals.
axis : int or None, optional
    Axis along which to compute the quantiles.
    If None, use a flattened array.

Returns
-------
ci_lower : ndarray
    The lower boundaries of the confidence interval.  Of the same length as
    `prob`.
ci_upper : ndarray
    The upper boundaries of the confidence interval.  Of the same length as
    `prob`.

r   rY   r   )alphapbetaprG   rG   )minr   r_   rZ   
mquantilesr   )r)   r*   r`   rG   zxqsmjs          r6   r	   r	   5  sc    6 q5y!EU2XA			4aqt	DB
t
%CSL"3w,''r9   c                     S n[         R                  " U SS9n Uc
  U" X5      nU$ U R                  S:  a  [        SU R                  -  5      e[         R                  " X2X5      nU$ )a  
Computes the alpha-level confidence interval for the median of the data.

Uses the Hettmasperger-Sheather method.

Parameters
----------
data : array_like
    Input data. Masked values are discarded. The input should be 1D only,
    or `axis` should be set to None.
alpha : float, optional
    Confidence level of the intervals.
axis : int or None, optional
    Axis along which to compute the quantiles. If None, use a flattened
    array.

Returns
-------
median_cihs
    Alpha level confidence interval.

c                    [         R                  " U R                  5       5      n [        U 5      n[	        USU-
  5      n[        [        R                  " US-  US5      5      n[        R                  " X#-
  US5      [        R                  " US-
  US5      -
  nUSU-
  :  a;  US-  n[        R                  " X#-
  US5      [        R                  " US-
  US5      -
  n[        R                  " X#-
  S-
  US5      [        R                  " X2S5      -
  nUS-
  U-   XE-
  -  nX#-
  U-  [        X2SU-  -
  U-  -   5      -  nXpU   -  SU-
  XS-
     -  -   XpX#-
  S-
     -  SU-
  XU-
     -  -   4nU$ )Nr   rY   rJ   r   )
r   r   r   r!   rw   ri   r   _ppfr&   r%   )	r)   r`   r-   kgkgkkIlambdlimss	            r6   _cihs_1Dmedian_cihs.<locals>._cihs_1Dn  s_   wwt()IE1U7#

58Q,-YYqs1S!EIIac!C$88%<FA13q%		!A#a(<<BiiAa$uyyS'99!Ve^bh'	E!1uai-001g5$s) 3313q5k!QuWdQ3i$779r9   Fr>   r   r=   )r?   r@   rC   rD   rE   )r)   r`   rG   r   rH   s        r6   r   r   W  st    . 88Du%D$& M 99q= 68<		B C C$$XTAMr9   c                 @   [         R                  " XS9[         R                  " XS9pC[        R                  " XS9[        R                  " XS9pe[        R
                  " X4-
  5      [         R                  " US-  US-  -   5      -  nS[        R                  " U5      -
  $ )a  
Compares the medians from two independent groups along the given axis.

The comparison is performed using the McKean-Schrader estimate of the
standard error of the medians.

Parameters
----------
group_1 : array_like
    First dataset.  Has to be of size >=7.
group_2 : array_like
    Second dataset.  Has to be of size >=7.
axis : int, optional
    Axis along which the medians are estimated. If None, the arrays are
    flattened.  If `axis` is not None, then `group_1` and `group_2`
    should have the same shape.

Returns
-------
compare_medians_ms : {float, ndarray}
    If `axis` is None, then returns a float, otherwise returns a 1-D
    ndarray of floats with a length equal to the length of `group_1`
    along `axis`.

Examples
--------

>>> from scipy import stats
>>> a = [1, 2, 3, 4, 5, 6, 7]
>>> b = [8, 9, 10, 11, 12, 13, 14]
>>> stats.mstats.compare_medians_ms(a, b, axis=None)
1.0693225866553746e-05

The function is vectorized to compute along a given axis.

>>> import numpy as np
>>> rng = np.random.default_rng()
>>> x = rng.random(size=(3, 7))
>>> y = rng.random(size=(3, 8))
>>> stats.mstats.compare_medians_ms(x, y, axis=1)
array([0.36908985, 0.36092538, 0.2765313 ])

References
----------
.. [1] McKean, Joseph W., and Ronald M. Schrader. "A comparison of methods
   for studentizing the sample median." Communications in
   Statistics-Simulation and Computation 13.6 (1984): 751-773.

rv   r   r   )	r?   medianrZ   stde_medianr   absrO   r   r&   )group_1group_2rG   med_1med_2std_1std_2rn   s           r6   r   r     s|    d ii2BIIg4PE((<((< 
u}q5!8(; <<Atxx{?r9   c                     S n[         R                  " XS9R                  [        5      n Uc  U" U 5      $ [         R                  " X!U 5      $ )a  
Returns an estimate of the lower and upper quartiles.

Uses the ideal fourths algorithm.

Parameters
----------
data : array_like
    Input array.
axis : int, optional
    Axis along which the quartiles are estimated. If None, the arrays are
    flattened.

Returns
-------
idealfourths : {list of floats, masked array}
    Returns the two internal values that divide `data` into four parts
    using the ideal fourths algorithm either along the flattened array
    (if `axis` is None) or along `axis` of `data`.

c                 $   U R                  5       n[        U5      nUS:  a   [        R                  [        R                  /$ [	        US-  S-   S5      u  p4[        U5      nSU-
  XS-
     -  XAU   -  -   nX#-
  nSU-
  X   -  XAUS-
     -  -   nXW/$ )N   g      @g?r   )r   r!   r   r"   divmodri   )r)   rk   r-   jhqlor   qups           r6   _idfidealfourths.<locals>._idf  s    OOFq5FF266?"qte|A&FsAcFlQtV#EsADj1qsV8#zr9   rv   )r?   r   r   r   rE   )r)   rG   r   s      r6   r   r     sD    ,
 774#((5DDz""4t44r9   c                    [         R                  " U SS9n Uc  U nO*[        R                  " [        R                  " U5      5      nU R
                  S:w  a  [        S5      eU R                  5       n[        U SS9nSUS   US	   -
  -  US
-  -  nU SS2S4   USSS24   U-   :*  R                  S	5      nU SS2S4   USSS24   U-
  :  R                  S	5      nXV-
  SU-  U-  -  $ )a  
Evaluates Rosenblatt's shifted histogram estimators for each data point.

Rosenblatt's estimator is a centered finite-difference approximation to the
derivative of the empirical cumulative distribution function.

Parameters
----------
data : sequence
    Input data, should be 1-D. Masked values are ignored.
points : sequence or None, optional
    Sequence of points where to evaluate Rosenblatt shifted histogram.
    If None, use the data.

Fr>   Nr   z#The input array should be 1D only !rv   g333333?r   r   皙?rY   )
r?   r@   r   rA   rB   rC   AttributeErrorr^   r   sum)r)   pointsr-   rr   nhinlos          r6   r
   r
     s      88Du%D~rzz&12yyA~BCC

AT%AquQqTzQY&A$<6$q&>A--
2
21
5C$<&a.1,,
1
1!
4CG1Qr9   )g      ?rJ   g      ?NF)r   F)r   N))r   r   )TT皙?N)r   r   N)r   N)N)__doc____all__numpyr   r   r   numpy.mar?   r    r   rZ   scipy.stats.distributionsr   r   r   r   r   r   r   r   r   r	   r   r   r   r
    r9   r6   <module>r      sl     "    % : :].@4<6~ 7B%)0<f*<Z(D0f6r%5P r9   