Ë
    ÜÍ:jùH  ã                   ó¢
  — d dl Zd dlZd dlmZmZ d dlmZ d dlmZ d dl	m
Z d dl	mZmZmZ d dlmZ d dlmZmZ d d	lmZ ej,                  j/                  d
ddg«      ej,                  j/                  dddg«      d„ «       «       Zej,                  j/                  d
ddg«      ej,                  j/                  ddddddgg«      ej,                  j/                  dddg«      d„ «       «       «       Zej,                  j/                  dddg«      d„ «       Zd„ Zd„ Zej,                  j/                  d
ddg«      ej,                  j/                  dg d¢«      d„ «       «       Zd „ Zej,                  j/                  d
ddg«      ej,                  j/                  dg d!¢«      d"„ «       «       Zej,                  j/                  d#dd$g«      ej,                  j/                  d
ddg«      ej,                  j/                  dddddg d!¢g«      d%„ «       «       «       Z ej,                  j/                  ddg d&¢g«      ej,                  j/                  d
ddg«      d'„ «       «       Z!ej,                  j/                  d( e«       «      ej,                  j/                  d) ejD                  d*«       ejF                  d+«      dfd,„  ejH                  d«      jK                  ejF                  «      dfd-„ d.„ d/fd0„ d1„ d2d/gf ejL                  g d3¢«       ejL                  g d4¢«      d f ejL                  ejN                  ejN                  d d5d6dg«       ejL                  g d7¢«      d f ejL                  g d3¢«       ejL                  g d7¢ejF                  ¬8«      d2d/gfg«      d9„ «       «       Z(ej,                  j/                  d
ddg«      ej,                  j/                  d:d+d;g«      d<„ «       «       Z)ej,                  j/                  d=d>ejN                  dgfdd>gejN                  ejN                  gd?d@ggfg«      dA„ «       Z*ej,                  jW                  e edB«      k  dC¬D«      ej,                  j/                  dEg dF¢«      ej,                  j/                  d
ddg«      ej,                  j/                  dGddg«      dH„ «       «       «       «       Z,ej,                  jW                  e edB«      k  dI¬D«      ej,                  j/                  dEg dF¢«      ej,                  j/                  d
ddg«      ej,                  j/                  dGddg«      dJ„ «       «       «       «       Z-y)Ké    N)Úassert_allcloseÚassert_array_equal)Úapprox)Úconfig_context©Údevice)Úget_namespaceÚmove_toÚ)yield_namespace_device_dtype_combinations)Ú_array_api_for_tests)Ú
np_versionÚparse_version)Ú_weighted_percentileÚaverageTFÚsizeé
   é   c                 ó
  — t        j                  | «      }t        j                  |«      }t        ||d|¬«      }| dz  dk(  r|du r|t        j                  |«      k7  sJ ‚yt        |«      t        j                  |«      k(  sJ ‚y)au  Ensure `_weighted_percentile` matches `median` when expected.

    With unit `sample_weight`, `_weighted_percentile` should match the median except
    when `average=False` and the number of samples is even.
    For an even array and `average=False`, `percentile_rank=50` gives the lower
    of the two 'middle' values, that are averaged when calculating the `median`.
    é2   ©r   é   r   FN)ÚnpÚarangeÚ	ones_liker   Úmedianr   )r   r   ÚyÚsample_weightÚscores        ús/home/mcse/projects/srt_converter/srt-converter-venv/lib/python3.12/site-packages/sklearn/utils/tests/test_stats.pyÚ'test_weighted_percentile_matches_medianr       sr   € ô 	�	‰	�$‹€AÜ—L‘L “O€Mä   M°2¸wÔG€Eð ˆa�x�1‚}˜ EÑ)ØœŸ	™	 !›Ò$Ð$Ñ$ä�e‹}¤§	¡	¨!£Ò,Ð,Ñ,ó    Úpercentile_ranké   é#   é=   é   é/   c                 ó
  — t         j                  j                  | «      }|j                  d|¬«      }t        j                  |«      }t        ||||¬«      }|rd}nd}t        |«      t        j                  |||¬«      k(  sJ ‚y)aë  Check `_weighted_percentile` with unit weights is correct.

    `average=True` results should be the same as `np.percentile`'s
    'averaged_inverted_cdf'.
    `average=False` results should be the same as `np.percentile`'s
    'inverted_cdf'.
    Note `np.percentile` is the same as `np.quantile` except `q` is in range [0, 100].

    We parametrize through different `percentile_rank` and `size` to
    ensure we get cases where `g=0` and `g>0` (see Hyndman and Fan 1996 for details).
    r#   ©r   r   Úaveraged_inverted_cdfÚinverted_cdf)ÚmethodN)r   ÚrandomÚRandomStateÚrandintr   r   r   Ú
