+ ŜiX $^RIHt^RIt^RIt^RIHtHtHt^RIt^RI t ^RI H t ^RI HtHtHtHt^RIHtHtHtHtHtHtHtHtHt^RIHt^RIHtH t H!t!H"t"H#t#H$t$H%t%H&t&^R I'H(t(H)t)H*t*]'d^R I+H,t,]!R R R 7t-]-RJt.Rs/RqRRllt0]0!] !R44!RR4t1!RR4t2RRlt3RRlt4RrRRllt5RRlt6RsRR llt7R!R"lt8R#R$lt9RtR%R&llt:R'R(lt;R)R*ltR-RR.RR/R/R2R3llt?]1!R44];]=R-RR.RR5^R/R/R6R7ll444t@R8R9ltA]2!4];R-RR.RR/R/R:R;ll44tB]2!4R-RR.RR/R/R<R=ll4tCR>R?ltD] P!] P43R@RAlltG]2!^RB7R-RR.RRC^R/R/RDREll4tH]1!R4RF4]2!^RB7R-RR.RRC^R/R/RGRHll44tI]1!R4RF4R-RR.RRC^R/R/RIRJll4tJRKtK]K!RLRMRN7tL]K!RORPRN7tMR-RR.RR/R/RQRRlltNR-RR.RR/R/RSRTlltO]1!R4RF4]=R-RR.RR/R/RURVll44tP]1!R4RF4]=R-RR.RR/R/RWRXll44tQ]1!R4RF4]=R-RR.RR5^R/R/RYRZll44tRR[R\ltS] P!] P43R]R^lltTRuR_R`lltURaRbltVRcRdltW]1!R4RF4ReRfRgR/RhRill4tXRjRkltY]1!R4RF4RgRRC^/RlRmll4tZRnt[RoRplt\R#)v) annotationsN) TYPE_CHECKINGAnycast) get_option)NaTNaTTypeiNaTlib) ArrayLikeAxisIntCorrelationMethodDtypeDtypeObjFScalarShapenpt)import_optional_dependency) is_complexis_floatis_float_dtype is_integeris_numeric_dtypeis_object_dtypeneeds_i8_conversion pandas_dtype)isnana_value_for_dtypenotna)Callable bottleneckwarn)errorsFTc V^8dQhRRRR/#)vboolreturnNone)formats"[/Users/mibo/.openclaw/workspace/.venv-ak/lib/python3.14/site-packages/pandas/core/nanops.py __annotate__r.;s$$c&\'dVsR#R#N)_BOTTLENECK_INSTALLED_USE_BOTTLENECK)r's&r-set_use_bottleneckr4;sr/zcompute.use_bottleneckcFa]tRt^EtRV3RlltRRltRRltRtV;t#)disallowc V^8dQhRRRR/#)r&dtypesrr)r*r+)r,s"r-r.disallow.__annotate__FsJJJ$Jr/c <\SV`4\;QJd.RV4FNK 5VnR#!RV44VnR#)c3L"TFp\V4PxK R#5ir1)rtype).0dtypes& r- $disallow.__init__..HsI&L/44&s"$N)super__init__tupler8)selfr8 __class__s&*r-rBdisallow.__init__Fs2 eI&Ie eI&II r/cV^8dQhRR/#r&r)r(r+)r,s"r-r.r9JsQQDQr/c ~\VR4;'d+\VPPVP4#r>)hasattr issubclassr>r<r8)rDobjs&&r-checkdisallow.checkJs*sG$PPCIINNDKK)PPr/c V^8dQhRRRR/#)r&frr)r+)r,s"r-r.r9Ms!r/c faa\P!S4VV3Rl4p\\V4#)c<\P!WP44p\;QJdV3RlV4F 'gK RM RM!V3RlV44'd,SPP RR4p\ RV R24hS!V/VB# \d+p\T^,4'd \ T4ThhRp?ii;i)c3F<"TFpSPV4xK R#5ir1)rN)r=rMrDs& r-r?0disallow.__call__.._f..Qs7hs4::c??hs!TFnanzreduction operation 'z' not allowed for this dtypeN) itertoolschainvaluesany__name__replace TypeError ValueErrorr)argskwargsobj_iterf_nameerQrDs*, r-_fdisallow.__call__.._fNs t]]_=Hs7h7sss7h777++E26+F83OP $)&))  #47++#A,A- sB C%%C  C functoolswrapsrr)rDrQresff r-__call__disallow.__call__Ms,     $Ar{r/)r8) r\ __module__ __qualname____firstlineno__rBrNrj__static_attributes__ __classcell__)rEs@r-r6r6EsJJQr/r6c2]tRt^dtRRRlltRRltRtR#)bottleneck_switchNcV^8dQhRR/#)r&r)r*r+)r,s"r-r.bottleneck_switch.__annotate__estr/c WnW nR#r1)namera)rDrvras&&,r-rBbottleneck_switch.__init__es   r/c V^8dQhRRRR/#)r&altrr)r+)r,s"r-r.rtis00A0!0r/c aaaaSP;'g SPo\\S4o\ P!S4RRRR/RVVVV3Rlll4p\\V4# \\ 3dRoLPi;i)NaxisskipnaTc$V^8dQhRRRRRR/#)r&rZ np.ndarrayr{AxisInt | Noner|r(r+)r,s"r-r.0bottleneck_switch.__call__..__annotate__rs(% % % !%  % r/c4<\S P4^8d0S PP4FwrEWC9gK WSV&K VP^8XdVP R4f \ W4#\ 'dV'd~\VPS 4'dbVP RR4f>VPRR4S!V3RV/VBp\V4'dS!V3RVRV/VBpV#S!V3RVRV/VBpV#S!V3RVRV/VBpV#)r min_countNmaskr{r|) lenraitemssizeget_na_for_min_countr3 _bn_ok_dtyper>pop _has_infs) rZr{r|kwdskr'resultrybn_funcbn_namerDs &$$, r-rQ%bottleneck_switch.__call__..fqs4;;!# KK--/DA}"#Q0{{aDHH[$9$A)666l6<<.Q.Q88FD)1HHVT*$V?$?$?F!((!$V!N$!Nv!N!N M !JdJ6JTJFMVF$FvFFMr/) rvr\getattrbnAttributeError NameErrorrhrirr)rDryrQrrsff @@r-rjbottleneck_switch.__call__is))++s|| b'*G  % $(%  % %  % NAqzW * G sA11BB)rarvr1)r\rlrmrnrBrjror+r/r-rrrrds00r/rrc$V^8dQhRRRRRR/#)r&r>rrvstrr)r(r+)r,s"r-r.r.s!r/cHV\8wd\V4'gVR9#R#)nansumF)rnanprodnanmean)objectr)r>rvs&&r-rrs% 2599;;; r/cV^8dQhRR/#rHr+)r,s"r-r.r.s   r/c(\V\P4'd7VPR9d&\P !VP R44#\P!V4P4# \\3dR#i;i)f8KF)rf4) isinstancenpndarrayr>r has_infsravelisinfr[r^NotImplementedError)rs&r-rrsn&"**%% <<< '<< S 12 2xx##%% * +s#A<<BBc V^8dQhRRRR/#)r&r>r fill_valuez Scalar | Noner+)r,s"r-r.r.s !.r/cVeV#\V4'd=Vf\P#VR8Xd\P#\P)#VR8Xd\P #\ #)z9return the correct fill value for the dtype of the values+inf) _na_ok_dtyperrVinfr i8maxr )r>rfill_value_typs&&&r-_get_fill_valuers]E  !66M v %66MFF7N 6 !yy r/c(V^8dQhRRRRRRRR/#)r&rZr~r|r(rnpt.NDArray[np.bool_] | Noner)r+)r,s"r-r.r.s,)) ) $),H)!)r/cVfLVPPR9dR#V'gVPPR9d \V4pV#)a^ Compute a mask if and only if necessary. This function will compute a mask iff it is necessary. Otherwise, return the provided mask (potentially None) when a mask does not need to be computed. A mask is never necessary if the values array is of boolean or integer dtypes, as these are incapable of storing NaNs. If passing a NaN-capable dtype that is interpretable as either boolean or integer data (eg, timedelta64), a mask must be provided. If the skipna parameter is False, a new mask will not be computed. The mask is computed using isna() by default. Setting invert=True selects notna() as the masking function. Parameters ---------- values : ndarray input array to potentially compute mask for skipna : bool boolean for whether NaNs should be skipped mask : Optional[ndarray] nan-mask if known Returns ------- Optional[np.ndarray[bool]] NbiumM)r>kindr)rZr|rs&&&r-_maybe_get_maskrsAB | <<   % V\\&&$.rrasarrayviewrr[rcopyputmaskwhere)rZr|rrrr> datetimelikes&&&&& r- _get_valuesrsR 64 0D LLEL ||D FKK-.  4#%    !xxzz<#6#6#[[]FJJvZ8 < XXteV@F <r/c V^8dQhRRRR/#)r&r>np.dtyper)r+)r,s"r-r.r.Ds  ( x r/cPTpVPR9d'\P!\P4pV#VPR8Xd'\P!\P4pV#VPR8Xd%\P!\P 4pV#)biurQ)rrr>int64uint64float64)r> dtype_maxs& r-_get_dtype_maxrDs{I zzTHHRXX&  s HHRYY'   s HHRZZ( r/c V^8dQhRRRR/#)r&r>rr)r(r+)r,s"r-r.r.Ps222T2r/cz\V4'dR#\VP\P4'*#)F)rrLr<rintegerrJs&r-rrPs(5!!%**bjj1 11r/cV^8dQhRR/#)r&r>rr+)r,s"r-r.r.Vs&&&r/cV\JdV#VPR8XdVf\p\V\P 4'g\ V4'dQR4hW8Xd\Pp\ V4'd(\P!RR4PV4pM%\P!V4PV4pVPVRR7pV#VPV4pV#VPR8Xd\V\P 4'gW8Xg\P!V4'd(\P!R4PV4pV#\P!V4\P 8d \#R4h\P!V4PVRR7pV#VPR 4PV4pV#) zwrap our results if neededMzExpected non-null fill_valuernsFrmzoverflow in timedelta operationzm8[ns])rrr rrrrrV datetime64astyperrisnan timedelta64fabsr rr_)rr>rs&&&r- _wrap_resultsrVs } F MC s   J&"**--J'' G)G G'#F||ud3::5A&)..u5]]5u]5F& M!]]5)F M s &"**--#rxx'7'7.55e< M399, !BCC&)00U0C M]]8,11%8F Mr/c V^8dQhRRRR/#r&funcrr)r+)r,s"r-r.r.sqQr/cxa\P!S4RRRRRR/RV3Rlll4p\\V4#)z If we have datetime64 or timedelta64 values, ensure we have a correct mask before calling the wrapped function, then cast back afterwards. r{Nr|Trc(V^8dQhRRRRRRRR/# r&rZr~r{rr|r(rrr+)r,s"r-r.*_datetimelike_compat..__annotate__s2  + r/c <TpVPPR9pV'dVf \V4pS!V3RVRVRV/VBpV'd6\WuP\R7pV'gVfQh\ WqW54pV#)rr{r|r)r)r>rrrr _mask_datetimelike_result) rZr{r|rra orig_valuesrrrs &$$$, r-new_func&_datetimelike_compat..new_funcs ||((D0 DL 1. Returns ------- result : scalar or ndarray For 1-D values, returns a scalar of the correct missing type. For 2-D values, returns a 1-D array where each element is missing. iufcbrNrJ)r>rrrndimshaperfull)rZr{r result_shapes&& r-rrs"||G#y)#FLL1J {{a ||ET*V\\$(*-EE ww|v||DDr/c V^8dQhRRRR/#rr+)r,s"r-r.r.sar/cpa\P!S4RR/RV3Rlll4p\\V4#)z NumPy operations on C-contiguous ndarrays with axis=1 can be very slow if axis 1 >> axis 0. Operate row-by-row and concatenate the results. r{Nc V^8dQhRRRR/#)r&rZr~r{rr+)r,s"r-r.+maybe_operate_rowwise..__annotate__s11 1^1r/c T<V^8XEd VP^8XdVPR,'dVP^,R, VP^,8dVP\\ 39d\ V4pVPR4eKVPR4p\\V44Uu.uFpS!W5,3RWE,/VBNK ppMVUu.uF pS!V3/VBNK pp\P!V4#S!V3RV/VB#uupiuupi) C_CONTIGUOUSrr{) rflagsrr>rr(listrrrangerrarray) rZr{raarrsriresultsxrs &$, r-newfunc&maybe_operate_rowwise..newfuncs AI q  ^,,a4'6<<?: VTN2>> from pandas.core import nanops >>> s = pd.Series([1, 2]) >>> nanops.nanany(s.values) np.True_ >>> from pandas.core import nanops >>> s = pd.Series([np.nan]) >>> nanops.nanany(s.values) np.False_ iubrz0datetime64 type does not support operation 'any'Frr)r>rr[r^rrrr(rZr{r|r_s&$$$ r-nananyr sD||E!dlzz$ ||CJKKFu4HIF||vt$ ::d r/c ,V^8dQhRRRRRRRRR R/#rr+)r,s"r-r.r.rr/cDVPPR9dVfVPV4#VPPR8Xd \R4h\ WRVR7wrVP\ 8XdVP \4pVPV4#)a Check if all elements along an axis evaluate to True. Parameters ---------- values : ndarray axis : int, optional skipna : bool, default True mask : ndarray[bool], optional nan-mask if known Returns ------- result : bool Examples -------- >>> from pandas.core import nanops >>> s = pd.Series([1, 2, np.nan]) >>> nanops.nanall(s.values) np.True_ >>> from pandas.core import nanops >>> s = pd.Series([1, 0]) >>> nanops.nanall(s.values) np.False_ rrz0datetime64 type does not support operation 'all'Tr )r>rallr^rrrr(r s&$$$ r-nanallrsD||E!dlzz$ ||CJKKFt$GIF||vt$ ::d r/M8rc 0V^8dQhRRRRRRRRR R R R /#) r&rZr~r{rr|r(rintrrr)z*npt.NDArray[np.floating] | float | NaTTyper+)r,s"r-r.r.TsF** * *  *  * ' *0*r/c:VPp\W^VR7wr\V4pVPR8XdTpM5VPR8Xd%\P!\P 4pVP WR7p\WqW@PVR7pV#)a Sum the elements along an axis ignoring NaNs Parameters ---------- values : ndarray[dtype] axis : int, optional skipna : bool, default True min_count: int, default 0 mask : ndarray[bool], optional nan-mask if known Returns ------- result : dtype Examples -------- >>> from pandas.core import nanops >>> s = pd.Series([1, 2, np.nan]) >>> nanops.nansum(s.values) np.float64(3.0) r rQrrJr) r>rrrrrsum_maybe_null_outr)rZr{r|rrr> dtype_sumthe_sums&$$$$ r-rrQs~D LLEv!$GLFu%I zzS s HHRZZ( jjj/GgT<<9UG Nr/c ,V^8dQhRRRRRRRRR R /#) r&rz+np.ndarray | np.datetime64 | np.timedelta64r{rrznpt.NDArray[np.bool_]rr~r)z5np.ndarray | np.datetime64 | np.timedelta64 | NaTTyper+)r,s"r-r.r.s:   7       ; r/cd\V\P4'dGVPR4P VP 4pVP VR7p\W&V#VP 4'd4\P!\4P VP 4#V#)rr{) rrrrrr>r[r r)rr{rr axis_masks&&&& r-rrs &"**%%t$))+*;*;<HH$H'   M xx~"";#4#455 Mr/c ,V^8dQhRRRRRRRRR R /# r&rZr~r{rr|r(rrr)floatr+)r,s"r-r.r.sC@@ @ @  @ ' @  @r/cVP\8Xd)\V4R8dVf\VR,WR7VPp\ W^VR7wr\ V4p\ P!\ P4pVPR9d&\ P!\ P4pMKVPR9d&\ P!\ P4pMVPR8XdTpTp\VPW1VR 7pVPWR 7p\V4pVe\VR R 4'd{\\ PV4p\ P !R R 7;_uu_4W, p RRR4V^8Hp V P#4'd\ P$X V &X #V^8d W, M\ P$p V # +'giLa;i)a Compute the mean of the element along an axis ignoring NaNs Parameters ---------- values : ndarray axis : int, optional skipna : bool, default True mask : ndarray[bool], optional nan-mask if known Returns ------- float Unless input is a float array, in which case use the same precision as the input array. Examples -------- >>> from pandas.core import nanops >>> s = pd.Series([1, 2, np.nan]) >>> nanops.nanmean(s.values) np.float64(1.5) rN:NiN)r{r|r riurQrJrFignore)r)r>rrrrrrrr _get_countsrr_ensure_numericrrrerrstater[rV) rZr{r|rr>r dtype_countcountrthe_meanct_masks &$$$ r-rrspB||v#f+"5$,u D8 LLEv!$GLFu%I((2::&K zzTHHRZZ( t HHRZZ( s    d DEjjj/Gg&G GGVU;;RZZ' [[X & &H'1* ;;== "HW  O',ai7?RVV O' &s  G11 H c(V^8dQhRRRRRRRR/#) r&rZr~r{rr|r(r)float | np.ndarrayr+)r,s"r-r.r.s2h%h% h%!/h%@Dh%h%r/c*aVPPR8H;'dVRJpRRV3RlllpVPp\VSVRR7wrVPPR8wdTVP\8Xd-\P !V4pVR9d\ RV R24hVPR4pV'gCVe?VPP'gVP4p\PW&VPp VP ^8Ed VEeV 'dS'g\P"!WQV4p M\$P&!4;_uu_4\$P(!R R \*4VP,^,^8XdV^8Xg VP,^,^8Xd5V^8Xd.\P.!\P0!V4R R 7p M\P.!WR 7p RRR4M7\3VP,V4p M V 'd V!W4M\Pp \5X V4# \dp\ \T44ThRp?ii;i +'giLD;i)a Parameters ---------- values : ndarray axis : int, optional skipna : bool, default True mask : ndarray[bool], optional nan-mask if known Returns ------- result : float | ndarray Unless input is a float array, in which case use the same precision as the input array. Examples -------- >>> from pandas.core import nanops >>> s = pd.Series([1, np.nan, 2, 2]) >>> nanops.nanmedian(s.values) 2.0 >>> s = pd.Series([np.nan, np.nan, np.nan]) >>> nanops.nanmedian(s.values) nan rQNcV^8dQhRR/#)r&rr~r+)r,s"r-r.nanmedian..__annotate__sjr/c<Vf \V4pMV(pS'g'VP4'g\P#\P !4;_uu_4\P !RR\4\P !RR\4\P!W,4pRRR4V# +'giX#;i)Nr#All-NaN slice encounteredzMean of empty slice) r rrrVwarningscatch_warningsfilterwarningsRuntimeWarning nanmedian)r_maskresr|s&& r- get_mediannanmedian..get_medians =!HEFEeiikk66M  $ $ & &  # #5~   # #H.C^ T,,qx(C ' ' & s AB?? C )rrzCannot convert to numericrr#r1T)keepdimsrr1stringmixed)r>rrrr infer_dtyper^rr_rr writeablerrrVrrapply_along_axisr2r3r4r5rr6squeeze_get_empty_reduction_resultr) rZr{r|rusing_nan_sentinelr9r>inferrederrnotemptyr8s &$d$ r-r6r6sB **c1BBddl LLEvvDTJLF ||C <<6 !v.H../& EFF /]]4(F $"2||%%%[[]Fvv {{H {{Q4+ ))*FC,,..++ "=~ Q1, Q1,!ll2::f+=M ll6=/.$.fllDAC+3j& e $$Y /CH%3 . /*/.s%,I/BJ I?%I::I? J c$V^8dQhRRRRRR/#)r&rrr{r r)r~r+)r,s"r-r.r.Bs&  r/c \P!V4p\P!\V44p\P!W#V8g,\P R7pVP \P4V#)z The result from a reduction on an empty ndarray. Parameters ---------- shape : Tuple[int, ...] axis : int Returns ------- np.ndarray rJ)rrarangeremptyrfillrV)rr{shpdimsrets&& r-rDrDBsS ((5/C 99SZ D ((3t|$BJJ 7CHHRVV Jr/c 0V^8dQhRRRRRRRRR R R R /#) r& values_shaperrrr{rddofrr>rr)z-tuple[float | np.ndarray, float | np.ndarray]r+)r,s"r-r.r.YsD/// &/ /  /  / 3 /r/c\WW$R7pWTPV4, p\V4'd*WS8:d!\Pp\PpWV3#\ \P V4pWS8*pVP4'dK\P!Wa\P4\P!WQ\P4WV3#)a Get the count of non-null values along an axis, accounting for degrees of freedom. Parameters ---------- values_shape : Tuple[int, ...] shape tuple from values ndarray, used if mask is None mask : Optional[ndarray[bool]] locations in values that should be considered missing axis : Optional[int] axis to count along ddof : int degrees of freedom dtype : type, optional type to use for count Returns ------- count : int, np.nan or np.ndarray d : int, np.nan or np.ndarray rJ) r$r<rrrVrrr[r)rRrr{rSr>r(ds&&&&& r-_get_counts_nanvarrVYs:  D >E 4  A =FFEA 8O RZZ'} 88:: JJq ' JJuBFF + 8Or/rSrSc$V^8dQhRRRRRR/#)r&r{rr|r(rSrr+)r,s"r-r.r.s*+-+- +-  +-  +-r/c @VPPR8Xd=\P!VP4^,pVP RV R24pVPp\ WVR7wr\P !\WW#VR74p\Wv4#)a_ Compute the standard deviation along given axis while ignoring NaNs Parameters ---------- values : ndarray axis : int, optional skipna : bool, default True ddof : int, default 1 Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements. mask : ndarray[bool], optional nan-mask if known Returns ------- result : float Unless input is a float array, in which case use the same precision as the input array. Examples -------- >>> from pandas.core import nanops >>> s = pd.Series([1, np.nan, 2, 3]) >>> nanops.nanstd(s.values) 1.0 rzm8[])rr{r|rSr) r>rr datetime_datarrsqrtnanvarr)rZr{r|rSrunit orig_dtypers&$$$$ r-nanstdrasH||C -a0s4&]+JvD9LF WWVFfdS TF  ,,r/m8c(V^8dQhRRRRRRRR/#) r&rZr~r{rr|r(rSrr+)r,s"r-r.r.s8JJ J J  J  Jr/cVPp\WV4pVPR9d(VPR4pVe\P W&VPPR8Xd%\ VPWAW0P4wrgM\ VPWAV4wrgV'd,Ve(VP4p\P!W^4\VPV\PR74V, pVe\P!W4pVPPR8Xd#\\W, 4^,4p M\W, ^,4p Ve\P!W^4V PV\PR7V, p VPR8XdV PVRR7p V #)aU Compute the variance along given axis while ignoring NaNs Parameters ---------- values : ndarray axis : int, optional skipna : bool, default True ddof : int, default 1 Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements. mask : ndarray[bool], optional nan-mask if known Returns ------- result : float Unless input is a float array, in which case use the same precision as the input array. Examples -------- >>> from pandas.core import nanops >>> s = pd.Series([1, np.nan, 2, 3]) >>> nanops.nanvar(s.values) 1.0 r"rrQ)r{r>cFr)r>rrrrrVrVrrrr%rr expand_dimsabs) rZr{r|rSrr>r(rUavgsqrrs &$$$$ r-r^r^siJ LLE 64 0D zzTt$  66FL ||C%fllDllSq%fllDE $" 6# &**$bjj*A BU JC nnS' ||Cc#,/145s|12  3a WW$bjjW 1A 5F  zzSu51 Mr/c 0V^8dQhRRRRRRRRR R R R /#) r&rZr~r{rr|r(rSrrrr)r r+)r,s"r-r.r. sF1)1) 1) 1)  1)  1) ' 1) 1)r/c\WW#VR7\WV4pVPPR8wdVP R4pV'g+Ve'VP 4'd\ P#\VPWAW0P4wrV\WW#VR7p\ P!V4\ P!V4, #)a Compute the standard error in the mean along given axis while ignoring NaNs Parameters ---------- values : ndarray axis : int, optional skipna : bool, default True ddof : int, default 1 Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements. mask : ndarray[bool], optional nan-mask if known Returns ------- result : float64 Unless input is a float array, in which case use the same precision as the input array. Examples -------- >>> from pandas.core import nanops >>> s = pd.Series([1, np.nan, 2, 3]) >>> nanops.nansem(s.values) np.float64(0.5773502691896258) r[rQr) r^rr>rrr[rrVrVrr])rZr{r|rSrr(r vars&$$$$ r-nansemrm sL 6VTB 64 0D ||Ct$ d&488::vv !&,,D,,OHE 64 HC 773<"''%. ((r/cdaa\RS 2R7\RRRRRR/RVV3Rlll44pV#) rV)rvr{Nr|Trc(V^8dQhRRRRRRRR/#rr+)r,s"r-r. _nanminmax..__annotate__As2  + r/c<VP^8Xd \W4#VPp\WSVR7wr\ VS4!V4p\ WQW0P VPR9R7pV#)rrrr)r)rrr>rrrrr)rZr{r|rr>rrmeths&$$$ r- reduction_nanminmax..reduction?sp ;;! $V2 2 " > &t, $ 5::;M  r/)rrr)rsrrtsff r- _nanminmaxrv>sSc$L) $  .2 *( r/minr)rmax-infc ,V^8dQhRRRRRRRRR R /# r&rZr~r{rr|r(rrr)zint | np.ndarrayr+)r,s"r-r.r.\<++ + +  + ' +  +r/cb\VRRVR7wrVPV4p\WAW24pV#)a Parameters ---------- values : ndarray axis : int, optional skipna : bool, default True mask : ndarray[bool], optional nan-mask if known Returns ------- result : int or ndarray[int] The index/indices of max value in specified axis or -1 in the NA case Examples -------- >>> from pandas.core import nanops >>> arr = np.array([1, 2, 3, np.nan, 4]) >>> nanops.nanargmax(arr) np.int64(4) >>> arr = np.array(range(12), dtype=np.float64).reshape(4, 3) >>> arr[2:, 2] = np.nan >>> arr array([[ 0., 1., 2.], [ 3., 4., 5.], [ 6., 7., nan], [ 9., 10., nan]]) >>> nanops.nanargmax(arr, axis=1) array([2, 2, 1, 1]) Tryrr)rargmax_maybe_arg_null_outrZr{r|rrs&$$$ r- nanargmaxr\8LvtFNLF ]]4 F!t >> from pandas.core import nanops >>> arr = np.array([1, 2, 3, np.nan, 4]) >>> nanops.nanargmin(arr) np.int64(0) >>> arr = np.array(range(12), dtype=np.float64).reshape(4, 3) >>> arr[2:, 0] = np.nan >>> arr array([[ 0., 1., 2.], [ 3., 4., 5.], [nan, 7., 8.], [nan, 10., 11.]]) >>> nanops.nanargmin(arr, axis=1) array([0, 0, 1, 1]) Trrr)rargminrrs&$$$ r- nanargminrrr/c ,V^8dQhRRRRRRRRR R /#rr+)r,s"r-r.r.sCTT T T  T ' T  Tr/c&\WV4pVPPR8wd)VPR4p\ VP W14pM"\ VP W1VPR7pV'd-Ve)VP 4p\P!W^4M2V'g+Ve'VP4'd\P#\P!RRR7;_uu_4VPV\PR7V, pRRR4Ve\P!XV4pVX, pV'dVe\P!Wc^4V^,pWv,pVPV\PR7p VPV\PR7p \P!V4P!VRR7p \P"!V P4P$p W,^,V,p W,^,V,p\'W4p \'W4p \P!RRR7;_uu_4WD^, R ,,V^, , WR ,, ,pRRR4VPpVPR8XdXPVR R 7p\)X\P*4'd3\P,!V ^8H^V4p\PW^8&V#V ^8XdVP/^4MTpV^8d\P#V# +'giELT;i +'giL;i) a Compute the sample skewness. The statistic computed here is the adjusted Fisher-Pearson standardized moment coefficient G1. The algorithm computes this coefficient directly from the second and third central moment. Parameters ---------- values : ndarray axis : int, optional skipna : bool, default True mask : ndarray[bool], optional nan-mask if known Returns ------- result : float64 Unless input is a float array, in which case use the same precision as the input array. Examples -------- >>> from pandas.core import nanops >>> s = pd.Series([1, np.nan, 1, 2]) >>> nanops.nanskew(s.values) np.float64(1.7320508075688787) rQrrJNr#invaliddivideinitialg?g?Fr)rr>rrr$rrrrr[rVr&rrrfrgrxfinfoeps_zero_out_fperrrrrr<)rZr{r|rr(meanadjusted adjusted2 adjusted3m2m3max_absrconstant_tolerance2constant_tolerance3rr>s&$$$ r-nanskewrsJ 64 0D ||Ct$FLL$5FLL$FLLI $" 6# (TXXZZvv Xh 7 7zz$bjjz1E9 8 ~~dD)}H $" 81%! I$I t2:: .B t2:: .BffVn  s 3G ((288  CMa/58Ma/58  1B  1B Xh 7 719,, :rG|L 8 LLE zzSu51&"**%%"'1f-FFqy M #%'Av 1966M MI 8 7 7* 8 7s8)M,69N, M= N c ,V^8dQhRRRRRRRRR R /#rr+)r,s"r-r.r.sCrr r r  r ' r  rr/c\WV4pVPPR8wd)VPR4p\ VP W14pM"\ VP W1VPR7pV'd-Ve)VP 4p\P!W^4M2V'g+Ve'VP4'd\P#\P!RRR7;_uu_4VPV\PR7V, pRRR4Ve\P!XV4pVX, pV'dVe\P!Wc^4V^,pV^,pVPV\PR7p VPV\PR7p \P!V4P!VRR7p \P"!V P4P$p W,^,V,p W,^,V,p\'W4p \'W4p \P!RRR7;_uu_4^V^, ^,,V^, V^, ,, pWD^,,V^, ,V ,pV^, V^, ,V ^,,pRRR4\)X\P*4'g:V^8d\P#V^8XdVPP-^4#\P!RRR7;_uu_4XV, X, pRRR4VPpVPR8XdXPVR R 7p\)X\P*4'd2\P.!V^8H^V4p\PVV^8&V# +'giEL;i +'giEL:;i +'giL;i) al Compute the sample excess kurtosis The statistic computed here is the adjusted Fisher-Pearson standardized moment coefficient G2, computed directly from the second and fourth central moment. Parameters ---------- values : ndarray axis : int, optional skipna : bool, default True mask : ndarray[bool], optional nan-mask if known Returns ------- result : float64 Unless input is a float array, in which case use the same precision as the input array. Examples -------- >>> from pandas.core import nanops >>> s = pd.Series([1, np.nan, 1, 3, 2]) >>> nanops.nankurt(s.values) np.float64(-1.2892561983471076) rQrrJNr#rrrFr)rr>rrr$rrrrr[rVr&rrrfrgrxrrrrrr<r)rZr{r|rr(rrr adjusted4rm4rrrconstant_tolerance4adj numerator denominatorrr>s&$$$ r-nankurtrsJ 64 0D ||Ct$FLL$5FLL$FLLI $" 6# (TXXZZvv Xh 7 7zz$bjjz1E9 8 ~~dD)}H $" 81%! I1 I t2:: .B t2:: .B0ffVn  s 3G ((288  CMa/58Ma/58  1B  1B Xh 7 7519""uqyUQY&?@QY'5195: qyUQY/"a%7  8 k2:: . . 1966M ! <<$$Q' ' Xh 7 7[(3. 8 LLE zzSu51&"**%%+*Av6FFuqy ME 8 7 7T 8 7 7 8 7s%8)P7A=P%5P9 P" % P6 9 Q c 0V^8dQhRRRRRRRRR R R R /#) r&rZr~r{rr|r(rrrrr)r r+)r,s"r-r.r.sF(( ( (  (  ( ' ( (r/c\WV4pV'dVeVP4p^W&VPV4p\WQW@PVR7#)a Parameters ---------- values : ndarray[dtype] axis : int, optional skipna : bool, default True min_count: int, default 0 mask : ndarray[bool], optional nan-mask if known Returns ------- Dtype The product of all elements on a given axis. ( NaNs are treated as 1) Examples -------- >>> from pandas.core import nanops >>> s = pd.Series([1, 2, 3, np.nan]) >>> nanops.nanprod(s.values) np.float64(6.0) r)rrprodrr)rZr{r|rrrs&$$$$ r-rrsS@ 64 0D $" [[ F dLLI r/c ,V^8dQhRRRRRRRRR R /#) r&rr~r{rrrr|r(r)znp.ndarray | intr+)r,s"r-r.r.s:   '    r/cVfV#Ve\VRR4'gUV'd"VP4'd \R4hV'g"VP4'd \R4hV#V'd1VPV4P4'd \R4hV'g1VPV4P4'd \R4hV#)NrFzEncountered all NA valuesz)Encountered an NA value with skipna=False)rrr_r[)rr{rr|s&&&&r-rrs |  |766599 dhhjj89 9DHHJJHI I M DHHTN&&((455 **,,DEE Mr/c ,V^8dQhRRRRRRRRR R /#) r&rRrrrr{rr>znp.dtype[np.floating]r)z&np.floating | npt.NDArray[np.floating]r+)r,s"r-r.r.s:&+&+&+ &&+ &+ ! &+ , &+r/czVfNVe#VPVP4, pM\P!V4pVP V4#Ve+VP V,VPV4, pMW,p\ V4'dVP V4#VPVRR7#)a} Get the count of non-null values along an axis Parameters ---------- values_shape : tuple of int shape tuple from values ndarray, used if mask is None mask : Optional[ndarray[bool]] locations in values that should be considered missing axis : Optional[int] axis to count along dtype : type, optional type to use for count Returns ------- count : scalar or array Fr)rrrrr<rrr)rRrr{r>nr(s&&&& r-r$r$s0 |   DHHJ&A %Azz!}  4 488D>1"%zz%  <<E< **r/c4V^8dQhRRRRRRRRR R R R R R/#)r&rznp.ndarray | float | NaTTyper{rrrrtuple[int, ...]rrrr(r)r+)r,s"r-r.r.sN11 (1 1 '1  1  1  1"1r/cfVf V^8XdV#VEeB\V\P4'Ed!Ve5VPV,VP V4, V, ^8pM=W1,V, ^8pVRVW1^,R,p\P !Wx4p\P !V4'dV'd \W&V#\V4'dg\P!V4'dVPR4pM$\V4'gVPRRR7p\PW&V#RW&V#V\JdT\W2V4'dB\VRR4p \V 4'dV P!R4pV#\PpV#)za Returns ------- Dtype The product of all elements on a given axis. ( NaNs are treated as 1) Nc16rFrr>rV)rrrrr broadcast_tor[r r iscomplexobjrrrVrcheck_below_min_countrr<) rr{rrrr null_mask below_count new_shape result_dtypes &&&&&& r-rrsr | Q  Jvrzz::  D)DHHTN:YF!KI + 1A5Ket uAXZ'88I ?I 66)  $(!& M%"&))??6**#]]51F'//#]]4e]KN r/cV^8dEVf\P!V4pM!VPVP4, pW28dR#R#)a Check for the `min_count` keyword. Returns True if below `min_count` (when missing value should be returned from the reduction). Parameters ---------- shape : tuple The shape of the values (`values.shape`). mask : ndarray[bool] or None Boolean numpy array (typically of same shape as `shape`) or None. min_count : int Keyword passed through from sum/prod call. Returns ------- bool TF)rrrr)rrr non_nullss&&& r-rr(s=(1} <I DHHJ.I   r/cV^8dQhRR/#)r&tolr,r+)r,s"r-r.r.Gs??0?r/c\V\P4'd0\P!\P!V4V8^V4#\P!V4V8dVP P ^4#T#r)rrrrrgr>r<)argrs&&r-rrGsZ#rzz""xxs c)1c22$&FF3K#$5syy~~a >3>r/methodpearson min_periodsc ,V^8dQhRRRRRRRRRR /#) r&ar~brrr int | Noner)r r+)r,s"r-r.r.Ps:      r/cj\V4\V48wd \R4hVf^p\V4\V4,pVP4'gW,pW,p\V4V8d\P #\ V4p\ V4p\V4pV!W4#)z a, b: ndarrays z'Operands to nancorr must have same size)rAssertionErrorr rrrVr% get_corr_func)rrrrvalidrQs&&$$ r-nancorrrOs 1vQFGG !HuQx E 99;; H H 1v vv AAfA Q7Nr/c V^8dQhRRRR/#)r&rrr)z)Callable[[np.ndarray, np.ndarray], float]r+)r,s"r-r.r.os .r/caaVR8Xd^RIHoV3RlpV#VR8Xd^RIHoV3RlpV#VR8XdRpV#\V4'dV#\ RV R 24h) kendall) kendalltauc"<S!W4^,#rr+)rrrs&&r-rget_corr_func..funcusa#A& &r/spearman) spearmanrc"<S!W4^,#rr+)rrrs&&r-rr|sQ?1% %r/rc<\P!W4R,#)rrr)rcorrcoef)rrs&&r-rrs;;q$T* *r/zUnknown method 'z@', expected one of 'kendall', 'spearman', 'pearson', or callable) scipy.statsrrcallabler_)rrrrs& @@r-rrosu* ' : ) & 9  + &    6(#8 8 r/c ,V^8dQhRRRRRRRRRR/#) r&rr~rrrrSr)r r+)r,s"r-r.r.s:)))) )  )  )r/c\V4\V48wd \R4hVf^p\V4\V4,pVP4'gW,pW,p\V4V8d\P #\ V4p\ V4p\P!WVR7R,#)z&Operands to nancov must have same sizerWr)rrr rrrVr%cov)rrrrSrs&&$$ r-nancovrs 1vQEFF !HuQx E 99;; H H 1v vv AA 66!T "4 ((r/c\V\P4'dVPPR9d"VP \P 4pV#VP\8Xd\P!V4pVR9d\RV R24hVP \P4p\P!\P!V44'g VPpV#V#\!V4'gV\#V4'gE\%V4'g4\V\&4'd\RV R24h\)V4pV#V# \\3dHTP \P 4pT# \dp\RT R24ThRp?ii;ii;i \\3d4\+T4pT# \dp\RT R24ThRp?ii;ii;i)rzCould not convert r;NzCould not convert string 'z ' to numericr=)rrrr>rrrrr r@r^ complex128r[imagrealr_rrrrr complex)rrFrGs& r-r%r%s!RZZ  77<<5 $A< H;WW q)H.."4QC{ CDD HHR]]+vvbggaj))A H;: HqkkZ]]jmm a  8<HI I NaA H1H-z* RR,A( H'"R#&8;$GHcQR R:& N NAJ H N"4QC{ CD#M N  NsTE' G'F?9F F;&F66F;;F?H G"" H-G==HHc$V^8dQhRRRRRR/#)r&rZr r|r(r)r+)r,s"r-r.r.s!"")"D"Y"r/c \PR\P3\PP\P )\P3\P R\P3\PP\P \P3/V,wr4VPPR9gQhV'dt\VPP\P\P34'g0VP4p\V4pW5V&V!V^R7pWGV&V#V!V^R7pV#)z Cumulative function with skipna support. Parameters ---------- values : np.ndarray or ExtensionArray accum_func : {np.cumprod, np.maximum.accumulate, np.cumsum, np.minimum.accumulate} skipna : bool Returns ------- np.ndarray or ExtensionArray g?rrr)rcumprodrVmaximum accumulatercumsumminimumr>rrLr<rbool_rr)rZ accum_funcr|mask_amask_bvalsrrs&&$ r- na_accum_funcrs S"&&M 0 C= /   NF <<  D (( (j!2!2RZZ4JKK{{}DzT Dq)t  MF+ Mr/)T)NN)NNNr1)rF)] __future__rrhrXtypingrrrr2numpyrpandas._configr pandas._libsrr r r pandas._typingr r rrrrrrrpandas.compat._optionalrpandas.core.dtypes.commonrrrrrrrrpandas.core.dtypes.missingrrr collections.abcr!rr2r3r4r6rrrrrrrrrrrrrr rrrrr6rDr>rrVrar^rmrvnanminnanmaxrrrrrrr$rrrrrrr%rr+r/r-rs" %   ?    ( V<$:678>55p( ()XDN 2 &RDE>B5 5 5 *. 5p5 5 5 *. 5p $* * *  * *. **Z  @ @ @ *. @@Fh%26h%GKh%RVh%h%V8hhrzz* /d+- +- +-  +-  +-+-\ $J J J  J  JJZ $1) 1) 1)  1) *. 1)1)h4 E& 1 E& 1+ + + *. +\+ + + *. +\ $T T T *. TTn $r r r *. rrj $( ( (  ( *. ((V4$&88BJJ#7 &+R1h>? $!*  # >@ $)# )  ))6! H"r/