2iXddlmZddlZddlZddlmZmZmZddlZddl Z ddl m Z ddl mZmZmZmZddlmZmZmZmZmZmZmZmZmZddlmZddlmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&dd l'm(Z(m)Z)m*Z*erdd l+m,Z,ed d Z-e-duZ.da/dKdLdZ0e0e dGddZ1GddZ2dMdZ3dNdZ4 dO dPdZ5 dQdZ6 dR dSdZ7dTdZ8dUdZ9dVdWdZ:dXdZ;dYdZdddd! dZd#Z?e1d$e;e=ddddd% d[d&Z@ d\d'ZAe2e;dddd! d]d(ZBe2dddd! d^d)ZC d_d*ZDe je jf d`d+ZGe2d,-ddd,dd. dad/ZHe1d$d0e2d,-ddd,dd. dbd1ZIe1d$d0ddd,dd. dcd2ZJd3ZKeKd4d56ZLeKd7d86ZMdddd! ddd9ZNdddd! ddd:ZOe1d$d0e=dddd! d]d;ZPe1d$d0e=dddd! d]d<ZQe1d$d0e=ddddd% ded=ZR dfd>ZSe je jf dgd?ZT dh did@ZU djdAZVdkdBZWe1d$d0dCddD dldEZX dmdFZYe1d$d0dd,dG dndHZZdIZ[dodJZ\y)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)errorsFTctr|ayyN)_BOTTLENECK_INSTALLED_USE_BOTTLENECK)vs I/var/www/html/acx/venv/lib/python3.12/site-packages/pandas/core/nanops.pyset_use_bottleneckr+;szcompute.use_bottleneckc0eZdZdfd ZddZddZxZS)disallowcPt|td|D|_y)Nc3FK|]}t|jywr&)rtype).0dtypes r* z$disallow.__init__..HsIL/44Is!)super__init__tupledtypes)selfr8 __class__s r*r6zdisallow.__init__Fs  I&II r,crt|dxr*t|jj|jS)Nr3)hasattr issubclassr3r1r8)r9objs r*checkzdisallow.checkJs'sG$PCIINNDKK)PPr,cbtjfd}tt|S)Nc4tj||j}tfd|Dr+jj dd}t d|d |i|S#t$r }t|dr t ||d}~wwxYw)Nc3@K|]}j|ywr&)r?)r2r>r9s r*r4z0disallow.__call__.._f..Qs7s4::c?7snanzreduction operation 'z' not allowed for this dtyper) itertoolschainvaluesany__name__replace TypeError ValueErrorr)argskwargsobj_iterf_nameefr9s r*_fzdisallow.__call__.._fNs tV]]_=H7h77++E26+F83OP $)&))  #47+#A,A- s&A.. B7BB functoolswrapsrr)r9rRrSs`` r*__call__zdisallow.__call__Ms,     $Ar{r,)r8rreturnNonerXbool)rRrrXr)rI __module__ __qualname__r6r?rW __classcell__)r:s@r*r.r.EsJQr,r.ceZdZdddZddZy)bottleneck_switchNc  ||_||_yr&)namerN)r9rbrNs r*r6zbottleneck_switch.__init__es  r,cjxs j ttt jddd dfd}tt|S#tt f$rdYMwxYw)NTaxisskipnact jdkDr, jjD]\}}||vs |||<|jdk(r|j d t ||St rn|rlt|j rV|j dd6|jdd|fd|i|}t|r|f||d|}|S|f||d|}|S|f||d|}|S)Nr min_countmaskrerd) lenrNitemssizeget_na_for_min_countr( _bn_ok_dtyper3pop _has_infs) rGrerfkwdskr)resultaltbn_funcbn_namer9s r*rRz%bottleneck_switch.__call__..fqs4;;!# KK--/$DAq}"#Q${{aDHH[$9$A)666l6<<.Q88FD)1HHVT*$V?$?$?F!(!$V!N$v!N!N M !Jd6JTJFMVF$vFFMr,)rG np.ndarrayreAxisInt | Nonerfr[) rbrIgetattrbnAttributeError NameErrorrUrVrr)r9rurRrvrws`` @@r*rWzbottleneck_switch.__call__is))+s|| b'*G  $( % % !%  %  % NAqzW * G sA**A>=A>r&)rXrY)rurrXr)rIr\r]r6rWr,r*r`r`ds 0r,r`c4|tk7rt|s|dvSy)N)nansumnanprodnanmeanF)objectr)r3rbs r*roros" 259;;; r,c t|tjr2|jdvr$t j |j dS tj|jS#ttf$rYywxYw)N)f8f4KF) isinstancenpndarrayr3r has_infsravelisinfrHrKNotImplementedError)rts r*rqrqsk&"**% <<< '<< S 12 2xx##%% * +s"A11BBc||St|r8|tjS|dk(rtjStj S|dk(rtj St S)z9return the correct fill value for the dtype of the values+inf) _na_ok_dtyperrCinfr i8maxr )r3 fill_valuefill_value_typs r*_get_fill_valuersZE  !66M v %66MFF7N 6 !yy r,c|>|jjdvry|s|jjdvr t|}|S)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)r3kindr)rGrfris r*_maybe_get_maskrsAB | <<   % V\\&&$..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. iufcbrNr)r3rrrndimshaperfull)rGrer result_shapes r*rnrns"||G#y)#FLL1J {{a ||ET*V\\$(*-EE ww|Zv||DDr,cftjdddfd}tt|S)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. Nrec |dk(r|jdk(r|jdr|jddz |jdkDr|jtt fvrt |}|jdB|jd}tt|Dcgc]}||fd||i|}}n|Dcgc] }|fi| }}tj|S|fd|i|Scc}wcc}w)Nr C_CONTIGUOUSrrire) rflagsrr3rr[listrmrprangerjrarray) rGrerNarrsriiresultsxrs r*newfuncz&maybe_operate_rowwise..newfuncs AI q  ^,a4'6<<?: VTN2?Da9tAw9&97;;4,V,;;88G$ $F0000B11, 7 r,rc6|jjdvr||j|S|jjdk(r tdt ||d|\}}|jt k(r|j t}|j|S)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'Frri)r3rrHrKrrrr[rGrerfri_s r*nananyrsD||E!dlzz$ ||CJKKFFu4HIFA||vt$ ::d r,c6|jjdvr||j|S|jjdk(r tdt ||d|\}}|jt k(r|j t}|j|S)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)r3rallrKrrrr[rs r*nanallrsD||E!dlzz$ ||CJKKFFt$GIFA||vt$ ::d r,M8)rerfrhric:|j}t||d|\}}t|}|jdk(r|}n2|jdk(r#t jtj }|j ||}t||||j|}|S)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) rrrRrrrh) r3rrrrrsum_maybe_null_outr)rGrerfrhrir3 dtype_sumthe_sums r*rrQsD LLEvv!$GLFDu%I zzS s HHRZZ( jjYj/GgtT6<<9UG Nr,cLt|tjrG|jdj |j }|j |}t||<|S|j r2tjtj |j S|S)Nrr) rrrrrr3rHr r)rtrerir axis_masks r*rrs &"**%t$))+*;*;<HH$H'  y M xx~"";#4#455 Mr,c|jtk(r!t|dkDr|t|dd|||j}t ||d|\}}t |}t jt j}|jdvr$t jt j}nE|jdvr$t jt j}n|jdk(r|}|}t|j||| }|j|| }t|}|ut|d d rhtt j|}t j d 5||z } ddd|dk(} | j#rt j$ | < S|dkDr||z nt j$} | S#1swYOxYw)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) rNrdrrriurRrrFignore)r)r3rrjrrrrrr _get_countsrr_ensure_numericrzrrerrstaterHrC) rGrerfrir3r dtype_countcountrthe_meanct_masks r*rrsB||v#f+"5$,u D8 LLEvv!$GLFDu%I((2::&K zzTHHRZZ( t HHRZZ( s    dD DEjjYj/Gg&G GGVU;RZZ' [[X & 'H '1* ;;= "HW  O',ai7U?RVV O ' 's .GG cv|jjdk(xr|du}ddfd }|j}t||d\}}|jjdk7rM|jtk(r(t j |}|dvrt d|d |jd}|s;|9|jjs|j}tj||<|j} |j d kDr|| rÉstj"|||} nt%j&5t%j(d d t*|j,d d k(r|d k(s|j,d d k(r0|d k(r+tj.tj0|d } ntj.||} dddn2t3|j,|} n| r |||ntj} t5 |S#t$r}t t||d}~wwxYw#1swY;xYw)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 rRNc^| t|}n|}s |jstjSt j 5t j ddtt j ddttj||}ddd|S#1swYSxYw)NrAll-NaN slice encounteredzMean of empty slice) r rrrCwarningscatch_warningsfilterwarningsRuntimeWarning nanmedian)r_maskresrfs r* get_medianznanmedian..get_medians =!HEFEeiik66M  $ $ & )  # #5~   # #H.C^ T,,qx(C  )  ) s AB""B,)rirstringmixedzCannot convert to numericrrrrrT)keepdimsrr&)rrx)r3rrrr infer_dtyperKrrLstrr writeablerrrCrlrapply_along_axisrrrrrrsqueeze_get_empty_reduction_resultr) rGrerfriusing_nan_sentinelrr3inferrederrnotemptyrs ` r*rrsB **c1Bddl LLEvvDTJLFD ||C <<6 !v.H../& EFF /]]4(F $"2||%%[[]Fvvt {{H {{Q4+ ))*dFC,,. >++ "=~ Q1, Q1,!ll2::f+=M ll6= > >$.fllDAC+3j& e $$Y /CH%3 . /* > >s%H 6B H/ H,H''H,/H8ctj|}tjt|}tj|||k7tj }|j tj|S)z The result from a reduction on an empty ndarray. Parameters ---------- shape : Tuple[int, ...] axis : int Returns ------- np.ndarray r)rrarangerjemptyrfillrC)rreshpdimsrets r*r r BsU ((5/C 99SZ D ((3tt|$BJJ 7CHHRVV Jr,ct||||}||j|z }t|r)||kr tj}tj}||fSt tj |}||k}|jrJtj||tjtj||tj||fS)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) rr1rrrCrrrHr) values_shaperireddofr3rds r*_get_counts_nanvarrYs:  dD >E  4  A D=FFEA !8O RZZ'} 88: JJq$ ' JJudBFF + !8Or,rrrerfrric :|jjdk(r7tj|jd}|j d|d}|j}t |||\}}tj t|||||}t||S)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[])rir) r3rr datetime_datarrsqrtnanvarr)rGrerfrriunit orig_dtyperts r*nanstdr'sH||C -a0s4&]+JvvD9LFD WWVFf4dS TF  ,,r,m8c~|j}t|||}|jdvr&|jd}|tj ||<|jjdk(r't |j||||j\}}nt |j|||\}}|r)|'|j}t j||dt|j|tj|z }|t j||}|jjdk(rtt||z dz} nt||z dz} |t j| |d| j|tj|z } |jdk(r| j|d } | S) a 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 rrrRr)rer3crFr)r3rrrrrCrrrrrrr expand_dimsabs) rGrerfrrir3rravgsqrrts r*r$r$sJ LLE 664 0D zzTt$  66F4L ||C%fllD$fllSq%fllD$Eq $" 64# &**$bjj*A BU JC nnS$' ||Cc#,/145sV|12  3a WW$bjjW 1A 5F  zzSu51 Mr,ct|||||t|||}|jjdk7r|j d}|s"| |j rt jSt|j||||j\}}t|||||}t j|t j|z S)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) rrRr) r$rr3rrrHrrCrrr#)rGrerfrrirrvars r*nansemr1 sL 6V$TB 664 0D ||Ct$ d&488:vv !&,,dD&,,OHE1 d64 HC 773<"''%. ((r,cftdtdddd dfd}|S)NrC)rbTrc|jdk(r t||S|j}t|||\}}t ||}t ||||j |jdv}|S)Nrrrir)r)rlrnr3rrzrrr)rGrerfrir3rtrmeths r* reductionz_nanminmax..reduction?s| ;;! $VT2 2 " F> '&t, D$ 5::;M  r,r)r`r)r5rr6s`` r* _nanminmaxr7>sac$L) $-1   + *( r,minr)rmax-infcht|dd|\}}|j|}t||||}|S)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]) Tr:r4)rargmax_maybe_arg_null_outrGrerfrirts r* nanargmaxr?\>LvtFNLFD ]]4 F!tV >> 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]) Trr4)rargminr=r>s r* nanargminrCr@r,ct|||}|jjdk7r)|jd}t |j ||}n#t |j |||j}|r*|(|j }tj||dn$|s"| |jrtjStjdd5|j|tj|z }ddd|tj|}|z }|r|tj||d|dz}||z}|j|tj} |j|tj} tj|j!|d } tj"| jj$} | | zdz|z} | | zd z|z}t'| | } t'| |} tjdd5||d z d zz|dz z | | dzz z}ddd|j}|jdk(rj|d}t)tj*r2tj,| dk(d|}tj||d k<|S| dk(r|j/dn|}|d krtjS|S#1swYxYw#1swYxYw)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) rRrrNrrinvaliddividerinitialrg?g?Fr)rr3rrrrrrrrHrCrrrr+r,r9finfoeps_zero_out_fperrrrrr1)rGrerfrirmeanadjusted adjusted2 adjusted3m2m3max_absrMconstant_tolerance2constant_tolerance3rtr3s r*nanskewrXsJ 664 0D ||Ct$FLL$5FLL$FLLI $" 64# (TXXZvv Xh 7:zz$bjjz1E9: ~~dD)}H $" 8T1%! IH$I t2:: .B t2:: .BffVn  s 3G ((288  C'Ma/58'Ma/58 0 1B 0 1B Xh 7M519,, :rBG|LM LLE zzSu51&"**%"'1f-FFuqy M #%'Av 1966M MI::*MMs%K+K8+K58Lct|||}|jjdk7r)|jd}t |j ||}n#t |j |||j}|r*|(|j }tj||dn$|s"| |jrtjStjdd5|j|tj|z }ddd|tj|}|z }|r|tj||d|dz}|dz}|j|tj} |j|tj} tj|j!|d } tj"| jj$} | | zdz|z} | | zd z|z}t'| | } t'| |} tjdd5d |d z dzz|dz |d z zz }||d zz|d z z| z}|dz |d z z| dzz}dddt)tj*s5|d krtjS|dk(r|jj-dStjdd5|z z }ddd|j}|jdk(rj|d}t)tj*r0tj.|dk(d|}tj||d k<|S#1swYUxYw#1swYxYw#1swYxYw)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) np.float64(-1.2892561983471076) rRrrNrrrErrHrIrKrFr)rr3rrrrrrrrHrCrrrr+r,r9rLrMrNrrr1r)rGrerfrirrOrPrQ adjusted4rSm4rUrMrVconstant_tolerance4adj numerator denominatorrtr3s r*nankurtrasJ 664 0D ||Ct$FLL$5FLL$FLLI $" 64# (TXXZvv Xh 7:zz$bjjz1E9: ~~dD)}H $" 8T1%! I1 I t2:: .B t2:: .B0ffVn  s 3G ((288  C'Ma/58'Ma/58 0 1B 0 1B Xh 78519""uqyUQY&?@UQY'5195: qyUQY/"a%7 8 k2:: . 1966M ! <<$$Q' ' Xh 7/[(3./ LLE zzSu51&"**%+*Av6FFuqy ME::T88//s$%M:M M,MM),M5ct|||}|r||j}d||<|j|}t||||j|S)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)rGrerfrhrirts r*rrs[@ 664 0D $"t [[ F dFLLI r,cT||S| t|dds<|r|jr td|s|jr td|S|r*|j|jr td|s*|j|jr td|S)NrFzEncountered all NA valuesz)Encountered an NA value with skipna=False)rzrrLrH)rtrerirfs r*r=r=s |  |76659 dhhj89 9DHHJHI I M DHHTN&&(455 **,DEE Mr,cB|F||j|jz }ntj|}|j |S|"|j ||j|z }n||}t |r|j |S|j|dS)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)rlrrrcr1rrr)rrirer3nrs r*rrs0 |   DHHJ&A %Azz!}  4 488D>1T"%zz%  <<E< **r,c||dk(r|S|t|tjr|(|j||j |z |z dk}n/|||z dk}|d|||dzdz}tj ||}tj |rw|r t||<|St|rZtj|r|jd}nt|s|jdd}tj||<|Sd||<|S|turHt|||r;t|dd} t| r| j!d }|Stj}|S) zu Returns ------- Dtype The product of all elements on a given axis. ( NaNs are treated as 1) Nrrc16rFrr3rC)rrrrr broadcast_torHr r iscomplexobjrrrCrcheck_below_min_countrzr1) rtrerirrhr null_mask below_count new_shape result_dtypes r*rrsk | Q  Jvrzz:  D)DHHTN:YF!KI + 1A5Ket uTAXZ'88I Y?I 66) $(y!& M%"&)??6*#]]51F'/#]]4e]3>r,pearson)method min_periodsc@t|t|k7r td|d}t|t|z}|js ||}||}t||krtj St |}t |}t|}|||S)z a, b: ndarrays z'Operands to nancorr must have same sizer)rjAssertionErrorr rrrCr get_corr_func)abrwrxvalidrRs r*nancorrrOs 1vQFGG !HuQx E 99; eH eH 1v vv AAfA Q7Nr,c|dk(r ddlmfd}|S|dk(r ddlmfd}|S|dk(rd }|St|r|St d |d ) Nkendallr) kendalltauc||dSrsr~)r|r}rs r*rzget_corr_func..funcusa#A& &r,spearman) spearmanrc||dSrsr~)r|r}rs r*rzget_corr_func..func|sQ?1% %r,rvc4tj||dS)Nrr)rcorrcoef)r|r}s r*rzget_corr_func..funcs;;q!$T* *r,zUnknown method 'z@', expected one of 'kendall', 'spearman', 'pearson', or callable) scipy.statsrrcallablerL)rwrrrs @@r*r{r{osr* ' : ) & 9  + &   6(#8 8 r,)rxrcNt|t|k7r td|d}t|t|z}|js ||}||}t||krtj St |}t |}t j|||dS)Nz&Operands to nancov must have same sizerrr)rjrzr rrrCrcov)r|r}rxrr~s r*nancovrs 1vQEFF !HuQx E 99; eH eH 1v vv AA 66!QT "4 ((r,ct|tjr|jjdvr!|j tj }|S|jtk(r~tj|}|dvrtd|d |j tj}tjtj|s|j}|S|St!|sCt#|s8t%|s-t|t&rtd|d t)|}|S|S#ttf$rF |j tj }n!#t$r}td|d|d}~wwxYwY|SwxYw#ttf$r1 t+|}Y|S#t$r}td|d|d}~wwxYwwxYw)NrrzCould not convert rzCould not convert string 'z ' to numeric)rrrr3rrrrr rrK complex128rHimagrealrLrrrr floatcomplex)rrrs r*rrs!RZZ 77<<5 $A< H;WW q)H.."4QC{ CDD HHR]]+vvbggaj)A H1HqkZ]jm a 8<HI I NaA H1H-z* RR,A!R#&8;$GHcQR( H- R:& N NAJ H N"4QC{ CD#M N  Ns`D7( F7F E'&F ' F0FFF  F G F-- G 6GG  Gc tjdtjftjjtj tjftj dtjftjjtj tjfi|\}}|jjdvsJ|rot|jjtjtjfs1|j}t|}|||<||d}|||<|S||d}|S)a 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?rHrrr)rcumprodrCmaximum accumulatercumsumminimumr3rr=r1rbool_rr)rG accum_funcrfmask_amask_bvalsrirts r* na_accum_funcrs S"&&M 0 C= /   NFF <<  D (( (j!2!2RZZ4JK{{}DzT Dq)t  MF+ Mr,)T)r)r[rXrY)r3rrbr rXr[rZ)NN)r3rrz Scalar | None)rGrxrfr[rirrXr)NNN) rGrxrfr[rrrz str | NonerirrXz/tuple[np.ndarray, npt.NDArray[np.bool_] | None])r3np.dtyperXr)r3rrXr[r&)r3r)rrrXr)rGrxreryrXzScalar | np.ndarray) rGrxreryrfr[rirrXr[) rGrxreryrfr[rhintrirrXz*npt.NDArray[np.floating] | float | NaTType) rtz+np.ndarray | np.datetime64 | np.timedelta64reryriznpt.NDArray[np.bool_]rrxrXz5np.ndarray | np.datetime64 | np.timedelta64 | NaTType) rGrxreryrfr[rirrXr)rGrxreryrfr[rXfloat | np.ndarray)rrrer rXrx) rrrirreryrrr3rrXz-tuple[float | np.ndarray, float | np.ndarray])reryrfr[rr)rGrxreryrfr[rr) rGrxreryrfr[rrrirrXr) rGrxreryrfr[rirrXzint | np.ndarray) rGrxreryrfr[rhrrirrXr) rtrxreryrirrfr[rXznp.ndarray | int) rrrirreryr3znp.dtype[np.floating]rXz&np.floating | npt.NDArray[np.floating])rF)rtnp.ndarray | float | NaTTypereryrirrtuple[int, ...]rhrrr[rXr)rrrirrhrrXr[)rur) r|rxr}rxrwrrx int | NonerXr)rwrrXz)Callable[[np.ndarray, np.ndarray], float]) r|rxr}rxrxrrrrXr)rGr rfr[rXr )] __future__rrUrEtypingrrrrnumpyrpandas._configr pandas._libsrr r r pandas._typingr r rrrrrrrpandas.compat._optionalrpandas.core.dtypes.commonrrrrrrrrpandas.core.dtypes.missingrrr collections.abcr!r{r'r(r+r.r`rorqrrrrrrrrnrrrrrrrr r3rrr'r$r1r7nanminnanmaxr?rCrXrarr=rrrkrNrr{rrrr~r,r*rsB" %   ?    ( 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  8bhhrzz* // &/ /  /  / 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$,288BJJ#7 &+&+ &&+ &+ ! &+ , &+\ 1 (1 1 '1  1  1  1"1h ">KN >? $ !*"       > .@ $ # ))) )  )  ))6! H"r,