percentile)	Úglobal_random_seedr   r"   r   Úrngr   Úswr   r,   s	            r   Ú&test_weighted_percentile_matches_numpyr4   (   st   € ô" �)‰)×
Ñ
Ð 2Ó
3€CØ�‰�B˜TˆÓ"€AÜ	�‰�a‹€Bä   B¨ÀÔI€EáØ(‰àˆä�%‹=œBŸM™M¨!¨_ÀVÔLÒLÐLÑLr!   r   éd   c                 óÔ   — t        j                  ddgddgg«      }t        j                  ddgddgg«      }t        ||| d¬«      }t        d«      D ]  }||   t	        d	«      k(  rŒJ ‚ y
)aÃ  Check `j+1` index is clipped to max, when `average=True`.

    `percentile_plus_one_indices` can exceed max index when `percentile_indices`
    is already at max index.
    Note that when `g` (Hyndman and Fan) / `fraction_above` is greater than 0,
    `j+1` (Hyndman and Fan) / `percentile_plus_one_indices` is calculated but
    never used, so it does not matter what this value is.
    When percentile of percentile rank 100 falls exactly on the last value in the
    `weighted_cdf`, `g=0` and `percentile_indices` is at max index. In this case
    we set `percentile_plus_one_indices` to be max index as well, so the result is
    the average of 2x the max index (i.e. last value of `weighted_cdf`).
    r   é   gš™™™™™¹?gš™™™™™É?r   é   Tr   g      ð?N)r   Úarrayr   Úranger   )r"   r   r3   r   Úidxs        r   Ú*test_weighted_percentile_plus_one_clip_maxr<   G   ss   € ô  	�‰�1�a�&˜1˜a˜&Ð!Ó"€AÜ	�‰�C˜�:  1˜vÐ&Ó	'€BÜ   B¨ÀÔF€EÜ�Q‹xò )ˆØ�S‰zœV C›[Ó(Ð(Ð(ñ)r!   c                  óÒ   — t        j                  dt         j                  ¬«      } t        j                  dt         j                  ¬«      }t	        | |d«      }t        |«      dk(  sJ ‚y)zJCheck `weighted_percentile` with unit weights and all 0 values in `array`.éf   ©Údtyper   r   N)r   ÚzerosÚfloat64Úonesr   r   )r   r3   r   s      r   Útest_weighted_percentile_equalrD   ^   sJ   € ä
