Mh( SSKJr SSKrSSKrSSKJrJrJr SSKrSSK r SSK J r SSK JrJrJrJr SSKJrJrJrJrJrJrJrJrJr SSKJr SSKJr SS K J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r( SS K)J*r*J+r+J,r, \"S S S 9r-\-SLr.Sq/SKSLSjjr0\0"\ "S55 "SS5r1"SS5r2SMSjr3SNSjr4SOSPSjjr5SQSjr6SRSSSjjr7STSjr8SUSjr9SVSWSjjr:SXSjr;SYSjrSSSS!.SZS#jjr?\1"S$5\;\=SSSSS%.S[S&jj555r@S\S'jrA\2"5\;SSSS!.S]S(jj55rB\2"5SSSS!.S^S)jj5rCS_S*jrD\ R"\ R54S`S+jjrG\2"S,S-9SSS,SS..SaS/jj5rH\1"S$S05\2"S,S-9SSS,SS..SbS1jj55rI\1"S$S05SSS,SS..ScS2jj5rJS3rK\K"S4S5S69rL\K"S7S8S69rMSSSS!.SdS9jjrNSSSS!.SdS:jjrO\1"S$S05\=SSSS!.S]S;jj55rP\1"S$S05\=SSSS!.S]S<jj55rQ\1"S$S05\=SSSSS%.S[S=jj55rRSeS>jrS\ R"\ R54SfS?jjrTSgShS@jjrUSiSAjrVSBrW\1"S$S05SCSSD.SjSEjj5rXSkSFjrY\1"S$S05SS,SG.SlSHjj5rZSIr[SmSJjr\g)n) annotationsN)AnyCallablecast) get_option)NaTNaTTypeiNaTlib) ArrayLikeAxisIntCorrelationMethodDtypeDtypeObjFScalarShapenpt)import_optional_dependency)find_stack_level) is_complexis_floatis_float_dtype is_integeris_numeric_dtypeis_object_dtypeneeds_i8_conversion pandas_dtype)isnana_value_for_dtypenotna bottleneckwarn)errorsFTc [(aUqggN)_BOTTLENECK_INSTALLED_USE_BOTTLENECK)vs D/var/www/html/env/lib/python3.13/site-packages/pandas/core/nanops.pyset_use_bottleneckr+9szcompute.use_bottleneckc@^\rSrSrSU4SjjrSSjrSSjrSrU=r$) disallowCcP>[TU]5 [SU55Ulg)Nc3L# UHn[U5Rv M g7fr&)rtype).0dtypes r* $disallow.__init__..FsI&L/44&s"$)super__init__tupledtypes)selfr: __class__s r*r8disallow.__init__Ds  I&II r,c|[US5=(a* [URRUR5$)Nr4)hasattr issubclassr4r2r:)r;objs r*checkdisallow.checkHs'sG$PCIINNDKK)PPr,cf^^[R"T5UU4Sj5n[[U5$)NcL>[R"XR55n[U4SjU55(a+TRR SS5n[ SUS35eT"U0UD6$![a%n[US5(a [ U5UeeSnAff=f)Nc3F># UHnTRU5v M g7fr&)rB)r3rAr;s r*r50disallow.__call__.._f..Os7hs4::c??hs!nanzreduction operation 'z' not allowed for this dtyper) itertoolschainvaluesany__name__replace TypeError ValueErrorr)argskwargsobj_iterf_nameefr;s r*_fdisallow.__call__.._fLs t]]_=H7h777++E26+F83OP $)&))  #47++#A,A- s,A44 B#> BB# functoolswrapsrr)r;rWrXs`` r*__call__disallow.__call__Ks,     $Ar{r,)r:)r:rreturnNoner_bool)rWrr_r) rN __module__ __qualname____firstlineno__r8rBr]__static_attributes__ __classcell__)r<s@r*r.r.CsJQr,r.c,\rSrSrSSSjjrSSjrSrg) bottleneck_switchbNc XlX lgr&)namerS)r;rlrSs r*r8bottleneck_switch.__init__cs   r,c^^^^TR=(d TRm[[T5m[ R"T5SSS.SUUUU4Sjjj5n[[U5$![[ 4a SmNRf=f)NTaxisskipnac>[T R5S:a.T RR5HupEXC;dM XSU'M URS:XaUR S5c [ X5$[ (a}U(av[URT 5(a[UR SS5c:URSS5 T"U4SU0UD6n[U5(a T"U4XS.UD6nU$T"U4XS.UD6nU$T"U4XS.UD6nU$)Nr min_countmaskrpro) lenrSitemssizeget_na_for_min_countr( _bn_ok_dtyper4pop _has_infs) rLrprqkwdskr)resultaltbn_funcbn_namer;s r*rW%bottleneck_switch.__call__..fos4;;!# KK--/DA}"#Q0{{aDHH[$9$A)666l6<<.Q.Q88FD)1HHVT*$V?$?$?F!((!$V!N$!N!N M !JdJTJFMVF$FFMr,)rL np.ndarrayrpAxisInt | Nonerqrb) rlrNgetattrbnAttributeError NameErrorr[r\rr)r;rrWrrs`` @@r*r]bottleneck_switch.__call__gs))+s|| b'*G  $( % % !%  % %  % NAqzW * G sA33BB)rSrlr&)r_r`)rrr_r)rNrcrdrer8r]rfr,r*riribs 0r,ricBU[:wa[U5(dUS;$g)N)nansumnanprodnanmeanF)objectr)r4rls r*rzrzs% 2599;;; r,c [U[R5(a5URS;a%[R "UR S55$[R"U5R5$![[4a gf=f)N)f8f4KF) isinstancenpndarrayr4r has_infsravelisinfrMrPNotImplementedError)rs r*r|r|sn&"**%% <<< '<< S 12 2xx##%% * +s#A::B  B cUbU$[U5(a:Uc[R$US:Xa[R$[R*$US:Xa[R $[ $)z9return the correct fill value for the dtype of the values+inf) _na_ok_dtyperrHinfr i8maxr )r4 fill_valuefill_value_typs r*_get_fill_valuers]E  !66M'vv w V #99 Kr,cUcGURRS;agU(dURRS;a [U5nU$)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)r4kindr)rLrqrts r*_maybe_get_maskrsAB | <<   % V\\&&$.UnURRS;nU(aUc [U5nT"U4XUS.UD6nU(a0[XuR[S9nU(dUce[ XqX55nU$)Nrr)r)r4rrrr _mask_datetimelike_result) rLrprqrtrS orig_valuesrrfuncs r*new_func&_datetimelike_compat..new_funcsy ||((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. iufcbrNr)r4rrr ndimshaperfull)rLrpr result_shapes r*ryrys"||G#y)#FLL1J {{a ||ET*V\\$(*-EE ww|v||DDr,cn^[R"T5SS.SU4Sjjj5n[[U5$)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. Nrpc 6>US:XaURS:XaURS(aURSS- URS:aUR[:waUR[ :wa[ U5nURS5bCURS5n[[U55Vs/sHnT"X54SXE0UD6PM nnOUVs/sH nT"U40UD6PM nn[R"U5$T"U4SU0UD6$s snfs snf)Nr C_CONTIGUOUSirrtrp) rflagsrr4rrblistrxr{rangerurarray) rLrprSarrsrtiresultsxrs r*newfunc&maybe_operate_rowwise..newfuncs  AI q  ^,a4'6<<?: & $B111. 7 r,rcdURRS;aUcURU5$URRS:Xa"[R"S[ [ 5S9 [XSUS9upUR[:XaUR[5nURU5$)a Check if any 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]) >>> nanops.nanany(s.values) True >>> from pandas.core import nanops >>> s = pd.Series([np.nan]) >>> nanops.nanany(s.values) False iubrzz'any' with datetime64 dtypes is deprecated and will raise in a future version. Use (obj != pd.Timestamp(0)).any() instead. stacklevelFrrt) r4rrMwarningsr# FutureWarningrrrrrbrLrprqrt_s r*nananyrsD||E!dlzz$ ||C  J ')  Fu4HIF||vt$ ::d r,cdURRS;aUcURU5$URRS:Xa"[R"S[ [ 5S9 [XSUS9upUR[:XaUR[5nURU5$)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) True >>> from pandas.core import nanops >>> s = pd.Series([1, 0]) >>> nanops.nanall(s.values) False rrzz'all' with datetime64 dtypes is deprecated and will raise in a future version. Use (obj != pd.Timestamp(0)).all() instead.rTr) r4rallrr#rrrrrrbrs r*nanallrsD||E!dlzz$ ||C  J ')  Ft$GIF||vt$ ::d r,M8)rprqrsrtc$URn[XSUS9up[U5nURS:XaUnO4URS:Xa$[R"[R 5nUR XS9n[XqX@RUS9nU$)au 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) 3.0 rrrWrrrs) r4rrrrrsum_maybe_null_outr)rLrprqrsrtr4 dtype_sumthe_sums r*rr\s~D LLEv!$GLFu%I zzS s HHRZZ( jjj/GgT<<9UG Nr,cZ[U[R5(aCURS5R UR 5nUR US9n[X'U$UR 5(a3[R"[5R UR 5$U$)Nrr) rrrrrr4rMr r)rrprtr axis_masks r*rrs &"**%%t$))+*;*;<HH$H' ! M 88::88D>&&{'8'89 9 Mr,cDURn[XSUS9up[U5n[R"[R5nUR S;a%[R"[R5nOIUR S;a%[R"[R5nOUR S:XaUnUn[ URX1US9nURXS9n[U5nUb|[USS 5(aj[[RU5n[R"S S 9 X- n SSS5 US:Hn U R5(a[RW U 'W $US:aX- O[Rn U $!,(df  NY=f) 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) 1.5 rrriurWrNrFignore)r)r4rrrrr _get_countsrr_ensure_numericrrrerrstaterMrH) rLrprqrtr4r dtype_countcountrthe_meanct_masks r*rrsDB LLEv!$GLFu%I((2::&K zzTHHRZZ( t HHRZZ( s    d DEjjj/Gg&G GGVU;;RZZ' [[X &H'1* ;;== "HW  O',ai7?RVV O' &s 9F Fc^URRS:H=(a USLnSU4SjjnURn[UTUSS9upURRS:waQUR[:Xa+[R "U5nUS;a[ SUS35eURS5nU(d@Ub=URR(dUR5n[RX'URn UR S :aUbU (aT(d[R""XQU5n O[$R&"5 [$R("S S [*5 UR,S S :XaUS :XdUR,S S :Xa0US :Xa*[R."[R0"U5S S9n O[R."XS9n SSS5 O6[3UR,U5n OU (aU"X5O[Rn [5W U5$![an[ [U55UeSnAff=f!,(df  NA=f)a Parameters ---------- values : ndarray axis : int, optional skipna : bool, default True 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, 2]) >>> nanops.nanmedian(s.values) 2.0 rWNcL>Uc [U5nOU)nT(d%UR5(d[R$[R "5 [R "SS[5 [R"X5nSSS5 U$!,(df  W$=f)NrAll-NaN slice encountered) r!rrrHrcatch_warningsfilterwarningsRuntimeWarning nanmedian)r_maskresrqs r* get_mediannanmedian..get_medians~ =!HEFEeiikk66M  $ $ &  # #5~ ,,qx(C '  ' &  s 5B B#)rtrstringmixedzCannot convert to numericrrrr rT)keepdimsrr&)r4rrrr infer_dtyperPrrQstrr writeablerrrHrwrapply_along_axisrrrrrrsqueeze_get_empty_reduction_resultr) rLrprqrtusing_nan_sentinelrr4inferrederrnotemptyrs ` r*rrs6 **c1Bddl  LLEvvDTJLF ||C <<6 !v.H../& EFF /]]4(F $"2||%%[[]Fvv {{H{{Q4+ ))*FC,,.++ "=~ Q1, Q1,!ll2::f+=M ll6=/.$.fllDAC+3j& e $$U /CH%3 . /&/.s%"H,B I, I6I  I I!c[R"U5n[R"[U55n[R"X#U:g[R S9nUR [R5 U$)z The result from a reduction on an empty ndarray. Parameters ---------- shape : Tuple[int, ...] axis : int Returns ------- np.ndarray r)rrarangeruemptyrfillrH)rrpshpdimsrets r*r r CsS ((5/C 99SZ D ((3t|$BJJ 7CHHRVV Jr,c[XX$S9nXTRU5- n[U5(a(XS::a [Rn[RnXV4$[ [R U5nXS:*nUR5(aJ[R"Xa[R5 [R"XQ[R5 XV4$)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 r) rr2rrrHrrrMr) values_shapertrpddofr4rds r*_get_counts_nanvarr0Zs:  D >E 4  A =FFEA 8O RZZ'} 88:: JJq ' JJuBFF + 8Or,rr.rprqr.rtc URS:XaURS5nURn[XUS9up[R"[ XX#US95n[ Xe5$)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 zM8[ns]r)rtr2)r4rrrsqrtnanvarr)rLrprqr.rt orig_dtypers r*nanstdr7sXH||xX&JvD9LF WWVFfdS TF  ,,r,m8cURn[XU5nURS;a&URS5nUb[R X'URRS:Xa$[ URXAX0R5upgO[ URXAU5upgU(a*Ub'UR5n[R"XS5 [URU[RS95U- nUb[R"X5n[X- S-5n Ub[R"XS5 U RU[RS9U- n URS:XaU RUSS9n U $) 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 rrrWr)rpr4rFr)r4rrrrrHr0rrrrrr expand_dims) rLrprqr.rtr4rr/avgsqrrs r*r5r5sAJ LLE 64 0D zzTt$  66FL ||C%fllDllSq%fllDE $" 6# &**$bjj*A BU JC nnS' 3>> from pandas.core import nanops >>> s = pd.Series([1, np.nan, 2, 3]) >>> nanops.nansem(s.values) 0.5773502691896258 r2rWr) r5rr4rrrMrrHr0rr4)rLrprqr.rtrrvars r*nansemr?sL 6VTB 64 0D ||Ct$ d&488::vv !&,,D,,OHE 64 HC 773<"''%. ((r,cf^^[ST3S9[SSSS.SUU4Sjjj55nU$)NrH)rlTrc>URS:Xa [X5$[XTUS9up[UT5"U5n[ XAX0R 5nU$)Nrrrt)rwryrrrr)rLrprqrtrrmeths r* reduction_nanminmax..reduction;sW ;;! $V2 2" > &t, t\\B r,r)rir)rCrrDs`` r* _nanminmaxrF:sfc$L) $-1   + *" r,minr)rmax-infc\[USSUS9upURU5n[XAX25nU$)ax 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) 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]) TrIrB)rargmax_maybe_arg_null_outrLrprqrtrs r* nanargmaxrNU8LvtFNLF ]]4 F!t >> from pandas.core import nanops >>> arr = np.array([1, 2, 3, np.nan, 4]) >>> nanops.nanargmin(arr) 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]) TrrB)rargminrLrMs r* nanargminrRrOr,c`[XU5nURRS:wa(URS5n[ UR X15nO[ UR X1URS9nU(a+Ub(UR 5n[R"XS5 O/U(d(Ub%UR5(a[R$[R"SSS9 URU[RS9U- nSSS5 Ub[R"WU5nUW- nU(aUb[R"XcS5 US-nXv-nURU[RS9n URU[RS9n [U 5n [U 5n [R"SSS9 XDS - S --US- - XS -- -n SSS5 URn U RS:XaW RU S S 9n [!W [R"5(a2[R$"U S:HSU 5n [RXS:'U $U S:XaU R'S5OU n US:a[R$U $!,(df  GN=f!,(df  N=f)at 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) 1.7320508075688787 rWrrNrrinvaliddividerrg?g?Fr)rr4rrrrrrrrMrHrrrr:_zero_out_fperrrrrr2) rLrprqrtrmeanadjusted adjusted2 adjusted3m2m3rr4s r*nanskewr_s'J 64 0D ||Ct$FLL$5FLL$FLLI $" 6# (TXXZZvv Xh 7zz$bjjz1E9 8 ~~dD)}H $" 81%! I$I t2:: .B t2:: .B  B  B Xh 719,, :rG|L 8 LLE zzSu51&"**%%"'1f-FFqy M #%'Av 1966M MG 8 7( 8 7s$"J >J J J-cZ[XU5nURRS:wa(URS5n[ UR X15nO[ UR X1URS9nU(a+Ub(UR 5n[R"XS5 O/U(d(Ub%UR5(a[R$[R"SSS9 URU[RS9U- nSSS5 Ub[R"WU5nUW- nU(aUb[R"XcS5 US-nUS-nURU[RS9n URU[RS9n [R"SSS9 S US - S--US- US - -- n XDS --US - -U -n US- US - -U S--n SSS5 [W 5n [W 5n [!U [R"5(d7US :a[R$U S:XaURR%S5$[R"SSS9 X- W - nSSS5 URnURS:XaWRUS S 9n[!W[R"5(a0[R&"U S:HSU5n[RXS :'U$!,(df  GN=f!,(df  GN/=f!,(df  N=f)a` 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) -1.2892561983471076 rWrrNrrrTrrWrFr)rr4rrrrrrrrMrHrrrr:rXrrr2r)rLrprqrtrrYrZr[ adjusted4r]m4adj numerator denominatorrr4s r*nankurtrg sJ 64 0D ||Ct$FLL$5FLL$FLLI $" 6# (TXXZZvv Xh 7zz$bjjz1E9 8 ~~dD)}H $" 81%! I1 I t2:: .B t2:: .B Xh 7519""uqyUQY&?@QY'5195: qyUQY/"a%7  8 *I!+.K k2:: . . 1966M ! <<$$Q' ' Xh 7(3. 8 LLE zzSu51&"**%%+*Av6FFqy MY 8 7 8 7( 8 7s$$"K8)9L +L8 L L L*c[XU5nU(aUbUR5nSX'URU5n[XQX@RUS9$)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) 6.0 rr)rrprodrr)rLrprqrsrtrs r*rrjsS@ 64 0D $" [[ F dLLI r,c2UcU$Ub[USS5(d9U(aUR5(agU$UR5(agU$U(aURU5nOURU5nUR5(aSX'U$)NrF)rrrM)rrprtrqna_masks r*rLrLs |  |766599 xxzz Mxxzz M hhtnGhhtnG ;;== FO Mr,cLUcHUbURUR5- nO[R"U5nUR U5$Ub"UR UURU5- nOXn[ U5(aUR U5$URUSS9$)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)rwrrrir2rrr)r-rtrpr4nrs r*rrs0 |   DHHJ&A %Azz!}  4 488D>1"%zz%  <<E< **r,cUcUS:XaU$UGb [U[R5(aUb(URUUR U5- U- S:nO-X1U- S:nUSUX1S-S-n[R "Xg5n[R "U5(au[U5(aa[R"U5(aURS5nO [U5(dURSSS9n[RX'U$SX'U$U[LaQ[X2U5(a@[USS5n[U5(aURS 5nU$[RnU$) za Returns ------- Dtype The product of all elements on a given axis. ( NaNs are treated as 1) Nrrc16rFrr4rH)rrrrr broadcast_torMr iscomplexobjrrrHrcheck_below_min_countrr2) rrprtrrs null_mask below_count new_shape result_dtypes r*rrs^ | Q  Jvrzz::  D)DHHTN:YF!KI + 1A5Ket uAXZ'88I ?I 66)  ''??6**#]]51F'//#]]4e]T"X5S$Nrr)rrrs r*rget_corr_func..funcXsa#A& &r,spearman) spearmanrc>T"X5S$rr)rrrs r*rr_sQ?1% %r,r}c4[R"X5S$)Nrr)rcorrcoef)rrs r*rres;;q$T* *r,zUnknown method 'z@', expected one of 'kendall', 'spearman', 'pearson', or callable) scipy.statsrrcallablerQ)r~rrrs @@r*rrRsu* ' : ) & 9  + &    6(#8 8 r,)rr.cT[U5[U5:wa [S5eUcSn[U5[U5-nUR5(dXnXn[U5U:a[R $[ U5n[ U5n[R"XUS9S$)Nz&Operands to nancov must have same sizerr1r)rurr!rrrHrcov)rrrr.rs r*nancovrrs 1vQEFF !HuQx E 99;; H H 1v vv AA 66!T "4 ((r,c[U[R5(aURRS;a!UR [R 5nU$UR[:Xa[R"U5nUS;a[SUS35eUR [R5n[R"[R"U55(d URnU$U$[!U5(dR[#U5(dB[%U5(d2[U[&5(a[SUS35e[)U5nU$U$![[4aF UR [R 5nU$![an[SUS35UeSnAff=ff=f![[4a2 [+U5nU$![an[SUS35UeSnAff=ff=f)NrrzCould not convert rzCould not convert string 'z ' to numeric)rrrr4rrrrr rrP complex128rMimagrealrQrrrrfloatcomplex)rr"r#s r*rrs!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 F7F4/F F0F++F00F47G9 G G5 G00G55G9c [RS[R4[RR[R *[R4[R S[R4[RR[R [R40Uup4URRS;deU(ao[URR[R[R45(d,UR5n[U5nX5U'U"USS9nXGU'U$U"USS9nU$)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?grrr)rcumprodrHmaximum accumulatercumsumminimumr4rr@r2rbool_rr)rL accum_funcrqmask_amask_bvalsrtrs r* na_accum_funcrs S"&&M 0 C= /   NF <<  D (( (j!2!2RZZ4JKK{{}DzT Dq)t  MF+ Mr,)T)r)rbr_r`)r4rrlrr_rbra)NN)r4rrz Scalar | None)rLrrqrbrtrr_r)NNN) rLrrqrbrrrz str | Nonertrr_z/tuple[np.ndarray, npt.NDArray[np.bool_] | None])r4np.dtyper_r)r4rr_rbr&)r4r)rrr_r)rLrrprr_zScalar | np.ndarray) rLrrprrqrbrtrr_rb) rLrrprrqrbrsintrtrr_r) rz+np.ndarray | np.datetime64 | np.timedelta64rprrtznpt.NDArray[np.bool_]rrr_z5np.ndarray | np.datetime64 | np.timedelta64 | NaTType) rLrrprrqrbrtrr_r)rprrqrb)rrrpr r_r) r-rrtrrprr.rr4rr_z-tuple[float | np.ndarray, float | np.ndarray])rprrqrbr.r)rLrrprrqrbr.r) rLrrprrqrbr.rrtrr_r) rLrrprrqrbrtrr_zint | np.ndarray) rrrprrtrrqrbr_znp.ndarray | int) r-rrtrrprr4znp.dtype[np.floating]r_z&np.floating | npt.NDArray[np.floating])r) rnp.ndarray | float | NaTTyperprrtrrtuple[int, ...]rsrr_r)rrrtrrsrr_rb) rrrrr~rr int | Noner_r)r~rr_z)Callable[[np.ndarray, np.ndarray], float]) rrrrrrr.rr_r)rLr rqrbr_r )] __future__rr[rJtypingrrrrnumpyrpandas._configr pandas._libsrr r r pandas._typingr r rrrrrrrpandas.compat._optionalrpandas.util._exceptionsrpandas.core.dtypes.commonrrrrrrrrpandas.core.dtypes.missingrr r!rr'r(r+r.rirzr|rrrrrrrryrrrrrrrr r4rr0r7r5r?rFnanminnanmaxrNrRr_rgrrLrrrsrXrrrrrrr,r*rs" %   ?4     V<$:678>55p( GK !.,) ) $),H)!)^!%)- D D DD D ' D 5 DN 2 &RDE>J )- : : :  : ' :  :@ )- : : :  : ' :  :z $ )- * * *  *  * ' * **Z 7    ; & )- < < <  < ' <  <<~04TPT_%_%D  8hhrzz* // &/ /  /  / 3 /d  *- *-  *-  *-*-Z $  F F F  F  FFR $ )- 1) 1) 1)  1)  1) ' 1) 1)1)h. E& 1 E& 1  )- + + +  + ' +  +b )- + + +  + ' +  +\ $ )- S S S  S ' S  SSl $ )- \ \ \  \ ' \  \\~ $ )- ( ( (  (  ( ' ( ((V   '    >$&88BJJ#7 &+&+ &&+ &+ ! &+ , &+\ - (- - '-  -  - " -` ">KN >A $ !*"       > .@ $ # ))) )  )  ))6! H"r,