`VgddlmZddlZddlZddlZddlmZmZmZddl Z ddl Z ddl m Z ddlmZmZmZmZddlmZmZmZmZmZmZmZddlmZddlmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+dd l,m-Z-dd l.m/Z/m0Z0m1Z1dd l2m3Z3ed d Z4e4duZ5da6dMdNdZ7e7e dGddZ8GddZ9dOdZ:dPdZ; dQ dRdZ< dSdZ= dT dUdZ>dVdZ?dWdXdZ@dYdZAdZdZBdYd ZCdddd! d[d"ZDdddd! d[d#ZEe8d$eAeCddddd% d\d&ZF d]d'ZGe8e-e9eAdddd! d^d(ZHe9dddd!d)ZI d_d*ZJe je jf d`d+ZMe9d,-ddd,dd.d/ZNe8d$d0e9d,-ddd,dd.d1ZOe8d$d0ddd,dd. dad2ZPd3ZQeQd4d56ZReQd7d86ZSe8d9dddd! dbd:ZTe8d9dddd! dbd;ZUe8d$d0eCdddd! d^d<ZVe8d$d0eCdddd! d^d=ZWe8d$d0eCddddd% d\d>ZX dcd?ZYe je jf ddd@ZZ de dfdAZ[ dgdBZ\dCZ]e8d$d0dDddE dhdFZ^didGZ_e8d$d0dd,dH djdIZ`dJZadKZbebejZdebejZfebejZhebejZjebejZlebejZndkdLZoy)l) annotationsN)AnyCallablecast) get_option)NaTNaTTypeiNaTlib) ArrayLikeDtypeDtypeObjFScalarShapenpt)import_optional_dependency)is_any_int_dtype is_bool_dtype is_complexis_datetime64_any_dtypeis_floatis_float_dtype is_integeris_integer_dtypeis_numeric_dtypeis_object_dtype is_scalaris_timedelta64_dtypeneeds_i8_conversion pandas_dtype) PeriodDtype)isnana_value_for_dtypenotna) extract_array bottleneckwarn)errorsFTctr|ayyN)_BOTTLENECK_INSTALLED_USE_BOTTLENECK)vs S/var/www/html/hubwallet-dev/venv/lib/python3.12/site-packages/pandas/core/nanops.pyset_use_bottleneckr0@szcompute.use_bottleneckc0eZdZdfd ZddZddZxZS)disallowcPt|td|D|_y)Nc3FK|]}t|jywr+)r!type).0dtypes r/ z$disallow.__init__..MsIL/44Is!)super__init__tupledtypes)selfr= __class__s r/r;zdisallow.__init__Ks  I&II r1crt|dxr*t|jj|jS)Nr8)hasattr issubclassr8r6r=)r>objs r/checkzdisallow.checkOs'sG$PCIINNDKK)PPr1cbtjfd}tt|S)Nctj||j}tfd|Dr+jj dd}t d|d tjd5|i|cdddS#1swYyxYw#t$r }t|dr t ||d}~wwxYw) Nc3@K|]}j|ywr+)rD)r7rCr>s r/r9z0disallow.__call__.._f..Vs7s4::c?7snanzreduction operation 'z' not allowed for this dtypeignoreinvalidr) itertoolschainvaluesany__name__replace TypeErrornperrstate ValueErrorr)argskwargsobj_iterf_nameefr>s r/_fzdisallow.__call__.._fSs tV]]_=H7h77++E26+F83OP [[2.d-f-...  #47+#A,A- s6&B<B BBBB C#B>>C functoolswrapsrr)r>r\r]s`` r/__call__zdisallow.__call__Rs,     &Ar{r1)r=r returnNonerbbool)r\rrbr)rQ __module__ __qualname__r;rDra __classcell__)r?s@r/r3r3JsJQr1r3ceZdZdddZddZy)bottleneck_switchNc  ||_||_yr+)namerX)r>rlrXs r/r;zbottleneck_switch.__init__ks  r1cjxs 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_countmaskrorn) lenrXitemssizeget_na_for_min_countr- _bn_ok_dtyper8pop _has_infs) rOrorpkwdskr.resultaltbn_funcbn_namer>s r/r\z%bottleneck_switch.__call__..fws4;;!# KK--/$DAq}"#Q${{aDHH[$9$A)666l6<<.Q88FD)1HHVT*$V?$?$?F!(!$V!N$v!N!N M !Jd6JTJFMVF$vFFMr1)rO np.ndarrayro int | Nonerpre) rlrQgetattrbnAttributeError NameErrorr_r`rr)r>rr\rrs`` @@r/razbottleneck_switch.__call__os))+s|| b'*G   $ % % %  %  % NAqzW * G sA**A>=A>r+)rbrc)rrrbr)rQrfrgr;rar1r/rjrjjs 0r1rjc8t|st|s|dvSy)N)nansumnanprodnanmeanF)rr )r8rls r/ryrys# 5 !*=e*D;;; r1c,t|tjrB|jdk(s|jdk(r$t j |j dS tj|jS#ttf$rYywxYw)Nf8f4KF) isinstancerTndarrayr8r has_infsravelisinfrPrSNotImplementedError)r~s r/r{r{sv&"**% <<4 6<<4#7<< S 12 2xx##%% * +s"BBBc||St|r8|tjS|dk(rtjStj S|dk(rtj St S)z9return the correct fill value for the dtype of the values+inf) _na_ok_dtyperTrHinfr i8maxr )r8 fill_valuefill_value_typs r/_get_fill_valuersZE  !66M'vv w V #99 Kr1c|Mt|jst|jry|st|jr 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]] N)rr8rr r#)rOrprss r/_maybe_get_maskrsBB |  &*:6<<*H (6.new_funcs ||((J6 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. rNr)rrr$r8ndimshaperTfull)rOror result_shapes r/rxrxs"y)#FLL1J {{a ||ET*V\\$(*-EE ww|Zv||DDr1cftjdddfd}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. Nroc |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_CONTIGUOUSirrsro) rflagsrr8objectrelistrwrzrangertrTarray) rOrorXarrsrsiresultsxrs r/newfuncz&maybe_operate_rowwise..newfuncs AI q  ^,a4'6<<?: & $?Da9tAw9&97;;4,V,;;88G$ $F000011. 7 r1rct||d|\}}}}}t|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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, 2]) >>> nanops.nanany(s) True >>> import pandas.core.nanops as nanops >>> s = pd.Series([np.nan]) >>> nanops.nanany(s) False Frrs)rrrrerPrOrorprs_s r/nananyrsID%VVDQFAq!Qvt$ ::d r1ct||d|\}}}}}t|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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, 2, np.nan]) >>> nanops.nanall(s) True >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, 0]) >>> nanops.nanall(s) False Tr)rrrreallrs r/nanallrsID%VV4PFAq!Qvt$ ::d r1M8)rorprrrsct||d|\}}}}}|}t|r|}n.t|r#tjtj }|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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, 2, np.nan]) >>> nanops.nansum(s) 3.0 rrrrr) rrrrTr8rsum_maybe_null_outr) rOrorprrrsr8rr dtype_sumthe_sums r/rrLs~D)414)%FD%AIe e $HHRZZ( jjYj/GgtT6<<9UG Nr1cLt|tjrG|jdj |j }|j |}t||<|S|j r2tjtj |j S|S)Nrr) rrTrrrr8rPr r)r~rorsr axis_masks r/rr}s &"**%t$))+*;*;<HH$H' !y M 88:88D>&&{'8'89 9 Mr1ct||d|\}}}}}|}tjtj}|jdvr$tjtj}n>t |r$tjtj}nt |r|}|}t|j|||} t|j||} |ut| ddrhttj| } 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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, 2, np.nan]) >>> nanops.nanmean(s) 1.5 rrrrNrFrJr)rrTr8rrrr _get_countsr_ensure_numericrrrrrUrPrH) rOrorprsr8rrr dtype_countcountrthe_meanct_masks r/rrsCD)414)%FD%AI((2::&K zzZHHRZZ( % HHRZZ(     dD DEfjjYj?@G GGVU;RZZ' [[X & 'H '1* ;;= "HW  O',ai7U?RVV O ' 's E33E<cfd}t||\}}}}}t|js' |jd}|tj||<|j}|jdkDr||rdstj|||} ntj5tjddtj||} dddnOt!|j"|tj$tj} n|r||ntj} t' |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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, np.nan, 2, 2]) >>> nanops.nanmedian(s) 2.0 ct|}s |jstjSt j 5t j ddtj||}ddd|S#1swYSxYw)NrJAll-NaN slice encountered)r%rrTrHwarningscatch_warningsfilterwarnings nanmedian)rrsresrps r/ get_medianznanmedian..get_mediansmQxdhhj66M  $ $ & (  # #H.I J,,qw'C (  ( s /A<<BrsrNrrJr)rrr8rrVrSstrrTrHrvrapply_along_axisrrrrget_empty_reduction_resultrfloat_r) rOrorprsrr8rerrnotemptyrs ` r/rrs:2!,FF FFD%A &,, ' /]]4(F  66F4L{{H{{Q4+ ))*dFC,,.5++H6QR,,vt4C55-V\\4BFFSC%-j "&& e $$C /CH%3 . /$55s#D5$-E5 E>EEE$ctj|}tjt|}tj|||k7|}|j ||S)z The result from a reduction on an empty ndarray. Parameters ---------- shape : Tuple[int] axis : int dtype : np.dtype fill_value : Any Returns ------- np.ndarray r)rTrarangertemptyfill)rror8rshpdimsrets r/rrsM( ((5/C 99SZ D ((3tt|$E 2CHHZ Jr1ct||||}||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) rr6rrTrHrrrPr) values_shapersroddofr8rds r/_get_counts_nanvarr8s:  dD >E  4  A D=FFEA !8O RZZ'} 88: JJq$ ' JJudBFF + !8Or1rrrorprrsc |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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, np.nan, 2, 3]) >>> nanops.nanstd(s) 1.0 M8[ns]rrr)r8rrrTsqrtnanvarr)rOrorprrs orig_dtyperr~s r/nanstdrgsh:||xX&J'TBFD!Q WWVFf4dS TF  ,,r1m8ct|d}|j}t|||}t|r&|j d}|t j ||<t|jr't|j||||j\}}nt|j|||\}}|r)|'|j}t j||dt|j|t j|z }|t j||}t||z dz} |t j| |d| j|t j|z } t|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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, np.nan, 2, 3]) >>> nanops.nanvar(s) 1.0 Trrr)ror8rFr)r&r8rrrrTrHrrrrrrrr expand_dims) rOrorprrsr8rravgsqrr~s r/rrsR<6 6F LLE 664 0Dt$  66F4Lfll#%fllD$fllSq%fllD$Eq $" 64# &**$bjj*A BU JC nnS$' 3>> import pandas.core.nanops as nanops >>> s = pd.Series([1, np.nan, 2, 3]) >>> nanops.nansem(s) 0.5773502691896258 rr)rorpr) rrrr8rrrrTr)rOrorprrsrrvars r/nansemr$sL 6V$TB 664 0D &,, 't$!&,,dD&,,OHE1 d6 =C 773<"''%. ((r1cjtdztdddd dfd}|S)NrH)rlTrct|||\}}}}}||j|dk(s|jdk(r5 t| ||}|j t j nt| |}t||||j}|S#tttf$rt j }Y@wxYw)Nrrsrr) rrrvrr rTrHrrSrVr) rOrorprsr8rrr~rmeths r/ reductionz_nanminmax..reductions6A F>6 2eY   d!3q!8V[[A=M ..t9E BFF#+WVT*40F tV\\B #Iz:  s3B$CC) rOrrorrprersrrbr )rjr)r(rr)s`` r/ _nanminmaxr*siEDL) -1   +   *0 r1minr)rmax-infOcnt|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 -------- >>> import pandas.core.nanops as 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]) Tr-r')rargmax_maybe_arg_null_outrOrorprsrr~s r/ nanargmaxr3'DN(VRVWFD!Q ]]4 F tV >> import pandas.core.nanops as 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]) Trr')rargminr1r2s r/ nanargminr7Ur4r1ct|d}t|||}t|js)|j d}t |j ||}n#t |j |||j}|r)|'|j}tj||d|j|tj|z }|tj||}||z }|r|tj||d|dz}||z}|j|tj} |j|tj} t| } t| } tjdd 5||d z d zz|dz z | | d zz z} ddd|j} t| r j | d } t tj r2tj"| dk(d| } tj$| |dk<| S| dk(rdn| } |dkrtj$S| S#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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, np.nan, 1, 2]) >>> nanops.nanskew(s) 1.7320508075688787 TrrrNrrrJrLdividerg?g?Fr)r&rrr8rrrrrTrrrr_zero_out_fperrrUrrrrH) rOrorprsrmeanadjusted adjusted2 adjusted3m2m3r~r8s r/nanskewrCsN6 6F 664 0D &,, 't$FLL$5FLL$FLLI $" 64# ::d"**: - 5D ~~dD)}H $" 8T1%! IH$I t2:: .B t2:: .B  B  B Xh 7M519,, :rBG|LM LLEeu51&"**%"'1f-FFuqy M Ag6 1966M MMMs <H55H>cRt|d}t|||}t|js)|j d}t |j ||}n#t |j |||j}|r)|'|j}tj||d|j|tj|z }|tj||}||z }|r|tj||d|dz}|dz}|j|tj} |j|tj} tjdd 5d |d z dzz|dz |d z zz } ||d zz|d z z| z} |dz |d z z| dzz} dddt } t } t| tj s|d krtj"S| dk(rytjdd 5| | z  z }ddd|j}t|rj |d }ttj r0tj$| dk(d|}tj"||d k<|S#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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, np.nan, 1, 3, 2]) >>> nanops.nankurt(s) -1.2892561983471076 TrrrNrrrJr9r;rFr)r&rrr8rrrrrTrrrrrUr<rrrHr)rOrorprsrr=r>r? adjusted4rAm4adj numerator denominatorr~r8s r/nankurtrKsiN6 6F 664 0D &,, 't$FLL$5FLL$FLLI $" 64# ::d"**: - 5D ~~dD)}H $" 8T1%! I1 I t2:: .B t2:: .B Xh 78519""uqyUQY&?@UQY'5195: qyUQY/"a%7 8 *I!+.K k2:: . 1966M !  Xh 7/[(3./ LLEeu51&"**%+*Av6FFuqy M?88(//s&:J JJJ&ct|||}|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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, 2, 3, np.nan]) >>> nanops.nanprod(s) 6.0 rr)rrprodrr)rOrorprrrsr~s r/rr<s[@ 664 0D $"t [[ F dFLLI r1c||S| t|dds&|r|jry|jry|S|r|j|}n|j|}|jrd||<|S)NrF)rrrP)r~rorsrpna_masks r/r1r1isv |  |76659 xxzxxz M hhtnGhhtnG ;;= F7O Mr1cB|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)rvrrTrMr6rrr)rrsror8nrs r/rrs0 |   DHHJ&A %Azz!}  4 488D>1T"zz%  <<E< **r1c<|t|tjr|(|j||j |z |z dk}n/|||z dk}|d|||dzdz}tj ||}tj |rjt|rZtj|r|jd}nt|s|jdd}tj||<|Sd||<|S|turt|||rtj}|S)zu Returns ------- Dtype The product of all elements on a given axis. ( NaNs are treated as 1) Nrrc16rFr)rrTrrr broadcast_torPr iscomplexobjrrrHrcheck_below_min_count)r~rorsrrr null_mask below_count new_shapes r/rrs Jvrzz:  D)DHHTN:YF!KI + 1A5Ket uTAXZ'88I Y?I 66) '??6*#]]51F'/#]]4e].funcsa#A& &r1spearman) spearmanrc||dSrnr)rfrgrps r/rzget_corr_func..func sQ?1% %r1r`c4tj||dS)Nrr)rTcorrcoef)rfrgs r/rzget_corr_func..func&s;;q!$T* *r1zUnknown method 'z@', expected one of 'kendall', 'spearman', 'pearson', or callable) scipy.statsrlrpcallablerV)rarrlrps @@r/reresp * ' : ) & 9  + &   6(#8 8 r1)rbrc"t|t|k7r td|d}t|t|z}|js ||}||}t||krtj St j |||dS)Nz&Operands to nancov must have same sizerrrs)rtrdr%rrTrHcov)rfrgrbrrhs r/nancovry3s 1vQEFF !HuQx E 99; eH eH 1v vv 66!QT "4 ((r1ct|tjrt|s t |r!|j tj }|St|rV |j tj}tjtj|s|j}|S|St|s$t|st!|s 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)NzCould not convert z to numeric)rrTrrrrrr complex128rPimagrealrSrVrrrfloatcomplex)rrs r/rrLso!RZZ A -"2$A. H-Q  HHR]]+vvbggaj)A H1HqkZ]jm NaA H1H'z* RR,A!R#&8;$GHcQR" H' R:& N NAJ H N"4QC{ CD#M N  Ns`C& D>&D;6DD; D4D//D44D;:D;>E> E E:%E55E::E>cfd}|S)NcHt|}t|}||z}tjd5||}ddd|jrAt r|j d}tj ||tjS#1swY\xYw)NrJrr.)r#rTrUrPrrrrH)ryxmaskymaskrsr~ops r/r\zmake_nancomp..fmsQQu} [[X & 1XF  88:V$s+ JJvtRVV ,   s BB!r)rr\s` r/ make_nancomprls  Hr1c vtjdtjftjjtj tjftj dtjftjjtj tjfi|\}}|jjdvrZ|j}t|}|jd}|tjjk(} |rtj||<||d} |r t||< |r t| |<n[|tjjk(r>tj|j!d} t#| r t| d| dt%|jtjr| j|} | St%|tjr|nd} t'|j)| j| | } | S|rot+|jj&tj,tj.fs1|j1} t| }|| |<|| d} || |<| S||d} | S#|r t||<wwxYw) 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?grrrrNrr)rTcumprodrHmaximum accumulatercumsumminimumr8rr#rr rr rnonzerortrr6 _simple_newrBrbool_r) rO accum_funcrpmask_amask_brrsrchangedr~nznpdtypevalss r/ na_accum_funcrs5 S"&&M 0 C= /   NFF||J&\\ F| KK  5 55 ))$*F$ F4L 2::00 0::d##,,.q1B2w"&wA fllBHH -[[,F* M!%/z288$Dj(G&\-- G$J.F M  6<<#4#4rzz2886LM{{}DzT Dq)t  MF+ MG$s J**J8)T)r.rerbrc)r8rrlrrbrerd)NN)r8rrz Scalar | None)rOrrprersrrbr)NNN) rOrrprerrrz str | NonersrrbzHtuple[np.ndarray, npt.NDArray[np.bool_] | None, np.dtype, np.dtype, Any])r8rrbrer+)r8np.dtype)rrrbr)rOrrorrbzScalar | np.ndarray) rOrrorrprersrrbre) rOrrorrprerrintrsrrbr~) r~z+np.ndarray | np.datetime64 | np.timedelta64rorrsznpt.NDArray[np.bool_]rrrbz5np.ndarray | np.datetime64 | np.timedelta64 | NaTType) rOrrorrprersrrbr~) rtuple[int, ...]rorr8znp.dtype | type[np.floating]rrrbr) rrrsrrorrrr8rrbz-tuple[float | np.ndarray, float | np.ndarray]) rOrrorrprerrrsrrbr~) rOrrorrprersrrbzint | np.ndarray) r~rrorrsrrprerbznp.ndarray | int) rrrsrrorr8rrbzfloat | np.ndarray)r) r~np.ndarray | float | NaTTyperorrsrrrrrrrbr)rrrsrrrrrbre)rfrrgrrbrrbr~)rbz)Callable[[np.ndarray, np.ndarray], float]) rfrrgrrbrrrrbr~)rOr rprerbr )p __future__rr_rMoperatortypingrrrrnumpyrTpandas._configr pandas._libsrr r r pandas._typingr r rrrrrpandas.compat._optionalrpandas.core.dtypes.commonrrrrrrrrrrrrr r!pandas.core.dtypes.dtypesr"pandas.core.dtypes.missingr#r$r%pandas.core.constructionr&rr,r-r0r3rjryr{rrrrrrrxrrrrrrrrr8rrrrr$r*nanminnanmaxr3r7rCrKrr1rrrWr<rireryrrgtnangtgenangeltnanltlenanleeqnaneqnenannerrr1r/rsB" % ? 2 3 V<$:678@55p( GK !.,) ) $),H)!)^!%)- V6 V6 V6V6 V6 ' V6 N V6r2 &RDE>J)- + + +  + ' +  +b)- + + +  + ' +  +\ $)- + + +  +  + ' + ++\ 7    ; & +)- < < <  < ' <  <<~"4dG%G%T   (   @bhhrzz* ,, &, ,  ,  , 3 ,^14#-#-L $14@@F $)- .) .) .)  .)  .) ' .) .).)b< E& 1 E& 1 #)- * * *  * ' *  **Z #)- * * *  * ' *  **Z $)- S S S  S ' S  SSl $)- \ \ \  \ ' \  \\~ $)- ( ( (  (  ( ' ( ((V   '    >bhhrzz* &+&+ &&+ &+  &+  &+\ $ ($ $ '$  $  $ " $N ">KN >A $,5QU DN 0< $ # ))) )  )  ))0 @ & X[[!X[[!X[[!X[[!X[[!X[[!Lr1