�‰�œBŸJ™JÔ'€AÜ	�‰�œBŸJ™JÔ	'€BÜ   B¨Ó+€EÜ�%‹=˜AÒÐÑr!   c                  ó    — t        j                  d«      } t        j                  d«      }t        | |d«      }t        j                  |«      sJ ‚y)zICheck `weighted_percentile` with all weights equal to 0 returns `np.nan`.r   r   N)r   r   rA   r   Úisnan)r   r3   Úvalues      r   Ú)test_weighted_percentile_all_zero_weightsrH   f   s:   € ä
�	‰	�"‹€AÜ	�‰�"‹€BÜ   B¨Ó+€EÜ�8‰8�EŒ?Ð‰?r!   zpercentile_rank, expected_value))r   r   )r   r8   )r5   r&   c                 ó@  — t        j                  g d¢«      }t        j                  g d¢«      }t        t        j                  ||f«      j                  t        j                  ||f«      j                  || ¬«      }t        d«      D ]  }t        ||   «      |k(  rŒJ ‚ y)a‹  Check leading, trailing and middle 0 weights behave correctly.

    Check that leading zero-weight observations are ignored when `percentile_rank=0`.
    See #20528 for details.
    Check that when `average=True` and the `j+1` ('plus one') index has sample weight
    of 0, it is ignored. Also check that trailing zero weight observations are ignored
    (e.g., when `percentile_rank=100`).
    )r   r7   r   r8   é   r&   é   )r   r   r7   r7   r   r7   r   r   r   N)r   r9   r   ÚvstackÚTr:   r   )r   r"   Úexpected_valuer   r3   rG   r;   s          r   Ú,test_weighted_percentile_ignores_zero_weightrO   n   s‡   € ô 	�‰Ò&Ó'€AÜ	�‰Ò'Ó	(€Bä Ü
�	‰	�1�a�&Ó×ÑœRŸY™Y¨¨B xÓ0×2Ñ2°OÈWô€Eô �Q‹xò 4ˆÜ�e˜C‘jÓ! ^Ó3Ð3Ð3ñ4r!   c                  ól   — t        ddgddgd¬«      } t        g d¢g d¢d¬«      }t        | «      |k(  sJ ‚y)z=Check zero weights just before `max_index` handled correctly.r7   r8   Tr   )r7   r   r8   )r8   r   r8   N)r   r   )Úscore_without_zerosÚscore_with_zeross     r   Ú4test_weighted_percentile_average_zero_weight_plateaurS   …   s=   € ä.°°1¨v¸¸1°vÀtÔLÐÜ+ªI²yÈ$ÔOÐÜÐ%Ó&Ð*:Ò:Ð:Ñ:r!   )r#   r$   r   r%   c                 ó”  — t         j                  j                  | «      }|j                  dd¬«      }|j	                  dd¬«      }t        j
                  ||«      }t        ||||¬«      }t        |t        j                  |«      ||¬«      }|t        |«      k(  sJ ‚|dk(  r'|r$|t        t        j                  |«      «      k(  sJ ‚yyy)z?Check integer weights give the same result as repeating values.r#   r   r)   r&   r   r   N)
r   r-   r.   r/   ÚchoiceÚrepeatr   r   r   r   )	r1   r"   r   r2   ÚxÚweightsÚ
x_repeatedÚpercentile_weightsÚpercentile_repeateds	            r   Ú3test_weighted_percentile_frequency_weight_semanticsr\   Œ   sÄ   € ô �)‰)×
Ñ
Ð 2Ó
3€CØ�‰�B˜RˆÓ €AØ�j‰j˜ ˆjÓ$€Gä—‘˜1˜gÓ&€JÜ-Ø	ˆ7�O¨WôÐô /Ø”B—L‘L Ó,¨oÀwôÐð ¤Ð(;Ó!<Ò<Ð<Ð<à˜"Ò¡Ø!¤V¬B¯I©I°jÓ,AÓ%BÒBÐBÑBð ")Ðr!   Úconstanté   c                 óô   — t         j                  j                  | «      }|j                  dd¬«      }|j	                  dd¬«      }||z  }t        ||||¬«      }t        ||||¬«      }	|t        |	«      k(  sJ ‚y)zßCheck multiplying weights by a constant does not change the result.

    Note scale invariance does not always hold when multiplying by a
    float due to cumulative sum numerical error (which grows proportional to n).
    r#   r)   r&   r   N)r   r-   r.   r/   rU   r   r   )
