U md @sddlmZddlZddlZddlZddlmZmZmZddl Z ddl Z ddl m Z ddlmZmZmZmZddlmZmZmZmZmZmZmZmZmZddlmZddlm Z dd l!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/dd l0m1Z1dd l2m3Z3m4Z4m5Z5dd l6m7Z7ed ddZ8e8dk Z9da:ddddddZ;e;e dGdddZdd!d"d#Z?ddd$d%d&d'Z@d(dd)d)d*d+d,ZAdd(dd-d.d)d/d0d1d2ZBddd3d4d5ZCdd6d7d8d9ZDd:d:d;dd?d@dAdBZFd:d:d;dCdDZGddddEd(d>dd)ddFdGdHZHddddEd(d>dd)ddFdIdJZIeddMd)dNdOdPdQZJdRd>dSd(dTdUdVdWZKedd)dNdFdXdYZLe=ddddEd>ddZd[d\ZMd]d^d_d-d(d`dadbZNe Oe jPfdcd)d>dMd6dddedfdgZQe=dhdidddhddjd>ddMdkdldmZReddMdkdodpZSeddMd)dNdqdrdsZTdtduZUeUdvdwdxZVeUdydzdxZWedd)d|dFd}d~ZXedd)d|dFddZYedd)dNdFddZZedd)dNdFddZ[eddMd)dNdOddZ\d(d>d)dddddZ]e Oe jPfdcd)d>d6ddddZ^ddd>d)d]dMddddZ_d]d)dMddddZ`ddZaePsz$disallow.__init__..)super__init__tupler6)selfr6 __class__r2r3r<Ns zdisallow.__init__r+r.cCst|dot|jj|jS)Nr9)hasattr issubclassr9r7r6)r>objr2r2r3checkRszdisallow.checkr)fr.cs"tfdd}tt|S)Nc st||}tfdd|DrDjdd}td|dz0tjdd||W5QRWSQRXWn:t k r}zt |d rt||W5d}~XYnXdS) Nc3s|]}|VqdSr/)rE)r8rD)r>r2r3r:Ysz0disallow.__call__.._f..nanzreduction operation 'z' not allowed for this dtypeignoreinvalidr) itertoolschainvaluesany__name__replace TypeErrornperrstate ValueErrorr)argskwargsZobj_iterf_nameerFr>r2r3_fVs "  zdisallow.__call__.._f functoolswrapsrr)r>rFr[r2rZr3__call__Uszdisallow.__call__)rP __module__ __qualname__r<rEr_ __classcell__r2r2r?r3r5Msr5c@s,eZdZd ddddZddddd ZdS) bottleneck_switchNr,rAcKs||_||_dSr/)namerW)r>rdrWr2r2r3r<nszbottleneck_switch.__init__r)altr.c spjp jzttWnttfk r6dYnXtdddddddfdd}tt |S) NTaxisskipna np.ndarrayAxisInt | Noner+)rNrgrhcstjdkr2jD]\}}||kr|||<q|jdkrT|ddkrTt||Str|rt|jr|dddkr| dd|fd|i|}t |rΈ|f||d|}q|f||d|}n|f||d|}|S)Nr min_countmaskrgrf) lenrWitemssizeget_na_for_min_countr1 _bn_ok_dtyper9pop _has_infs)rNrgrhkwdskr-resultreZbn_funcZbn_namer>r2r3rFzs   z%bottleneck_switch.__call__..f) rdrPgetattrbnAttributeError NameErrorr]r^rr)r>rerFr2rxr3r_rs  "'zbottleneck_switch.__call__)N)rPr`rar<r_r2r2r2r3rcmsrcrstr)r9rdr.cCst|st|s|dkSdS)N)nansumnanprodnanmeanF)rr")r9rdr2r2r3rrsrrrAc CsVt|tjr&|jdkr&t|dSzt|WSt t fk rPYdSXdS)N)f8Zf4KF) isinstancerSndarrayr9r Zhas_infsZravelisinfrOrRNotImplementedError)rwr2r2r3rts  rtz Scalar | None)r9 fill_valuecCsP|dk r |St|r:|dkr"tjS|dkr0tjStj Sn|dkrHtjStSdS)z9return the correct fill value for the dtype of the valuesN+inf) _na_ok_dtyperSrGinfr i8maxr )r9rfill_value_typr2r2r3_get_fill_values rrinpt.NDArray[np.bool_] | None)rNrhrlr.cCs:|dkr6t|jst|jr dS|s.t|jr6t|}|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)rr9rr"r%)rNrhrlr2r2r3_maybe_get_masks !rrz str | NonezHtuple[np.ndarray, npt.NDArray[np.bool_] | None, np.dtype, np.dtype, Any])rNrhrrrlr.c Cst|s tt|dd}t|||}|j}d}t|jrLt|d}d}t |}t |||d}|r|dk r|dk r| r|s|r| }t |||nt|||}|}t|st|rttj}nt|rttj}|||||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 TZ extract_numpyFi8)rrN)r AssertionErrorr(rr9r"rSZasarrayviewrrrOcopyputmaskwhererrint64rfloat64) rNrhrrrlr9 datetimelikeZdtype_ok dtype_maxr2r2r3 _get_valuess4.     r)r9r.cCst|r dSt|jtj S)NF)r"rCr7rSintegerr9r2r2r3rasrznp.dtypercCs|tkr nt|r|dkr t}t|tjst|r.new_funcr\)rrr2rr3_datetimelike_compats rrjzScalar | np.ndarray)rNrgr.cCslt|r|d}t|j}|jdkr*|S|dkr6|S|jd||j|dd}tj|||jdSdS)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&r9ndimshaperSfull)rNrgrZ result_shaper2r2r3rqs    rqcs.tdddddfdd}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. Nrgrirj)rNrgcs|dkr|jdkr|jdr|jdd|jdkr|jtkr|jtkrt|ddk rdfddt t D}nfd dD}t |S|fd |iS) NrZ C_CONTIGUOUSirrlcs(g|] }|fd|iqSrlr2)r8i)arrsrrWrlr2r3 sz:maybe_operate_rowwise..newfunc..csg|]}|fqSr2r2)r8x)rrWr2r3rsrg) rflagsrr9objectr+listrprsrangermrSarray)rNrgrWresultsr)rrWrlr3newfuncs*    z&maybe_operate_rowwise..newfuncr\)rrr2rr3maybe_operate_rowwisesrrrNrgrhrlr.cCs^t|jr(|jjdkr(tjdttdt||d|d\}}}}}t|rT| 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 -------- >>> from pandas.core import nanops >>> s = pd.Series([1, 2]) >>> nanops.nanany(s) True >>> from pandas.core import nanops >>> s = pd.Series([np.nan]) >>> nanops.nanany(s) False rzz'any' with datetime64 dtypes is deprecated and will raise in a future version. Use (obj != pd.Timestamp(0)).any() instead. stacklevelFrrl) r"r9rwarningsr) FutureWarningrrrrr+rOrNrgrhrl_r2r2r3nananys" rcCs^t|jr(|jjdkr(tjdttdt||d|d\}}}}}t|rT| t }| |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) True >>> from pandas.core import nanops >>> s = pd.Series([1, 0]) >>> nanops.nanall(s) False rzz'all' with datetime64 dtypes is deprecated and will raise in a future version. Use (obj != pd.Timestamp(0)).all() instead.rTr) r"r9rrr)rrrrrr+allrr2r2r3nanall*s" rZM8)rgrhrkrlintfloat)rNrgrhrkrlr.c Csft||d|d\}}}}}|}t|r,|}nt|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 -------- >>> from pandas.core import nanops >>> s = pd.Series([1, 2, np.nan]) >>> nanops.nansum(s) 3.0 rrrrk) rrr!rSr9rsum_maybe_null_outr) rNrgrhrkrlr9rr dtype_sumthe_sumr2r2r3r~as" r~z+np.ndarray | np.datetime64 | np.timedelta64znpt.NDArray[np.bool_]z5np.ndarray | np.datetime64 | np.timedelta64 | NaTType)rwrgrlrr.cCsRt|tjr4|d|j}|j|d}t||<n|rNtt|jS|S)Nrr) rrSrrrr9rOr r)rwrgrlrZ axis_maskr2r2r3rs   rc Cst||d|d\}}}}}|}ttj}|jdkrBttj}n&t|rXttj}nt|rh|}|}t|j|||d} t |j ||d} |dk rt | ddrt tj | } tjdd | | } W5QRX| dk} | rtj| | <n| 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 -------- >>> from pandas.core import nanops >>> s = pd.Series([1, 2, np.nan]) >>> nanops.nanmean(s) 1.5 rrrrNrFrIr)rrSr9rrrr _get_countsr_ensure_numericrryrrrTrOrG) rNrgrhrlr9rrrZ dtype_countcountrZthe_meanZct_maskr2r2r3rs4"    rrfc sd fdd }t||dd\}}}}}t|jsrz|d}Wn0tk rp}ztt||W5d}~XYnX|dk rtj||<|j }|j dkr|dk r|rst |||} qt t dd tt||} W5QRXnt|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 -------- >>> from pandas.core import nanops >>> s = pd.Series([1, np.nan, 2, 2]) >>> nanops.nanmedian(s) 2.0 Nc s^|dkrt|}n|}s*|s*tjSt"tddtt||}W5QRX|S)NrIAll-NaN slice encountered) r'rrSrGrcatch_warningsfilterwarningsRuntimeWarning nanmedian)rZ_maskresrhr2r3 get_medians   znanmedian..get_medianr)rlrrrrIr)N)rrr9rrUrRr}rSrGrorZapply_along_axisrrrrrget_empty_reduction_resultrZfloat_r) rNrgrhrlrr9rerrZnotemptyrr2rr3rs0    rztuple[int, ...]r znp.dtype | type[np.floating])rrgr9rr.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)rSrZarangermemptyfill)rrgr9rZshpZdimsretr2r2r3r8s   rrz-tuple[float | np.ndarray, float | np.ndarray]) values_shaperlrgddofr9r.cCst||||d}|||}t|r<||krxtj}tj}n>> from pandas.core import nanops >>> s = pd.Series([1, np.nan, 2, 3]) >>> nanops.nanstd(s) 1.0 zM8[ns]rrr)r9rrrSsqrtnanvarr)rNrgrhrrlZ orig_dtyperrwr2r2r3nanstds $  rZm8c Cst|dd}|j}t|||}t|rB|d}|dk rBtj||<t|jrft|j ||||j\}}nt|j |||\}}|r|dk r| }t ||dt |j |tjd|}|dk rt||}t ||d} |dk rt | |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 -------- >>> from pandas.core import nanops >>> s = pd.Series([1, np.nan, 2, 3]) >>> nanops.nanvar(s) 1.0 TrrNr)rgr9rFr)r(r9rrrrSrGrrrrrrrr expand_dims) rNrgrhrrlr9rravgZsqrrwr2r2r3rs.%        r)rNrgrhrrlr.cCst|||||dt|||}t|js2|d}|sL|dk rL|rLtjSt|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 -------- >>> from pandas.core import nanops >>> s = pd.Series([1, np.nan, 2, 3]) >>> nanops.nansem(s) 0.5773502691896258 rrN) rrrr9rrOrSrGrrr)rNrgrhrrlrrvarr2r2r3nansems&   rc s>tddtddddddddd d fd d }|S) NrG)rdTrrirjr+rrrc st|||d\}}}}}|dk r0|j|dks:|jdkrz"t|||d}|tjWqttt fk r|tj}YqXnt||}t ||||j}|S)Nrrlrr) rrroryrrSrGr{rRrUr)rNrgrhrlr9rrrwrmethr2r3 reduction2s  z_nanminmax..reduction)rcr)rrrr2rr3 _nanminmax1s$rminr)rmax-infOzint | np.ndarraycCs6t|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 -------- >>> 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]) Trr)rZargmax_maybe_arg_null_outrNrgrhrlrrwr2r2r3 nanargmaxRs' rcCs6t|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 min 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.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)rZargminrrr2r2r3 nanargmins' rc Cst|dd}t|||}t|js<|d}t|j||}nt|j|||jd}|rt|dk rt|}t ||dn|s|dk r| rtj S|j |tj d|}|dk rt||}||}|r|dk rt ||d|d}||}|j |tj d} |j |tj d} t| } t| } tjddd *||d d |d| | d } W5QRX|j} t| rt| j| d d} t| tjrt| dkd| } tj | |dk<n"| dkrdn| } |dkrtj S| 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 -------- >>> from pandas.core import nanops >>> s = pd.Series([1, np.nan, 1, 2]) >>> nanops.nanskew(s) 1.7320508075688787 TrrrNrrrIrKdividerg?g?Fr)r(rrr9rrrrrSrrOrGrrr_zero_out_fperrrTrrr) rNrgrhrlrmeanadjusted adjusted2Z adjusted3m2Zm3rwr9r2r2r3nanskewsF'       .  rc Cs$t|dd}t|||}t|js<|d}t|j||}nt|j|||jd}|rt|dk rt|}t ||dn|s|dk r| rtj S|j |tj d|}|dk rt||}||}|r|dk rt ||d|d}|d}|j |tj d} |j |tj d} tjddd Vd |d d|d|d } ||d |d | } |d|d | d} W5QRXt| } t| } t| tjs|d krtj S| dkrdStjddd | | | }W5QRX|j}t|r|j|d d}t|tjr t| 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 -------- >>> from pandas.core import nanops >>> s = pd.Series([1, np.nan, 1, 3, 2]) >>> nanops.nankurt(s) -1.2892561983471076 TrrrNrrrIrrrFr)r(rrr9rrrrrSrrOrGrrrrTrrrr)rNrgrhrlrrrrZ adjusted4rZm4Zadj numerator denominatorrwr9r2r2r3nankurtsR'        "   r cCsFt|||}|r(|dk r(|}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 -------- >>> from pandas.core import nanops >>> s = pd.Series([1, 2, 3, np.nan]) >>> nanops.nanprod(s) 6.0 Nrr)rrprodrr)rNrgrhrkrlrwr2r2r3rks   rznp.ndarray | int)rwrgrlrhr.cCsn|dkr |S|dks t|dds@|r2|r>dSqj|rjdSn*|rP||}n ||}|rjd||<|S)NrF)ryrrO)rwrgrlrhZna_maskr2r2r3rs  rzfloat | np.ndarray)rrlrgr9r.cCsz|dkr4|dk r |j|}n t|}||S|dk rR|j|||}n||}t|rl||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)rorrSr r7rr r)rrlrgr9nrr2r2r3rs   rznp.ndarray | float | NaTType)rwrgrlrrkr.c Cs|dkr|dkr|S|dk rt|tjr|dk rN|j||||dk}n8|||dk}|d|||dd}t||}t|rt|rt|r| d}nt |s|j ddd}tj ||<nd||<n@|t k rt |||rt|dd}t |r|d }ntj }|S) zu Returns ------- Dtype The product of all elements on a given axis. ( NaNs are treated as 1) NrrZc16rFrr9rG)rrSrrrZ broadcast_torOrZ iscomplexobjrrrGrcheck_below_min_countryr7) rwrgrlrrkZ null_maskZ below_countZ new_shapeZ result_dtyper2r2r3rs.           r)rrlrkr.cCs:|dkr6|dkrt|}n|j|}||kr6dSdS)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)rSr ror)rrlrkZ non_nullsr2r2r3r s rc Csht|tjrFtjdd&tt|dkd|W5QRSQRXnt|dkr`|jdS|SdS)NrIrJg+=r)rrSrrTrabsr9r7)argr2r2r3r+s ,rpearson)method min_periodsr z int | None)abrrr.cCspt|t|krtd|dkr$d}t|t|@}|sL||}||}t||kr^tjSt|}|||S)z a, b: ndarrays z'Operands to nancorr must have same sizeNr)rmrr'rrSrG get_corr_func)rrrrvalidrFr2r2r3nancorr4s  rz)Callable[[np.ndarray, np.ndarray], float])rr.cs||dkr$ddlmfdd}|S|dkrHddlmfdd}|S|d kr\d d}|St|rh|Std |d dS) NZkendallr kendalltaucs||dSNrr2rrrr2r3rWszget_corr_func..funcZspearman spearmanrcs||dSrr2rrr2r3r^srcSst||dS)Nrr)rSZcorrcoefrr2r2r3rdszUnknown method 'z@', expected one of 'kendall', 'spearman', 'pearson', or callable)Z scipy.statsrr callablerU)rrr2)rr r3rQs      r)rr)rrrrr.cCsrt|t|krtd|dkr$d}t|t|@}|sL||}||}t||kr^tjStj|||ddS)Nz&Operands to nancov must have same sizerrr!)rmrr'rrSrGZcov)rrrrrr2r2r3nancovqs r#c CsHt|tjrt|st|r*|tj}nt|rz|tj}Wn^t t fk rz|tj}Wn4t k r}zt d|d|W5d}~XYnXYnXt t |s|j }nt|sDt|sDt|sDz t|}Wn^t t fk rBz t|}Wn6t k r<}zt d|d|W5d}~XYnXYnX|S)NzCould not convert z to numeric)rrSrrrrrrZ complex128rRrUrOimagrealrrrrcomplex)rrr2r2r3rs, *  *rcsfdd}|S)Nc sht|}t|}||B}tjdd||}W5QRX|rdt|rT|d}t||tj|S)NrIrr)r%rSrTrOrrrrG)ryZxmaskZymaskrlrwopr2r3rFs zmake_nancomp..fr2)r)rFr2r(r3 make_nancomps r*r )rNrhr.c Cstjdtjftjjtj tjftjdtjftjjtjtjfi|\}}|jj dksVt |rt |jj tj tjfs|}t|}|||<||dd}|||<n ||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?grrr)rSZcumprodrGmaximum accumulaterZcumsumminimumr9rrrCr7rZbool_rr%)rNZ accum_funcrhZmask_aZmask_bvalsrlrwr2r2r3 na_accum_funcs(     r/)T)NN)NNN)N)r)t __future__rr]rLoperatortypingrrrrnumpyrSZpandas._configrZ pandas._libsrrr r Zpandas._typingr r r rrrrrrZpandas.compat._optionalrZpandas.util._exceptionsrZpandas.core.dtypes.commonrrrrrrrrrrr r!r"r#Zpandas.core.dtypes.dtypesr$Zpandas.core.dtypes.missingr%r&r'Zpandas.core.constructionr(rzr0r1r4r5rcrrrtrrrrrrrqrrrr~rrrrr9rrrrrrZnanminZnanmaxrrrr rrrrrrrrr#rr*gtZnangtgeZnangeltZnanltleZnanleeqZnaneqneZnanner/r2r2r2r3s  ,  @     8/Y)"%:7". ?P /-J4  --Xa + .0