eh(ddlmZddlZddlZddlmZmZmZddlZddl Z ddl m Z ddl mZmZmZmZddlmZmZmZmZmZmZmZmZmZddlmZddlmZdd l m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(dd l)m*Z*m+Z+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% d[d=ZR ded>ZSe je jf dfd?ZT dg dhd@ZU didAZVdBZWe1d$d0dCddD djdEZX dkdFZYe1d$d0dd,dG dldHZZdIZ[dmdJZ\y)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)errorsFTctr|ayyN)_BOTTLENECK_INSTALLED_USE_BOTTLENECK)vs P/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/pandas/core/nanops.pyset_use_bottleneckr+9szcompute.use_bottleneckc0eZdZdfd ZddZddZxZS)disallowcPt|td|D|_y)Nc3FK|]}t|jywr&)rtype).0dtypes r* z$disallow.__init__..FsIL/44Is!)super__init__tupledtypes)selfr8 __class__s r*r6zdisallow.__init__Ds  I&II r,crt|dxr*t|jj|jS)Nr3)hasattr issubclassr3r1r8)r9objs r*checkzdisallow.checkHs'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..Os7s4::c?7snanzreduction operation 'z' not allowed for this dtyper) itertoolschainvaluesany__name__replace TypeError ValueErrorr)argskwargsobj_iterf_nameefr9s r*_fzdisallow.__call__.._fLs tV]]_=H7h77++E26+F83OP $)&))  #47+#A,A- s&A.. B7BB functoolswrapsrr)r9rRrSs`` r*__call__zdisallow.__call__Ks,     $Ar{r,)r8rreturnNonerXbool)rRrrXr)rI __module__ __qualname__r6r?rW __classcell__)r:s@r*r.r.CsJQr,r.ceZdZdddZddZy)bottleneck_switchNc  ||_||_yr&)namerN)r9rbrNs r*r6zbottleneck_switch.__init__cs  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__..fos4;;!# 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__gs))+s|| b'*G  $( % % !%  %  % NAqzW * G sA**A>=A>r&)rXrY)rurrXr)rIr\r]r6rWr,r*r`r`bs 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'vv w V #99 Kr,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)r3rrr ndimshaperfull)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|jtk7r|jt k7rt |}|jdB|jd}tt|Dcgc]}||fd||i|}}n|Dcgc] }|fi| }}tj|S|fd|i|Scc}wcc}w)Nr C_CONTIGUOUSirrire) rflagsrr3rr[listrmrprangerjrarray) rGrerNarrsriiresultsxrs r*newfuncz&maybe_operate_rowwise..newfuncs AI q  ^,a4'6<<?: & $?Da9tAw9&97;;4,V,;;88G$ $F0000B11. 7 r,rch|jjdvr||j|S|jjdk(r$tjdt t t||d|\}}|jtk(r|jt}|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) 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. stacklevelFrri) r3rrHwarningsr# FutureWarningrrrrr[rGrerfri_s r*nananyrsD||E!dlzz$ ||C  J ')  FFu4HIFA||vt$ ::d r,ch|jjdvr||j|S|jjdk(r$tjdt t t||d|\}}|jtk(r|jt}|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) 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) r3rallrr#rrrrrr[rs r*nanallrsD||E!dlzz$ ||C  J ')  FFt$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) 3.0 rrrRrrrh) r3rrrrrsum_maybe_null_outr)rGrerfrhrir3 dtype_sumthe_sums r*rr\sD 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 88:88D>&&{'8'89 9 Mr,c4|j}t||d|\}}t|}tjtj}|j dvr$tjtj}nE|j dvr$tjtj}n|j dk(r|}|}t |j|||}|j||}t|}|ut|dd rhttj|}tjd 5||z } ddd|dk(} | jrtj | < S|dkDr||z ntj} | 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) 1.5 rrriurRrNrFignore)r)r3rrrrr _get_countsrr_ensure_numericrzrrerrstaterHrC) rGrerfrir3r dtype_countcountrthe_meanct_masks r*rrsRB LLEvv!$GLFDu%I((2::&K zzTHHRZZ( t HHRZZ( s    dD DEjjYj/Gg&G GGVU;RZZ' [[X & 'H '1* ;;= "HW  O',ai7U?RVV O ' 's :FFct|jjdk(xr|du}dfd }|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 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 rRNc(| t|}n|}s |jstjSt j 5t j ddttj||}ddd|S#1swYSxYw)NrAll-NaN slice encountered) r!rrrCrcatch_warningsfilterwarningsRuntimeWarning nanmedian)r_maskresrfs r* get_medianznanmedian..get_medians =!HEFEeiik66M  $ $ & )  # #5~ ,,qx(C  )   )  s 4BB)rirstringmixedzCannot convert to numericrrrrrT)keepdimsrr&)r3rrrr infer_dtyperKrrLstrr writeablerrrCrlrapply_along_axisrrrrrrsqueeze_get_empty_reduction_resultr) rGrerfriusing_nan_sentinelrr3inferrederrnotemptyrs ` r*rrs6 **c1Bddl  LLEvvDTJLFD ||C <<6 !v.H../& EFF /]]4(F $"2||%%[[]Fvvt {{H{{Q4+ ))*dFC,,. >++ "=~ Q1, Q1,!ll2::f+=M ll6= > >$.fllDAC+3j& e $$U /CH%3 . /& > >s%H5B H. H+H&&H+.H7ctj|}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*rrCsU ((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_nanvarr Zs:  dD >E  4  A D=FFEA !8O RZZ'} 88: JJq$ ' JJudBFF + !8Or,rrrerfrric |jdk(r|jd}|j}t|||\}}tjt |||||}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 zM8[ns]r)rir")r3rrrsqrtnanvarr)rGrerfrri orig_dtyperts r*nanstdr'sbH||xX&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||}t||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)rer3rFr)r3rrrrrCr rrrrrr expand_dims) rGrerfrrir3rravgsqrrts r*r%r%sUJ LLE 664 0D zzTt$  66F4L ||C%fllD$fllSq%fllD$Eq $" 64# &**$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 r"rRr) r%rr3rrrHrrCr rr$)rGrerfrrirrvars r*nansemr/sL 6V$TB 664 0D ||Ct$ d&488:vv !&,,dD&,,OHE1 d64 HC 773<"''%. ((r,cftdtdddd dfd}|S)NrC)rbTrc|jdk(r t||St|||\}}t||}t ||||j }|S)Nrrri)rlrnrrzrr)rGrerfrirtrmeths r* reductionz_nanminmax..reduction;sc ;;! $VT2 2" F> '&t, tV\\B r,r)r`r)r3rr4s`` r* _nanminmaxr5: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) 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]) Tr8r2)rargmax_maybe_arg_null_outrGrerfrirts r* nanargmaxr=U>LvtFNLFD ]]4 F!tV >> 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]) Trr2)rargminr;r<s r* nanargminrAr>r,c:t|||}|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} t| } t| } tjdd5||d z d zz|dz z | | d zz z} ddd|j} | jdk(r j| d } t! tj"r2tj$| dk(d| } tj| |dk<| S| dk(r| j'dn| } |dkrtjS| 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) 1.7320508075688787 rRrrNrrinvaliddividerrg?g?Fr)rr3rrrrrrrrHrCrrrr*_zero_out_fperrrrrr1) rGrerfrirmeanadjusted adjusted2 adjusted3m2m3rtr3s r*nanskewrNsFJ 664 0D ||Ct$FLL$5FLL$FLLI $" 64# (TXXZvv Xh 7:zz$bjjz1E9: ~~dD)}H $" 8T1%! IH$I t2:: .B t2:: .B  B  B Xh 7M519,, :rBG|LM LLE zzSu51&"**%"'1f-FFuqy M #%'Av 1966M MG::(MMs%J8JJJc"t|||}|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} tjdd5d |d z dzz|dz |d z zz } ||d zz|d z z| z} |dz |d z z| dzz} dddt } t } t!| tj"s5|d krtjS| dk(r|jj%dStjdd5| | z  z }ddd|j}|jdk(rj|d }t!tj"r0tj&| dk(d|}tj||d k<|S#1swYxYw#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) -1.2892561983471076 rRrrNrrrCrrFrFr)rr3rrrrrrrrHrCrrrr*rGrrr1r)rGrerfrirrHrIrJ adjusted4rLm4adj numerator denominatorrtr3s r*nankurtrV sJ 664 0D ||Ct$FLL$5FLL$FLLI $" 64# (TXXZvv Xh 7:zz$bjjz1E9: ~~dD)}H $" 8T1%! I1 I t2:: .B t2:: .B Xh 78519""uqyUQY&?@UQY'5195: qyUQY/"a%7 8 *I!+.K k2:: . 1966M ! <<$$Q' ' Xh 7/[(3./ LLE zzSu51&"**%+*Av6FFuqy MY::88(//s$%K+":K8 L+K58LLct|||}|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) 6.0 rr)rrprodrr)rGrerfrhrirts r*rrjs[@ 664 0D $"t [[ F dFLLI r,c||S| t|dds&|r|jry|jry|S|r|j|}n|j|}|jrd||<|S)NrF)rzrrH)rtrerirfna_masks r*r;r;sv |  |76659 xxzxxz M hhtnGhhtnG ;;= F7O 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)rlrrrXr1rrr)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 |rjt|rZtj|r|jd}nt|s|jdd}tj||<|Sd||<|S|turHt|||r;t|dd}t|r|jd }|Stj}|S) zu Returns ------- Dtype The product of all elements on a given axis. ( NaNs are treated as 1) Nrrc16rFrr3rC)rrrrr broadcast_torHr iscomplexobjrrrCrcheck_below_min_countrzr1) rtrerirrh null_mask below_count new_shape result_dtypes r*rrsU | Q  Jvrzz:  D)DHHTN:YF!KI + 1A5Ket uTAXZ'88I Y?I 66) '??6*#]]51F'/#]]4e].funcXsa#A& &r,spearman) spearmanrc||dSrzr~)rrrsr|s r*rzget_corr_func..func_sQ?1% %r,rlc4tj||dS)Nrr)rcorrcoef)rrrss r*rzget_corr_func..funces;;q!$T* *r,zUnknown method 'z@', expected one of 'kendall', 'spearman', 'pearson', or callable) scipy.statsrxr|callablerL)rmrrxr|s @@r*rqrqRsr* ' : ) & 9  + &   6(#8 8 r,)rnrcNt|t|k7r td|d}t|t|z}|js ||}||}t||krtj St |}t |}t j|||dS)Nz&Operands to nancov must have same sizerr!r)rjrpr!rrrCrcov)rrrsrnrrts r*nancovrrs 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 r zCould not convert string 'z ' to numeric)rrrr3rrrrr r rK 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?grrr)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[rhintrirrXr) rtz+np.ndarray | np.datetime64 | np.timedelta64reryriznpt.NDArray[np.bool_]rrxrXz5np.ndarray | np.datetime64 | np.timedelta64 | NaTType) rGrxreryrfr[rirrXr)reryrfr[)rrrer rXrx) rrrirreryrrr3rrXz-tuple[float | np.ndarray, float | np.ndarray])reryrfr[rr)rGrxreryrfr[rr) rGrxreryrfr[rrrirrXr) rGrxreryrfr[rirrXzint | np.ndarray) rtrxreryrirrfr[rXznp.ndarray | int) rrrirreryr3znp.dtype[np.floating]rXz&np.floating | npt.NDArray[np.floating])r) rtnp.ndarray | float | NaTTypereryrirrtuple[int, ...]rhrrXr)rrrirrhrrXr[) rrrxrsrxrmrrn int | NonerXr)rmrrXz)Callable[[np.ndarray, np.ndarray], float]) rrrxrsrxrnrrrrXr)rGr rfr[rXr )] __future__rrUrEtypingrrrrnumpyrpandas._configr pandas._libsrr r r pandas._typingr r rrrrrrrpandas.compat._optionalrpandas.util._exceptionsrpandas.core.dtypes.commonrrrrrrrrpandas.core.dtypes.missingrr r!r{r'r(r+r.r`rorqrrrrrrrrnrrrrrrrrr3rr r'r%r/r5nanminnanmaxr=rArNrVrr;rrrbrGrurqrrrr~r,r*rs" %   ?4     V<$:678>55p( GK !.,) ) $),H)!)^!%)- D D DD D ' D 5 DN 2 &RDE>J )- : : :  : ' :  :@ )- : : :  : ' :  :z $ )- * * *  *  * ' * **Z 7    ; & )- < < <  < ' <  <<~04TPT_%_%D  8bhhrzz* // &/ /  /  / 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   '    >$,288BJJ#7 &+&+ &&+ &+ ! &+ , &+\ - (- - '-  -  - " -` ">KN >A $ !*"       > .@ $ # ))) )  )  ))6! H"r,