
    Wh 1                        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
mZmZ d dl	mZ d dlmZ d dlmZmZ d d	lmZmZ d
 Zd Zd Zd Zd Zd Zd Zd Zd Zd Z ejB                  jE                  d e             ejB                  jE                  d ejF                  d       ejH                  d      dfd  ejJ                  d      jM                  ejH                        dfd d dfd d df ejN                  g d        ejN                  g d!      d f ejN                  ejP                  ejP                  d d"d#d$g       ejN                  g d%      d f ejN                  g d        ejN                  g d%ejH                  &      dfg      d'               Z)ejB                  jE                  d(dd)g      d*        Z*d+ Z+ejB                  jY                  e ed,      k  d-.      ejB                  jE                  d/g d0      d1               Z-ejB                  jY                  e ed,      k  d2.      ejB                  jE                  d/g d0      d3               Z.y)4    N)assert_allcloseassert_array_equal)approx)config_context)_convert_to_numpyget_namespace)yield_namespace_device_dtype_combinationsdevice)_array_api_for_tests)
np_versionparse_version)_averaged_weighted_percentile_weighted_percentilec                      t        j                  g d      } t        j                  g d      }t        | |d      }|t        j                  |       k(  sJ y )Nr                  )r   r   r   r   r   r   2   )nparrayr   medianyswscores      X/var/www/html/jupyter_env/lib/python3.12/site-packages/sklearn/utils/tests/test_stats.pytest_averaged_weighted_medianr!      sD    
#$A	$	%B)!R4EBIIaL       c                     t         j                  j                  |       }|j                  dd      }t        j                  d      }t        ||d      }|t        j                  |dd      k(  sJ y )N   
   sizeaveraged_inverted_cdf)method)r   randomRandomStaterandintonesr   
percentile)global_random_seedrngr   r   r   s        r    !test_averaged_weighted_percentiler1      s`    
))

 2
3CBR A	B)!R4EBMM!R0GHHHHr"   c                      t        j                  g d      } t        j                  g d      }d}t        | ||      }t        | ||      }||k(  sJ y )N)r   r   r   )r   r   r   r   )r   r   r   r   )r   r   qscore_averagedr   s        r    %test_averaged_and_weighted_percentiler5   &   sM    
A	)	B
A21b!<N B*EU"""r"   c                     t        j                  dt         j                        } d| dd d| dd d| d	<   d
| d<   t        j                  dt         j                        }d|d	<   t	        | |d      }t        |      d
k(  sJ y)zCCheck `weighted_percentile` on artificial data with obvious median.f   dtyper   Nr   r   ii r           )r   emptyfloat64r-   r   r   r   r   values      r    test_weighted_percentiler@   1   s{    
BJJ'AAcrFAcdGAbEAbE	BJJ	'BBrF B+E%=Ar"   c                      t        j                  dt         j                        } | j                  d       t        j                  dt         j                        }t        | |d      }t        |      dk(  sJ y)z8Check `weighted_percentile` with all weights equal to 1.r7   r8   r;   r   r   Nr   r<   r=   fillr-   r   r   r   s      r    test_weighted_percentile_equalrD   >   sU    
BJJ'AFF3K	BJJ	'B B+E%=Ar"   c                     t        j                  dt         j                        } | j                  d       t        j                  dt         j                        }|j                  d       t        | |d      }t        |      dk(  sJ y)z8Check `weighted_percentile` with all weights equal to 0.r7   r8   g      ?r;   r   NrB   r>   s      r    $test_weighted_percentile_zero_weightrF   G   s`    
BJJ'AFF3K	BJJ	'BGGCL B+E%=Cr"   c                     t        j                  g d      } t        j                  g d      }t        | |d      }t        |      dk(  sJ t        | |d      }t        |      dk(  sJ t        | |d      }t        |      dk(  sJ y	)
zCheck `weighted_percentile(percentile_rank=0)` behaves correctly.

    Ensures that (leading)zero-weight observations ignored when `percentile_rank=0`.
    See #20528 for details.
    r   r   r   r   r   r   r   r   r   r   r   d   r   N)r   r   r   r   r>   s      r    4test_weighted_percentile_zero_weight_zero_percentilerJ   Q   s     	#$A	$	%B B*E%=A B+E%=A B,E%=Ar"   c                    t         j                  j                  |       }|j                  dd      }t        j                  |j
                        }t        j                  |      }t        ||      }|t        |      k(  sJ y)a  Checks `_weighted_percentile(percentile_rank=50)` is the same as `np.median`.

    `sample_weights` are all 1s and the number of samples is odd.
    When number of samples is odd, `_weighted_percentile` always falls on a single
    observation (not between 2 values, in which case the lower value would be taken)
    and is thus equal to `np.median`.
    For an even number of samples, this check will not always hold as (note that
    for some other percentile methods it will always hold). See #17370 for details.
    r%      r&   N)	r   r*   r+   r,   r-   shaper   r   r   )r/   r0   xweightsr   w_medians         r    "test_weighted_median_equal_weightsrQ   c   si     ))

 2
