A>iXFSSKJr SSKrSSKrSSKJrJrJr SSKrSSK r SSK J r SSK JrJrJrJr SSKJrJrJrJrJrJrJrJrJr SSKJr SSKJrJ r J!r!J"r"J#r#J$r$J%r%J&r& SS K'J(r(J)r)J*r* \(aSS K+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%.SeS=jj55rRSfS>jrS\ R"\ R54SgS?jjrTShSiS@jjrUSjSAjrVSkSBjrW\1"S$S05SCSSD.SlSEjj5rXSmSFjrY\1"S$S05SS,SG.SnSHjj5rZSIr[SoSJjr\g)p) 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 [(aUqggN)_BOTTLENECK_INSTALLED_USE_BOTTLENECK)vs Q/var/www/html/land-tabula/venv/lib/python3.13/site-packages/pandas/core/nanops.pyset_use_bottleneckr+;szcompute.use_bottleneckc@^\rSrSrSU4SjjrSSjrSSjrSrU=r$) disallowEcP>[TU]5 [SU55Ulg)Nc3L# UHn[U5Rv M g7fr&)rtype).0dtypes r* $disallow.__init__..HsI&L/44&s"$)super__init__tupledtypes)selfr: __class__s r*r8disallow.__init__Fs  I&II r,c|[US5=(a* [URRUR5$)Nr4)hasattr issubclassr4r2r:)r;objs r*checkdisallow.checkJs'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..Qs7hs4::c??hs!nanzreduction operation 'z' not allowed for this dtyper) itertoolschainvaluesany__name__replace TypeError ValueErrorr)argskwargsobj_iterf_nameefr;s r*_fdisallow.__call__.._fNs t]]_=H7h777++E26+F83OP $)&))  #47++#A,A- s,A44 B#> BB# functoolswrapsrr)r;rWrXs`` r*__call__disallow.__call__Ms,     $Ar{r,)r:)r:rreturnNoner_bool)rWrr_r) rN __module__ __qualname____firstlineno__r8rBr]__static_attributes__ __classcell__)r<s@r*r.r.EsJQr,r.c,\rSrSrSSSjjrSSjrSrg) bottleneck_switchdNc XlX lgr&)namerS)r;rlrSs r*r8bottleneck_switch.__init__es   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__..fqs4;;!# 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__is))+s|| b'*G  $( % % !%  % %  % NAqzW * G sA33BB)rSrlr&)r_r`)rrr_r)rNrcrdrer8r]rfr,r*ririds 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 v %66MFF7N 6 !yy r,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)r4rrrndimshaperfull)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 >US:XaURS:XaURS(aURSS- URS:aUR[[ 4;a[ U5nURS5bCURS5n[[U55Vs/sHnT"X54SXE0UD6PM nnOUVs/sH nT"U40UD6PM nn[R"U5$T"U4SU0UD6$s snfs snf)Nr C_CONTIGUOUSrrtrp) rflagsrr4rrblistrxr{rangerurarray) rLrprSarrsrtiresultsxrs r*newfunc&maybe_operate_rowwise..newfuncs AI q  ^,a4'6<<?: VTN2B111, 7 r,rc6URRS;aUcURU5$URRS:Xa [S5e[ 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) 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'Frrt)r4rrMrPrrrrbrLrprqrt_s r*nananyrsD||E!dlzz$ ||CJKKFu4HIF||vt$ ::d r,c6URRS;aUcURU5$URRS:Xa [S5e[ 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) 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)r4rallrPrrrrbrs r*nanallrsD||E!dlzz$ ||CJKKFt$GIF||vt$ ::d r,M8)rprqrsrtc$URn[XSUS9up[U5nURS:XaUnO4URS:Xa$[R"[R 5nUR XS9n[XqX@RUS9nU$)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) rrrWrrrs) r4rrrrrsum_maybe_null_outr)rLrprqrsrtr4 dtype_sumthe_sums r*rrQs~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 xx~"";#4#455 Mr,cUR[:Xa[U5S:aUc [USSXS9 URn[ XSUS9up[ U5n[ R"[ R5nURS;a%[ R"[ R5nOIURS;a%[ R"[ R5nOURS:XaUnUn[URX1US 9nURXS 9n[U5nUb|[US S 5(aj[[ RU5n[ R "S S 9 X- n SSS5 US:Hn U R#5(a[ R$W U 'W $US:aX- O[ R$n 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) np.float64(1.5) rNrorrriurWrrFignore)r)r4rrurrrrrr _get_countsrr_ensure_numericrrrerrstaterMrH) rLrprqrtr4r dtype_countcountrthe_meanct_masks r*rrsoB||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 ,G Gc^URRS:H=(a USLnSSU4SjjjnURn[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 | 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 rWNc>Uc [U5nOU)nT(d%UR5(d[R$[R "5 [R "SS[5 [R "SS[5 [R"X5nSSS5 U$!,(df  W$=f)NrAll-NaN slice encounteredzMean of empty slice) r rrrHwarningscatch_warningsfilterwarningsRuntimeWarning nanmedian)r_maskresrqs r* get_mediannanmedian..get_medians =!HEFEeiikk66M  $ $ &  # #5~   # #H.C^ T,,qx(C ' ' & s AB00 B?)rtrstringmixedzCannot convert to numericrrrr rT)keepdimsrr&)rr)r4rrrr infer_dtyperPrrQstrr writeablerrrHrwrapply_along_axisr r r r rrsqueeze_get_empty_reduction_resultr) rLrprqrtusing_nan_sentinelrr4inferrederrnotemptyrs ` r*rrsB **c1Bddl 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%$H.B I. I8I  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*rrBsS ((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_nanvarr-Ys:  D >E 4  A =FFEA 8O RZZ'} 88:: JJq ' JJuBFF + 8Or,rr+rprqr+rtc *URRS:Xa8[R"UR5SnUR SUS35nURn[ XUS9up[R "[XX#US95n[Xv5$)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 rrzm8[])rtr/) r4rr datetime_datarrsqrtnanvarr)rLrprqr+rtunit orig_dtypers r*nanstdr7sH||C -a0s4&]+JvD9LF WWVFfdS TF  ,,r,m8cvURn[XU5nURS;a&URS5nUb[R X'URRS:Xa$[ URXAX0R5upgO[ URXAU5upgU(a*Ub'UR5n[R"XS5 [URU[RS95U- nUb[R"X5nURRS:Xa[[X- 5S-5n O[X- S-5n Ub[R"XS5 U RU[RS9U- n URS:XaU RUSS 9n 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)rpr4crFr)r4rrrrrHr-rrrrrr expand_dimsabs) rLrprqr+rtr4rr,avgsqrrs r*r4r4siJ 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[XX#US9 [XU5nURRS:waUR S5nU(d(Ub%UR 5(a[ R$[URXAX0R5upV[XX#US9n[ R"U5[ R"U5- $)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/rWr) r4rr4rrrMrrHr-rr3)rLrprqr+rtrrvars r*nansemrA sL 6VTB 64 0D ||Ct$ d&488::vv !&,,D,,OHE 64 HC 773<"''%. ((r,cf^^[ST3S9[SSSS.SUU4Sjjj55nU$)NrH)rlTrc>URS:Xa [X5$URn[XTUS9up[ UT5"U5n[ XQX0R URS;S9nU$)Nrrrtr)r)rwryr4rrrrr)rLrprqrtr4rrmeths r* reduction_nanminmax..reduction?sp ;;! $V2 2 " > &t, $ 5::;M  r,r)rir)rErrFs`` r* _nanminmaxrH>sfc$L) $-1   + *( r,minr)rmax-infc\[USSUS9upURU5n[XAX25nU$)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]) TrKrD)rargmax_maybe_arg_null_outrLrprqrtrs r* nanargmaxrP\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]) TrrD)rargminrNrOs r* nanargminrTrQr,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 [R"U5R!US S 9n [R""U R5R$n X-S-U-n X-S -U-n['X5n ['X5n [R"SSS9 XDS - S --US- - XS-- -nSSS5 URnURS:XaWRUSS9n[)W[R*5(a2[R,"U S:HSU5n[RXS :'U$U S:XaUR/S5OUnUS :a[R$U$!,(df  GN=f!,(df  N=f)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) rWrrNrrinvaliddividerinitialrg?g?Fr)rr4rrrrrrrrMrHrrrr;r<rJfinfoeps_zero_out_fperrrrrr2)rLrprqrtrmeanadjusted adjusted2 adjusted3m2m3max_absr^constant_tolerance2constant_tolerance3rr4s r*nanskewrisJ 64 0D ||Ct$FLL$5FLL$FLLI $" 6# (TXXZZvv Xh 7zz$bjjz1E9 8 ~~dD)}H $" 81%! I$I t2:: .B t2:: .BffVn  s 3G ((288  CMa/58Ma/58  1B  1B Xh 719,, :rG|L 8 LLE zzSu51&"**%%"'1f-FFqy M #%'Av 1966M MI 8 7* 8 7s$"K/ L/ K> Lc"[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"U5R!US S 9n [R""U R5R$n X-S-U-n X-S -U-n['X5n ['X5n [R"SSS9 S US - S--US- US - -- nXDS --US - -U -nUS- US - -U S--nSSS5 [)W[R*5(d7US :a[R$US:XaURR-S5$[R"SSS9 WU- W- nSSS5 URnURS:XaWRUSS9n[)W[R*5(a1[R."US:HSU5n[RUUS :'U$!,(df  GN]=f!,(df  GN=f!,(df  N=f)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) rWrrNrrrVrrYrZr\rFr)rr4rrrrrrrrMrHrrrr;r<rJr]r^r_rrr2r)rLrprqrtrr`rarb adjusted4rdm4rfr^rgconstant_tolerance4adj numerator denominatorrr4s r*nankurtrrsJ 64 0D ||Ct$FLL$5FLL$FLLI $" 6# (TXXZZvv Xh 7zz$bjjz1E9 8 ~~dD)}H $" 81%! I1 I t2:: .B t2:: .B0ffVn  s 3G ((288  CMa/58Ma/58  1B  1B Xh 7519""uqyUQY&?@QY'5195: qyUQY/"a%7  8 k2:: . . 1966M ! <<$$Q' ' Xh 7[(3. 8 LLE zzSu51&"**%%+*Av6FFuqy ME 8 7T 8 7 8 7s$$"M!9M. N M+. M= Nc[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) np.float64(6.0) rr)rrprodrr)rLrprqrsrtrs r*rrsS@ 64 0D $" [[ F dLLI r,cUcU$Ub[USS5(dPU(a UR5(a [S5eU(d UR5(a [S5eU$U(a/URU5R5(a [S5eU(d/URU5R5(a [S5eU$)NrFzEncountered all NA valuesz)Encountered an NA value with skipna=False)rrrQrM)rrprtrqs r*rNrNs |  |766599 dhhjj89 9DHHJJHI I M DHHTN&&((455 **,,DEE 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)rwrrrtr2rrr)r*rtrpr4nrs r*rrs0 |   DHHJ&A %Azz!}  4 488D>1"%zz%  <<E< **r,c UcUS:XaU$UGb[U[R5(aUb(URUUR U5- U- S:nO-X1U- S:nUSUX1S-S-n[R "Xx5n[R "U5(aU(a [X'U$[U5(aa[R"U5(aURS5nO [U5(dURSSS9n[RX'U$SX'U$U[LaQ[X2U5(a@[USS5n [U 5(aU R!S 5nU$[RnU$) za Returns ------- Dtype The product of all elements on a given axis. ( NaNs are treated as 1) Nrrc16rFrr4rH)rrrrr broadcast_torMr r iscomplexobjrrrHrcheck_below_min_countrr2) rrprtrrsr 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]3>r,pearson)method min_periodscJ[U5[U5:wa [S5eUcSn[U5[U5-nUR5(dXnXn[U5U:a[R $[ U5n[ U5n[U5nU"X5$)z a, b: ndarrays z'Operands to nancorr must have same sizer)ruAssertionErrorr rrrHr get_corr_func)abrrvalidrWs r*nancorrrOs 1vQFGG !HuQx E 99;; H H 1v vv AAfA Q7Nr,c^^US:XaSSKJm U4SjnU$US:XaSSKJm U4SjnU$US:XaS nU$[U5(aU$[ S US 35e) Nkendallr) kendalltauc>T"X5S$rr)rrrs r*rget_corr_func..funcusa#A& &r,spearman) spearmanrc>T"X5S$rr)rrrs r*rr|sQ?1% %r,rc4[R"X5S$)Nrr)rcorrcoef)rrs r*rrs;;q$T* *r,zUnknown method 'z@', expected one of 'kendall', 'spearman', 'pearson', or callable) scipy.statsrrcallablerQ)rrrrs @@r*rrosu* ' : ) & 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 sizerr.r)rurr rrrHrcov)rrrr+rs r*nancovrs 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)rrr 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?rYrrr)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_z*npt.NDArray[np.floating] | float | NaTType) rz+np.ndarray | np.datetime64 | np.timedelta64rprrtznpt.NDArray[np.bool_]rrr_z5np.ndarray | np.datetime64 | np.timedelta64 | NaTType) rLrrprrqrbrtrr_r)rLrrprrqrbr_float | np.ndarray)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) rLrrprrqrbrsrrtrr_r) rrrprrtrrqrbr_znp.ndarray | int) r*rrtrrprr4znp.dtype[np.floating]r_z&np.floating | npt.NDArray[np.floating])rF)rnp.ndarray | float | NaTTyperprrtrrtuple[int, ...]rsrrrbr_r)rrrtrrsrr_rb)rr) rrrrrrr int | Noner_r)rrr_z)Callable[[np.ndarray, np.ndarray], float]) rrrrrrr+rr_r)rLr rqrbr_r )] __future__rr[rJtypingrrrr numpyrpandas._configr pandas._libsrr r r pandas._typingr r rrrrrrrpandas.compat._optionalrpandas.core.dtypes.commonrrrrrrrrpandas.core.dtypes.missingrrr collections.abcr!rr'r(r+r.rirzr|rrrrrrrryrrrrrrrrr4rr-r7r4rArHnanminnanmaxrPrTrirrrrNrrr|r_rrrrrrr,r*rs>" %   ?    ( V<$:678>55p( GK !.() ) $),H)!)^!%)- D D DD D ' D 5 DN 2 &RDE>H )- 5 5 5  5 ' 5  5v )- 5 5 5  5 ' 5  5p $ )- * * *  *  * ' *0**Z  7       ;   )- @ @ @  @ ' @  @@F26tRVh% h%!/h%@Dh%h%h%V  8hhrzz* // &/ /  /  / 3 /d  +- +-  +-  +-+-\ $  J J J  J  JJZ $ )- 1) 1) 1)  1)  1) ' 1) 1)1)h4 E& 1 E& 1  )- + + +  + ' +  +b )- + + +  + ' +  +\ $ )- T T T  T ' T  TTn $ )- r r r  r ' r  rrj $ )- ( ( (  (  ( ' ( ((V   '    4$&88BJJ#7 &+&+ &&+ &+ ! &+ , &+\ 1 (1 1 '1  1  1  1"1h ">KN >? $ !*"       > .@ $ # ))) )  )  ))6! H"r,