r1   r"   r   r]   r2   rW   rX   Úweights_multipliedr0   Úpercentile_multipliers
             r   Ú,test_weighted_percentile_constant_multiplierrb   £   sƒ   € ô �)‰)×
Ñ
Ð 2Ó
3€CØ�‰�B˜RˆÓ €AØ�j‰j˜ ˆjÓ$€GØ  8Ñ+Ðä% a¨°/È7ÔS€JÜ0Ø	Ð˜¸ôÐð œÐ 5Ó6Ò6Ð6Ñ6r!   )r#   r$   r   c                 óö  — t         j                  j                  | «      }|j                  dd¬«      }|j	                  dd¬«      }|j                  dd¬«      }t        j
                  ||f«      j                  }t        ||||¬«      }t        |t        «      r’g }	|D ]K  }
|	j                  t        |j                  d   «      D �cg c]  }t        |dd…|f   ||
|¬«      ‘Œ c}«       ŒM t        j                  |	d¬	«      }|j                  |j                  d   t        |«      fk(  sZJ ‚t        |j                  d   «      D �cg c]  }t        |dd…|f   |||¬«      ‘Œ }}|j                  |j                  d   fk(  sJ ‚t        ||«       |j	                  dd¬«      }t        j
                  ||f«      j                  }t        ||||¬«      }t        |t        «      r™g }	|D ]R  }
|	j                  t        |j                  d   «      D �cg c]  }t        |dd…|f   |dd…|f   |
|¬«      ‘Œ! c}«       ŒT t        j                  |	d¬	«      }|j                  |j                  d   t        |«      fk(  saJ ‚t        |j                  d   «      D �cg c]  }t        |dd…|f   |dd…|f   ||¬«      ‘Œ! }}|j                  |j                  d   fk(  sJ ‚t        ||«       yc c}w c c}w c c}w c c}w )
zECheck `_weighted_percentile` behaviour is correct when `array` is 2D.r   r)   r&   r#   )r"   r   r7   Néÿÿÿÿ)Úaxis)r   r-   r.   r/   rU   rL   rM   r   Ú
isinstanceÚlistÚappendr:   ÚshapeÚstackÚlenr   )r1   r"   r   r2   Úx1Úw1Úx2Úx_2dÚwpÚp_listÚprÚiÚp_axis_0Úw2Úw_2ds                  r   Útest_weighted_percentile_2drw   º   s÷  € ô
 �)‰)×
Ñ
Ð 2Ó
3€CØ	�‰�R˜bˆÓ	!€BØ	�‰�A˜BˆÓ	€Bà	�‰�R˜bˆÓ	!€BÜ�9‰9�b˜"�XÓ× Ñ €Dä	Øˆb /¸7ô
€Bô �/¤4Ô(ØˆØ!ò 	ˆBØ�M‰Mô
 # 4§:¡:¨a¡=Ó1ö	ð ô )ØšQ ˜T™
 B¸ÀGöòõð	ô —8‘8˜F¨Ô,ˆØ�x‰x˜DŸJ™J q™M¬3¨Ó+?Ð@Ò@Ð@Ð@ô ˜4Ÿ:™: a™=Ó)ö	
ð ô !Ø’Q˜�T‘
˜B°Èöð
ˆð 
ð �x‰x˜DŸJ™J q™MÐ+Ò+Ð+Ð+ä�B˜Ô!ð 
�‰�A˜BˆÓ	€BÜ�9‰9�b˜"�XÓ× Ñ €Dä	Øˆd O¸Wô
€Bô �/¤4Ô(ØˆØ!ò 	ˆBØ�M‰Mô
 # 4§:¡:¨a¡=Ó1ö	ð ô )ØšQ ˜T™
 Dª¨A¨¡JÀÈGöòõð	ô —8‘8˜F¨Ô,ˆØ�x‰x˜DŸJ™J q™M¬3¨Ó+?Ð@Ò@Ð@Ð@ô ˜4Ÿ:™: a™=Ó)ö	