3CBR AggaggGYYq\F#Aw/HVH%%%%r"   c                    t         j                  j                  |       }|j                  dd      }|j	                  dd      }t        j
                  ||      }t        j                  |      }t        ||      }|t        |      k(  sJ y )Nr$   r%   r&   r   )	r   r*   r+   r,   choicerepeatr   r   r   )r/   r0   rN   rO   x_manualr   rP   s          r    $test_weighted_median_integer_weightsrV   u   sz     ))

 2
3CBR Ajjj$GyyG$HYYx F,Q8HVH%%%%r"   c           	         t         j                  j                  |       }|j                  dd      }|j	                  dd      }|j                  dd      }t        j
                  ||f      j                  }t        ||      }t        |j                  d         D cg c]  }t        |d d |f   |       }}t        ||       |j	                  dd      }	t        j
                  ||	f      j                  }
t        ||
      }t        |j                  d         D cg c]  }t        |d d |f   |
d d |f          }}t        ||       y c c}w c c}w )Nr%   r&   r   r$   r   )r   r*   r+   r,   rS   vstackTr   rangerM   r   )r/   r0   x1w1x2x_2drP   ip_axis_0w2w_2ds              r    test_weighted_percentile_2drc      s7   
))

 2
3C	Rb	!B	AB	B	Rb	!B99b"X  D#D"-H>CDJJqM>RS$T!Q$Z4SHSHh'	AB	B99b"X  D#D$/H>CDJJqM>R9:T!Q$Zad4H  Hh' Ts    E"!Ez#array_namespace, device, dtype_namezdata, weights, percentile*   r   r   c                 $    | j                  d      S Nr   randr0   s    r    <lambda>rj      s    SXXb\ r"   c                 &    | j                  dd      S )Nr   r   rg   ri   s    r    rj   rj      s    SXXb!_ r"   c                 ^    | j                  d      j                  t        j                        S rf   rh   astyper   float32ri   s    r    rj   rj      s    #((2,2E2Ebjj2Q r"   K   c                 &    | j                  dd      S Nr$   r   rg   ri   s    r    rj   rj      s    Q r"   c                 `    | j                  dd      j                  t        j                        S rr   rm   ri   s    r    rj   rj      s    Q..rzz: r"      r   rH   r   r   r   )r   r   r   r   r   r   r8   c                    |dk(  r/	 ddl }||j                  d      k(  rt        j                  d       	 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)        ||      }ddd       j*                  |j*                  k(  sJ |j,                  |j,                  k(  sJ t/        ||       |dk(  r3|j*                  |j*                  cxk(  rt        j0                  k(  sJ  J y|j*                  t        j2                  k(  sJ y# t        $ r Y w xY w# 1 sw Y   xY w)zECheck `_weighted_percentile` gives consistent results with array API.array_api_strictr   Ndevice1zXarray_api_strict has bug when indexing with tuple of arrays on non-'CPU_DEVICE' devices.r   r
   zxp.nextafter is broken on T)array_api_dispatch)xpro   )rv   DevicepytestxfailImportErrorr   zerosr-   all	nextafterr   r*   r+   callablern   r   asarrayr   array_devicer   r   r9   rM   r   ro   r=   )r/   array_namespacer   
dtype_namedatarO   r.   rv   ry   zerooner0   X_np
weights_np	result_npX_xp
weights_xp	result_xpresult_xp_nps                      r    .test_weighted_percentile_array_api_consistencyr      s*   D ,,
	# )00;;3
 
ov	6B
 88Af8%D
''!F'
#CQ266",,tS"9T"AB1&:;
))

 2
