o i@s~ddlmZddlZddlZddlZddlmZmZmZddl 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 dZ4e4duZ5da6ddddZ7e7e dGdddZ8GdddZ9dd d!Z:dd"d#Z; ddd&d'Zdd5d6Z?ddd8d9Z@ddMz$disallow.__init__..)super__init__tupler4)selfr4 __class__r0r1r;Ks zdisallow.__init__r*cCst|do t|jj|jS)Nr7)hasattr issubclassr7r5r4)r=objr0r0r1checkOszdisallow.checkfrcs"tfdd}tt|S)Nc st||}tfdd|Dr"jdd}td|dz!tjdd|i|WdWS1s._f..nanzreduction operation 'z' not allowed for this dtypeignoreinvalidr) itertoolschainvaluesany__name__replace TypeErrornperrstate ValueErrorr)argskwargsobj_iterf_nameerDr=r0r1_fSs   (  zdisallow.__call__.._f functoolswrapsrr)r=rDrZr0rYr1__call__Rs zdisallow.__call__)r4r r+r,r+r*)rDrr+r)rN __module__ __qualname__r;rCr^ __classcell__r0r0r>r1r3Js r3c@s"eZdZd d ddZd dd ZdS) bottleneck_switchNr+r,cKs||_||_dSr-)namerU)r=rdrUr0r0r1r;ks zbottleneck_switch.__init__altrc sfjpjzttWn ttfydYnwtdddd fd d }tt |S) NTaxisskipnarL np.ndarrayrg int | Nonerhr*cstjdkrjD] \}}||vr|||<q |jdkr*|ddur*t||Strj|rjt|jrj|dddur]| dd|fd|i|}t |r[|f||d|}|S|f||d|}|S|f||d|}|S)Nr min_countmaskrgrf) lenrUitemssizeget_na_for_min_countr/ _bn_ok_dtyper7pop _has_infs)rLrgrhkwdskr)resultrebn_funcbn_namer=r0r1rDws$  z%bottleneck_switch.__call__..f)rLrirgrjrhr*) rdrNgetattrbnAttributeError NameErrorr\r]rr)r=rerDr0rxr1r^os  'zbottleneck_switch.__call__r-)r+r,)rerr+r)rNr`rar;r^r0r0r0r1rcjs rcr7r rdstrcCst|s t|s |dvSdS)N)nansumnanprodnanmeanF)rr)r7rdr0r0r1rrsrrc CsZt|tjr|jdks|jdkrt|dSzt|WSt t fy,YdSw)Nf8f4KF) isinstancerQndarrayr7r has_infsravelisinfrMrPNotImplementedError)rwr0r0r1rts rt fill_value Scalar | NonecCsJ|dur|St|r|durtjS|dkrtjStj S|dkr#tjStS)z9return the correct fill value for the dtype of the valuesN+inf) _na_ok_dtyperQrEinfr i8maxr )r7rfill_value_typr0r0r1_get_fill_valuesrrLrirhrlnpt.NDArray[np.bool_] | NonecCs:|durt|jst|jrdS|st|jrt|}|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)rr7rrr")rLrhrlr0r0r1_maybe_get_masks !rrr str | NoneHtuple[np.ndarray, npt.NDArray[np.bool_] | None, np.dtype, np.dtype, Any]c Cst|sJt|dd}t|||}|j}d}t|jr&t|d}d}t|}t |||d}|rW|durW|durW| rW|sC|rO| }t |||nt |||}|}t|sat|rhttj}n t|rrttj}|||||fS)a7 Utility to get the values view, mask, dtype, dtype_max, and fill_value. If both mask and fill_value/fill_value_typ are not None and skipna is True, the values array will be copied. For input arrays of boolean or integer dtypes, copies will only occur if a precomputed mask, a fill_value/fill_value_typ, and skipna=True are provided. Parameters ---------- values : ndarray input array to potentially compute mask for skipna : bool boolean for whether NaNs should be skipped fill_value : Any value to fill NaNs with fill_value_typ : str Set to '+inf' or '-inf' to handle dtype-specific infinities mask : Optional[np.ndarray[bool]] nan-mask if known Returns ------- values : ndarray Potential copy of input value array mask : Optional[ndarray[bool]] Mask for values, if deemed necessary to compute dtype : np.dtype dtype for values dtype_max : np.dtype platform independent dtype fill_value : Any fill value used T extract_numpyFi8)rrN)rr%rr7rrQasarrayviewrrrMcopyputmaskwhererrint64rfloat64) rLrhrrrlr7 datetimelikedtype_ok dtype_maxr0r0r1 _get_valuess0 .    rcCst|rdSt|jtj S)NF)rrAr5rQintegerr7r0r0r1r^srnp.dtypecCs|tur |St|rI|durt}t|tjsBt|rJd||kr&tj}t|r1tdd}nt | d}|j |dd}|S| |}|St |rt|tjs~||ks\t |rftd |}|St|tjkrrtdt |j |dd}|S| d  |}|S) zwrap our results if neededNzExpected non-null fill_valuernszdatetime64[ns]Frzoverflow in timedelta operationm8[ns])rrr rrQrr"rE datetime64rrastyperisnan timedelta64fabsr rrS)rwr7rr0r0r1 _wrap_resultsds8#    rfuncrcs,tdddddfd d }tt|S)z If we have datetime64 or timedelta64 values, ensure we have a correct mask before calling the wrapped function, then cast back afterwards. NTrgrhrlrLrirgrjrhr*rlrcsr|}|jjdv}|r|durt|}|f|||d|}|r7t||jtd}|s7|dus0Jt||||}|S)NmMr)r)r7kindr"rr _mask_datetimelike_result)rLrgrhrlrU orig_valuesrrwrr0r1new_funcs   z&_datetimelike_compat..new_func)rLrirgrjrhr*rlrr[)rrr0rr1_datetimelike_compats  rrgrjScalar | np.ndarraycCsht|r |d}t|j}|jdkr|S|dur|S|jd||j|dd}tj|||jdS)a Return the missing value for `values`. Parameters ---------- values : ndarray axis : int or None axis for the reduction, required if values.ndim > 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#r7ndimshaperQfull)rLrgr result_shaper0r0r1rqs    rqcs(tddd fdd}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. NrgrLrirgrjcs|dkrT|jdkrT|jdrT|jdd|jdkrT|jtkrT|jtkrTt|ddurEdfddt t D}n fd dD}t |S|fd |iS) Nr C_CONTIGUOUSirrlcs(g|]}|fd|iqSrlr0)r6i)arrsrrUrlr0r1 sz:maybe_operate_rowwise..newfunc..csg|] }|fiqSr0r0)r6x)rrUr0r1rsrg) rflagsrr7objectr*listrprsrangermrQarray)rLrgrUresultsr)rrUrlr1newfuncs       z&maybe_operate_rowwise..newfunc)rLrirgrjr[)rrr0rr1maybe_operate_rowwises rrcC6t||d|d\}}}}}t|r|t}||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 Frrl)rrrr*rMrLrgrhrl_r0r0r1nanany"  rcCr)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)rrrr*allrr0r0r1nanallrrM8)rgrhrkrlrkintfloatc Csft||d|d\}}}}}|}t|r|}n t|r ttj}|j||d} t| |||j|d} | 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 rrrrk) rrrrQr7rsum_maybe_null_outr) rLrgrhrkrlr7rr dtype_sumthe_sumr0r0r1rLs" rrw+np.ndarray | np.datetime64 | np.timedelta64npt.NDArray[np.bool_]r5np.ndarray | np.datetime64 | np.timedelta64 | NaTTypecCsTt|tjr|d|j}|j|d}t||<|S|r(tt|jS|S)Nrr) rrQrrrr7rMr r)rwrgrlr axis_maskr0r0r1r}s  rc Cst||d|d\}}}}}|}ttj}|jdvr!ttj}nt|r,ttj}nt|r4|}|}t|j|||d} t |j ||d} |durt | ddrt tj | } tjdd  | | } Wdn1skwY| dk} | r}tj| | <| S| dkr| | ntj} | S) 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 rrrrNrFrGr)rrQr7rrrr _get_countsr_ensure_numericrr{rrrRrMrE) rLrgrhrlr7rrr dtype_countcountrthe_meanct_maskr0r0r1rs2"     rc sfdd}t||d\}}}}}t|js;z|d}Wnty1}ztt||d}~ww|dur;tj||<|j }|j dkr|dur|rtsSt |||} n5t t ddt||} Wdn1snwYnt|j|tjtj} n |r||ntj} t| |S) 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 csbt|}s |s tjSttddt||}Wd|S1s*wY|S)NrGAll-NaN slice encountered)r$rrQrEwarningscatch_warningsfilterwarnings nanmedian)rrlresrhr0r1 get_medians    znanmedian..get_medianrrNrrGr)rrr7rrSrPrrQrErorapply_along_axisrrrrget_empty_reduction_resultrfloat_r) rLrgrhrlrr7rerrnotemptyrr0rr1rs0       rrtuple[int, ...]np.dtype | type[np.floating]cCs<t|}tt|}tj|||k|d}|||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)rQrarangermemptyfill)rrgr7rshpdimsretr0r0r1rs  r values_shaperddof-tuple[float | np.ndarray, float | np.ndarray]cCst||||d}|||}t|r!||krtj}tj}||fSttj|}||k}|r?t||tjt||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) rr5rrQrErrrMr)rrlrgrr7rdr0r0r1_get_counts_nanvar8s rrrrgrhrrlc CsT|jdkr |d}|j}t|||d\}}}}}tt|||||d}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 )r7rrrQsqrtnanvarr)rLrgrhrrl orig_dtyperrwr0r0r1nanstdgs   rm8c Cst|dd}|j}t|||}t|r!|d}|dur!tj||<t|jr3t|j ||||j\}}n t|j |||\}}|rN|durN| }t ||dt |j |tjd|}|durdt||}t ||d} |durwt | |d| j |tjd|} t|r| j|dd } | 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 TrrNr)rgr7rFr)r%r7rrrrQrErrrrrrrr expand_dims) rLrgrhrrlr7rravgsqrrwr0r0r1r s.       r cCsnt|||||dt|||}t|js|d}t|j||||j\}}t||||d}t|t|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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, np.nan, 2, 3]) >>> nanops.nansem(s) 0.5773502691896258 r r)rgrhr) r rrr7rrrrQr )rLrgrhrrlrrvarr0r0r1nansems&   rcs0tddtdddddfdd}|S)NrE)rdTrrLrirgrjrhr*rlrr+r c st|||d\}}}}}|dur|j|dks|jdkr>zt|||d}|tjWnttt fy=tj}Ynwt||}t ||||j}|S)Nrrlrr) rrror{rrQrEr}rPrSr)rLrgrhrlr7rrrwrmethr0r1 reductions   z_nanminmax..reduction) rLrirgrjrhr*rlrr+r )rcr)rrrr0rr1 _nanminmaxs rminr)rmax-infOint | np.ndarraycC6t|dd|d\}}}}}||}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]) Trr)rargmax_maybe_arg_null_outrLrgrhrlrrwr0r0r1 nanargmax'' r#cCr)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 min 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.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)rargminr!r"r0r0r1 nanargminUr$r&c Cst|dd}t|||}t|js|d}t|j||}n t|j|||jd}|r9|dur9|}t ||d|j |tj d|}|durMt ||}||}|r^|dur^t ||d|d}||}|j |tj d} |j |tj d} t | } t | } tjddd ||d d |d| | d } Wdn1swY|j} t| r| j| d d} t| tjrt| dkd| } tj| |dk<| S| dkrdn| } |dkrtjS| S)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 TrrrNrrrGrIdividerg?g?Fr)r%rrr7rrrrrQrrrr_zero_out_fperrrRrrrrE) rLrgrhrlrmeanadjusted adjusted2 adjusted3m2m3rwr7r0r0r1nanskewsF '      & r1cCs(t|dd}t|||}t|js|d}t|j||}n t|j|||jd}|r9|dur9|}t ||d|j |tj d|}|durMt ||}||}|r^|dur^t ||d|d}|d}|j |tj d} |j |tj d} tj ddd 0d |d d|d|d } ||d |d | } |d|d | d} Wdn1swYt| } t| } t| tjs|d krtjS| dkrdStj ddd | | | }Wdn1swY|j}t|r|j|d d}t|tjrt| dkd|}tj||d k<|S)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 TrrrNrrrGr'r)rFr)r%rrr7rrrrrQrrrrrRr*rrrEr)rLrgrhrlrr+r,r- adjusted4r/m4adj numerator denominatorrwr7r0r0r1nankurtsR '         r8cCsFt|||}|r|dur|}d||<||}t||||j|dS)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 Nrr)rrprodrr)rLrgrhrkrlrwr0r0r1r<s   rnp.ndarray | intcCsr|dur|S|dust|dds"|r|rdS|S|r dS|S|r*||}n||}|r7d||<|S)NrF)r{rrM)rwrgrlrhna_maskr0r0r1r!is    r!float | np.ndarraycCsz|dur|dur|j|}nt|}||S|dur)|j|||}n||}t|r6||S|j|ddS)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 NFr)rorrQr9r5rrr)rrlrgr7nrr0r0r1rs   rnp.ndarray | float | NaTTypecCs|duret|tjre|dur|j||||dk}n|||dk}|d|||dd}t||}t|rct|r_t|rM| d}n t |sX|j ddd}tj ||<|Sd||<|S|t urrt |||rrtj }|S)zu Returns ------- Dtype The product of all elements on a given axis. ( NaNs are treated as 1) Nrrc16rFr)rrQrrr broadcast_torMr iscomplexobjrrrErcheck_below_min_count)rwrgrlrrk null_mask below_count new_shaper0r0r1rs(       rcCs:|dkr|durt|}n|j|}||krdSdS)a Check for the `min_count` keyword. Returns True if below `min_count` (when missing value should be returned from the reduction). Parameters ---------- shape : tuple The shape of the values (`values.shape`). mask : ndarray[bool] or None Boolean numpy array (typically of same shape as `shape`) or None. min_count : int Keyword passed through from sum/prod call. Returns ------- bool rNTF)rQr9ror)rrlrk non_nullsr0r0r1rCs rCcCsrt|tjr*tjddtt|dkd|WdS1s#wYdSt|dkr7|jdS|S)NrGrHg+=r)rrQrrRrabsr7r5)argr0r0r1r*s $r*pearson)method min_periodsabrLcCspt|t|kr td|durd}t|t|@}|s&||}||}t||kr/tjSt|}|||S)z a, b: ndarrays z'Operands to nancorr must have same sizeNr)rmAssertionErrorr$rrQrE get_corr_func)rMrNrKrLvalidrDr0r0r1nancorrs  rR)Callable[[np.ndarray, np.ndarray], float]csx|dkrddlmfdd}|S|dkr$ddlmfdd}|S|d kr.d d}|St|r4|Std |d ) Nkendallr kendalltauc||dSNrr0rMrNrUr0r1rzget_corr_func..funcspearman spearmanrcrWrXr0rYr\r0r1r rZrJcSst||dS)Nrr)rQcorrcoefrYr0r0r1r&szUnknown method 'z@', expected one of 'kendall', 'spearman', 'pearson', or callable) scipy.statsrVr]callablerS)rKrr0)rVr]r1rPs      rP)rLrcCsrt|t|kr td|durd}t|t|@}|s&||}||}t||kr/tjStj|||ddS)Nz&Operands to nancov must have same sizerrr^)rmrOr$rrQrEcov)rMrNrLrrQr0r0r1nancov3s rcc Cs,t|tjrYt|st|r|tj}|St|rWz|tj}Wn)t t fyKz |tj}WY|St yJ}z t d|d|d}~wwwt t |sW|j }|St|st|st|szt|}W|St t fyzt|}WY|St y}z t d|d|d}~www|S)NzCould not convert z to numeric)rrQrrrrrr complex128rPrSrMimagrealrrrrcomplex)rrr0r0r1rLsB     rcsfdd}|S)Ncs|t|}t|}||B}tjdd ||}Wdn1s"wY|r.fr0)rlrDr0rkr1 make_nancompls rmr c Cstjdtjftjjtj tjftjdtjftjjtjtjfi|\}}|jj dvr|j}t |}| d}|tjjk}z|rCt j ||<||dd} W|rPt||<n|rWt||<w|r_t| |<n|tjjkr{t|d} t| r{t| d| d<t|jtjr| |} | St|tjr|nd} t|j| | |d } | S|rt|jjtjtjfs|} t | }|| |<|| dd} || |<| S||dd} | 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?grrrrNr r)rQcumprodrEmaximum accumulatercumsumminimumr7rr"rr rr rnonzerormrr5 _simple_newrArbool_r) rL accum_funcrhmask_amask_br rlrhchangedrwnznpdtypevalsr0r0r1 na_accum_funcsX              r})T)r)r*r+r,)r7r rdrr+r*r_)NN)r7r rr)rLrirhr*rlrr+r)NNN) rLrirhr*rrrrrlrr+r)r7r r+r*r-)r7r)rrr+r)rLrirgrjr+r) rLrirgrjrhr*rlrr+r*) rLrirgrjrhr*rkrrlrr+r) rwrrgrjrlrrrir+r) rLrirgrjrhr*rlrr+r) rrrgrr7rrrr+ri) rrrlrrgrjrrr7rr+r) rLrirgrjrhr*rrrlrr+r) rLrirgrjrhr*rlrr+r) rwrirgrjrlrrhr*r+r:) rrrlrrgrjr7rr+r=)r) rwr?rgrjrlrrrrkrr+r?)rrrlrrkrr+r*)rMrirNrirLrjr+r)r+rS) rMrirNrirLrjrrjr+r)rLr rhr*r+r )p __future__rr\rJoperatortypingrrrrnumpyrQpandas._configr pandas._libsrrr r pandas._typingr r r rrrrpandas.compat._optionalrpandas.core.dtypes.commonrrrrrrrrrrrrrr pandas.core.dtypes.dtypesr!pandas.core.dtypes.missingr"r#r$pandas.core.constructionr%r|r.r/r2r3rcrrrtrrrrrrrqrrrrrrrrr7rrrr rrnanminnanmaxr#r&r1r8rr!rrrCr*rRrPrcrrmgtnangtgenangeltnanltlenanleeqnaneqnenanner}r0r0r0r1s  $ @      8  / Y  ) " %1. .? J /&C1  --V_ +  . '