ð ô !Ø’Q˜�T‘
˜D¢ A ™J¸ÐQXöð
ˆð 
ð �x‰x˜DŸJ™J q™MÐ+Ò+Ð+Ð+ä�B˜Õ!ùòiùò
ùò,ùò
s   ÃK'
ÅK,È$K1
Ê$K6z(array_namespace, device_name, dtype_namezdata, weights, percentileé*   r7   c                 ó$   — | j                  d«      S ©Nr   ©Úrand©r2   s    r   ú<lambda>r~     s   € �S—X‘X˜b“\€ r!   c                 ó&   — | j                  dd«      S )Nr   r8   r{   r}   s    r   r~   r~     s   € �S—X‘X˜b !“_€ r!   c                 ó^   — | j                  d«      j                  t        j                  «      S rz   ©r|   Úastyper   Úfloat32r}   s    r   r~   r~     s   € °#·(±(¸2³,×2EÑ2EÄbÇjÁjÓ2Q€ r!   éK   c                 ó&   — | j                  dd«      S ©Nr#   r8   r{   r}   s    r   r~   r~     s   € ˜Ÿ™  Q›€ r!   c                 ó`   — | j                  dd«      j                  t        j                  «      S r†   r�   r}   s    r   r~   r~     s   € ˜Ÿ™  Q›×.Ñ.¬r¯z©zÓ:€ r!   é   )r   r7   r   r8   rJ   r&   )r   r   r7   r7   r7   r   r8   rJ   )r   r7   r7   r7   r7   r   r?   c                 ó.  — t        |||«      \  }}|j                  d|¬«      }	|j                  d|¬«      }
|dk(  r<|j                  |j	                  |	|
«      |	k(  «      rt        j                  d|› �«       t        j                  j                  | «      }t        |«      r ||«      n|}t        |«      r ||«      n|}|j                  |«      }t        |||«      }|j                  ||¬«      }|j                  ||¬«      }t        d¬«      5  t        |||«      }t        |«      t        |«      k(  sJ ‚t!        |«      d   t!        |«      d   k(  sJ ‚t#        |t        d¬«      }d	d	d	«       j$                  |j$                  k(  sJ ‚|j&                  |j&                  k(  sJ ‚t)        ||«       |d
k(  r3|j$                  |j$                  cxk(  rt        j*                  k(  sJ ‚ J ‚y	|j$                  t        j,                  k(  sJ ‚y	# 1 sw Y   Œ£xY w)zECheck `_weighted_percentile` gives consistent results with array API.r7   r   r   zxp.nextafter is broken on T)Úarray_api_dispatchÚcpu)Úxpr   Nrƒ   )r   rA   rC   ÚallÚ	nextafterÚpytestÚxfailr   r-   r.   Úcallabler‚   r   Úasarrayr   Úarray_devicer	   r
   r@   ri   r   rƒ   rB   )r1   Úarray_namespaceÚdevice_nameÚ
dtype_nameÚdatarX   r0   rŒ   r   ÚzeroÚoner2   ÚX_npÚ
weights_npÚ	result_npÚX_xpÚ
weights_xpÚ	result_xpÚresult_xp_nps                      r   Ú.test_weighted_percentile_array_api_consistencyr¡     sã  € ôR & o°{ÀJÓO�J€Bˆð
 �8‰8�A˜fˆ8Ó%€DØ
�'‰'�!˜Fˆ'Ó
#€CØ�Q‚˜2Ÿ6™6 "§,¡,¨t°SÓ"9¸TÑ"AÔBÜ�‰Ð1°&°Ð:Ô;ä
�)‰)×
Ñ
Ð 2Ó
3€CÜ  œ‰4�Œ9¨D€DÜ!)¨'Ô!2‘˜”¸€Jà�;‰;�zÓ"€Dä$ T¨:°zÓB€Ià�:‰:�d 6ˆ:Ó*€DØ—‘˜J¨v�Ó6€Jä	¨4Ô	0ñ ?Ü(¨¨z¸:ÓFˆ	Ü˜IÓ&¬,°tÓ*<Ò<Ð<Ð<Ü˜YÓ'¨Ñ*¬m¸DÓ.AÀ!Ñ.DÒDÐDÐDÜ˜y¬R¸Ô>ˆ÷	?ð ×Ñ §¡Ò0Ð0Ð0Ø×Ñ §¡Ò0Ð0Ð0Ü�I˜|Ô,ð �YÒØ×!Ñ! Y§_¡_ÔB¼¿
¹
ÒBÐBÑBÐBÑBà×!Ñ!¤R§Z¡ZÒ/Ð/Ñ/÷?ð ?ús   ÄAHÈHÚsample_weight_ndimr   c                 ó²  — t         j                  j                  | «      }|j                  dd«      }t         j                  | |j                  |j
                  Ž dk  <   t        j                  |«      }|dk(  r|j                  ddd¬«      }n|j                  ddd	¬«      }t        ||d