3C 49DD!)'!2J;;z"D$T:zBI::d6:*DJv6J	4	0 ;(z:F	I&,t*<<<<Y'*mD.A!.DDDD(r:	; 000000I|, Y!!Y__B

BBBBB!!RZZ///[  		>; ;s   H6 AI6	III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 that 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.rI   r%         ?r   r      )rI   r%   r&   )rI      Nr   )r   r*   r+   rh   nanrM   isnanr,   r   rZ   ndimrT   reshaper   r   )r   r/   r0   array_with_nansnan_masksample_weightresultscolfiltered_arrayfiltered_weightsexpected_resultss              r    %test_weighted_percentile_nan_filteredr      s    ))

 2
3ChhsB'O>@ffOHCHHo334s:;xx(HQAqy9Aqv6 #?M2FG
 ..q12 	!S&))3./N  Q		-1F1Fq1IJRR!!!$o&;&;A&>
 :??T?TUV?W9X25x3'',-  xx _22156	
 !!46Fs6KRP	
 '1'
	
s   	G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                  |       }d}t	        | ||      }t        j
                  |t        j                  t         j                  dg      d      sJ y)zCCheck that nans are ignored in general, except for all NaN columns.r   r   r   Z   T)	equal_nanN)r   r   r   	ones_liker   array_equal)r   rO   percentile_rankvaluess       r    'test_weighted_percentile_all_nan_columnr     s     HHVVQKVVQKVVRVVVVRVVVVQKVVRVV	
	E ll5!GO!%/BF
 >>&"((BFFA;"74HHHr"   z2.0z2np.quantile only accepts weights since version 2.0)reasonr.   )B   r%   r   c                     t         j                  j                  |      }|j                  dd      }|j	                  ddd      }t        |||       }t        j                  || dz  |dd	      }t        ||       y
)z\Check that _weighted_percentile delivers equivalent results as np.quantile
    with weights.r%   rI   r   r   r%   rI   r&   r   inverted_cdfrO   axisr)   N)r   r*   r+   rh   r,   r   quantiler   )r.   r/   r0   r   r   percentile_weighted_percentilepercentile_numpy_quantiles          r    ,test_weighted_percentile_like_numpy_quantiler   0  s~     ))

 2
3CHHREKK19K5M%9}j&" !#zCQ~! 57PQr"   z5np.nanquantile only accepts weights since version 2.0c                 T   t         j                  j                  |      }|j                  dd      }t         j                  | |j                  |j
                   dk  <   |j                  ddd      }t        |||       }t        j                  || dz  |dd	
      }t        ||       y)z_Check that _weighted_percentile delivers equivalent results as np.nanquantile
    with weights.r%   rI   r   r   r   r   r&   r   r   r   N)
r   r*   r+   rh   r   rM   r,   r   nanquantiler   )r.   r/   r0   r   r   r   percentile_numpy_nanquantiles          r    /test_weighted_percentile_like_numpy_nanquantiler   G  s     ))

 2
3Chhr3'O>@ffOHCHHo334s:;KK19K5M%9
&" $&>>S$  57S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   r   r!   r1   r5   r@   rD   rF   rJ   rQ   rV   rc   markparametrizero   int32r-   rn   r   r   r   r   r   skipifr   r    r"   r    <module>r      so     =  * 
 < ? 9 S!I#
 $&$	&(. )+T+V  
B!b)	!72772;#5#5bhh#?D	$&QSUV (:	
 
$	%xrxx0B'CQG	2662661aA.	/:L1MqQ BHH'(BHH'rxx8	
%6407<40n -1v6'2 7'2TI0 u%%?   |4R 5	
R$ u%%B   |4U 5	
Ur"   