|¬«      }t        |j
                  d   «      D �cg c]  }||dd…|f    |f   ‘Œ }	}|j                  dk(  rMt        j                  ||j
                  d   «      j                  |j
                  d   |j
                  d   «      }t        |j
                  d   «      D �cg c]  }||dd…|f    |f   ‘Œ }
}t        j                  t        |j
                  d   «      D �cg c]  }t        |	|   |
|   d
|¬«      ‘Œ c}«      }t        ||«       yc c}w c c}w c c}w )a>  Test `_weighted_percentile` ignores NaNs.

    Calling `_weighted_percentile` on an array with nan values returns the same
    results as calling `_weighted_percentile` on a filtered version of the data.
    We test both with sample_weight of the same shape as the data and with
    one-dimensional sample_weight.
    r5   r   ç      à?r   r7   rK   )r5   r   r)   )r5   é   r   Nr   )r   r-   r.   r|   Únanri   rF   r/   r   r:   ÚndimrV   Úreshaper9   r   )r1   r¢   r   r2   Úarray_with_nansÚnan_maskr   ÚresultsÚcolÚfiltered_arrayÚfiltered_weightsÚexpected_resultss               r   Ú%test_weighted_percentile_nan_filteredr°   T  sç  € ô �)‰)×
Ñ
Ð 2Ó
3€CØ—h‘h˜s BÓ'€OÜ>@¿f¹f€O�H�C—H‘H˜o×3Ñ3Ð4°sÑ:Ñ;Ü�x‰x˜Ó(€Hà˜QÒØŸ™ A q¨y˜Ó9‰àŸ™ A q¨v˜Ó6ˆô # ?°MÀ2ÈwÔW€Gô
 ˜×.Ñ.¨qÑ1Ó2öàð 	˜¢! S &Ñ)Ð)¨3Ð.Ó/ð€Nð ð ×Ñ˜QÒÜŸ	™	 -°×1FÑ1FÀqÑ1IÓJ×RÑRØ×!Ñ! !Ñ$ o×&;Ñ&;¸AÑ&>ó
ˆô :?¸×?TÑ?TÐUVÑ?WÓ9XöØ25ˆ�x¢ 3 Ñ'Ð'¨Ð,Ó-ðÐð ô —x‘xô
 ˜_×2Ñ2°1Ñ5Ó6ö		
ð ô !Ø˜sÑ#Ð%5°cÑ%:¸BÈöò	
óÐô Ð'¨Õ1ùò+ùòùò
	
s   ÃG
ÅGÆGzpercentile_rank, expectedéZ   g       @g      @c           	      óÆ  — t        j                  t         j                  dgt         j                  dgt         j                  t         j                  gt         j                  t         j                  gt         j                  dgt         j                  t         j                  gg«      }t        j                  |«      }t	        ||| «      }t        j
                  ||d¬«      sJ ‚y)zCCheck that nans are ignored in general, except for all NaN columns.r&   r7   r   T)Ú	equal_nanN)r   r9   r¦   r   r   Úarray_equal)r"   Úexpectedr9   rX   Úvaluess        r   Ú'test_weighted_percentile_all_nan_columnr·   ‡  sž   € ô �H‰Hä�V‰V�QˆKÜ�V‰V�QˆKÜ�V‰V”R—V‘VÐÜ�V‰V”R—V‘VÐÜ�V‰V�QˆKÜ�V‰V”R—V‘VÐð	
ó	€Eô �l‰l˜5Ó!€GÜ! %¨°/ÓB€Fô
 �>‰>˜& (°dÕ;Ð;Ñ;r!   z2.0z2np.quantile only accepts weights since version 2.0)Úreasonr0   )éB   r   r   Úuniform_weightc                 óš  — |r|st        j                  d«       t        j                  j	                  |«      }|j                  dd«      }|r+t        j                  |«      |j                  ddd¬«      z  }n|j                  ddd¬«      }t        ||| |¬«      }t        j                  || dz  |s|nd	|rd
ndd¬«      }t        ||«       y	)zICheck `_weighted_percentile` is equivalent to `np.quantile` with weights.zHnp.quantile does not support weights with method='averaged_inverted_cdf'r   r5   r7   rK   r)   ©r   r5   r   Nr*   r+   r   ©rX   r,   re   )r�   Úskipr   r-   r.   r|   r   r/   r   Úquantiler   )	r0   r   rº   r1   r2   r9   r   Úpercentile_weighted_percentileÚpercentile_numpy_quantiles	            r   Ú,test_weighted_percentile_like_numpy_quantilerÂ   ¤  sÈ   € ñ ‘~Ü�‰ØVô	
ô �)‰)×
Ñ
Ð 2Ó
3€CØ�H‰H�R˜Ó€EÙÜŸ™ UÓ+¨c¯k©k¸!¸QÀQ¨kÓ.GÑG‰àŸ™ A q¨y˜Ó9ˆä%9Øˆ}˜j°'ô&Ð"ô !#§¡ØØ�SÑÙ%3‘¸Ù*1Ñ&°~Øô!Ðô Ð5Ð7PÕQr!   z5np.nanquantile only accepts weights since version 2.0c                 óô  — |r|st        j                  d«       t        j                  j	                  |«      }|j                  dd«      }t        j                  | |j
                  |j                  Ž dk  <   |r+t        j                  |«      |j                  ddd¬«      z  }n|j                  ddd¬«      }t        ||| |¬	«      }t        j                  || dz  |s|nd
|rdndd¬«      }t        ||«       y
)zICheck `_weighted_percentile` equivalent to `np.nanquantile` with weights.zKnp.nanquantile does not support weights with method='averaged_inverted_cdf'r   r5   r¤   r7   rK   r)   r¼   r   Nr*   r+   r   r½   )r�   r¾   r   r-   r.   r|   r¦   ri   r   r/   r   Únanquantiler   )	r0   r   rº   r1   r2   r©   r   rÀ   Úpercentile_numpy_nanquantiles	            r   Ú/test_weighted_percentile_like_numpy_nanquantilerÆ   Ê  sû   € ñ ‘~Ü�‰ð-ô	
ô
 �)‰)×
Ñ
Ð 2Ó
3€CØ—h‘h˜r 3Ó'€OÜ>@¿f¹f€O�H�C—H‘H˜o×3Ñ3Ð4°sÑ:Ñ;ÙÜŸ™ _Ó5¸¿¹ØØØð 9Dó 9
ñ 
‰ð Ÿ™ A q¨y˜Ó9ˆä%9Ø˜¨
¸Gô&Ð"ô $&§>¡>ØØ�SÑÙ%3‘¸Ù*1Ñ&°~Øô$Ð ô Ð5Ð7SÕTr!   ).Únumpyr   r�   Únumpy.testingr   r   r   Úsklearn._configr   Úsklearn.utils._array_apir   r“   r	   r
   r   Úsklearn.utils.estimator_checksr   Úsklearn.utils.fixesr   r   Úsklearn.utils.statsr   ÚmarkÚparametrizer    r4   r<   rD   rH   rO   rS   r\   rb   rw   rƒ   Úint32rC   r‚   r9   r¦   r¡   r°   r·   ÚskipifrÂ   rÆ   © r!   r   ú<module>rÓ      sb  ðÛ Û ß =Ý å *Ý ;÷ñ õ
 @ß 9Ý 4ð ‡�×Ñ˜ T¨5 MÓ2Ø‡�×Ñ˜ " b Ó*ñ-ó +ó 3ð-ð( ‡�×Ñ˜ T¨5 MÓ2Ø‡�×ÑÐ*¨R°°R¸!¸R¸Ð,AÓBØ‡�×Ñ˜ " b Ó*ñMó +ó Có 3ðMð8 ‡�×ÑÐ*¨R°¨IÓ6ñ)ó 7ð)ò,òð ‡�×Ñ˜ T¨5 MÓ2Ø‡�×ÑÐ:Ò<WÓXñ4ó Yó 3ð4ò*;ð ‡�×Ñ˜ T¨5 MÓ2Ø‡�×ÑÐ*Ò,<Ó=ñCó >ó 3ðCð* ‡�×Ñ˜ a¨ VÓ,Ø‡�×Ñ˜ T¨5 MÓ2Ø‡�×ÑÐ*¨R°°R¸Ò=MÐ,NÓOñ7ó Pó 3ó -ð7ð( ‡�×ÑÐ*¨R²Ð,>Ó?Ø‡�×Ñ˜ T¨5 MÓ2ñF"ó 3ó @ðF"ðR ‡�×ÑØ.Ù-Ó/óð ‡�×ÑØð 
ˆ�‰�B‹˜˜Ÿ™ !› bÐ)á	! 7 2§7¡7¨2£;×#5Ñ#5°b·h±hÓ#?ÀÐDá	$Ñ&QÐSUÐVñ (Ù:Ø�ˆHð	
ð 
ˆ�‰Ò$Ó	% x r§x¡xÒ0BÓ'CÀQÐGà	ˆ�‰�2—6‘6˜2Ÿ6™6 1 a¨¨AÐ.Ó	/°°·±Ò:LÓ1MÈqÐQð ˆB�H‰HÒ'Ó(ØˆB�H‰HÒ'¨r¯x©xÔ8Ø�ˆHð	
ð%óñ6-0ó7ó	ð>-0ð` ‡�×Ñ˜ T¨5 MÓ2Ø‡�×ÑÐ-°°1¨vÓ6ñ.2ó 7ó 3ð.2ðb ‡�×ÑØà	ˆb�f‰f�aˆ[ÐØ
ˆbˆ�R—V‘V˜RŸV™VÐ$ s¨C jÐ1Ð2ðóñ<óð<ð, ‡�×ÑØ‘˜uÓ%Ñ%Ø?ð ó ð ‡�×Ñ˜¢|Ó4Ø‡�×Ñ˜ U¨D MÓ2Ø‡�×ÑÐ)¨E°4¨=Ó9ñRó :ó 3ó 5ó	ðRð> ‡�×ÑØ‘˜uÓ%Ñ%ØBð ó ð ‡�×Ñ˜¢|Ó4Ø‡�×Ñ˜ U¨D MÓ2Ø‡�×ÑÐ)¨E°4¨=Ó9ñ"Uó :ó 3ó 5ó	ñ"Ur!   