U sVc @sddlmZddlZddlZddlZddlmZmZmZddl 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 dZ4e4dk Z5da6ddddddZ7e7e dGdddZ8GdddZ9ddddddZ:dd d!d"Z;ddd#d$d%d&Zddd2d3d4Z?dd5d6d7d8Z@d9d9d:d;d<ZAd'd=d>d?d@dAZBd9d9d:dBdCZCddddDd'd=dd(ddEdFdGZDddddDd'd=dd(ddEdHdIZEe8dJeAeCdddddKd'd=ddLd(dMdNdOdPZFdQd=dRd'dSdTdUdVZGe8e-e9eAddddDd'd=dd(dMdEdWdXZHe9ddddDdYdZZId[dLd\d,d'd]d^d_ZJe Ke jLfd`d(d=dLd5dadbdcddZMe9dedfdddeddgdhdiZNe8dJdje9dedfdddeddgdkdlZOe8dJdjdddeddgd'd=ddLd(dMdmdndoZPdpdqZQeQdrdsdtZReQdudvdtZSe8dwddddDd'd=dd(dxdEdydzZTe8dwddddDd'd=dd(dxdEd{d|ZUe8dJdjeCddddDd'd=dd(dMdEd}d~ZVe8dJdjeCddddDd'd=dd(dMdEddZWe8dJdjeCdddddKd'd=ddLd(dMdNddZXd'd=d(dddddZYe Ke jLfd`d(d=d5ddddZZddd=d(d[dLddddZ[d[d(dLddddZ\ddZ]e8dJdjdddd'd'd=dMdddZ^dd ddZ_e8dJdjddedd'd'd=d=dMdddZ`ddZaddZbebejcZdebejeZfebejgZhebejiZjebejkZlebejmZnddddddZodS)) 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_arrayZ bottleneckwarn)errorsFTboolNone)vreturncCs tr|adSN)_BOTTLENECK_INSTALLED_USE_BOTTLENECK)r*r/6/tmp/pip-unpacked-wheel-xj8nt62q/pandas/core/nanops.pyset_use_bottleneck@sr1zcompute.use_bottleneckcsBeZdZdddfdd Zdddd Zd d d d d ZZS)disallowr r))dtypesr+cs"ttdd|D|_dS)Ncss|]}t|jVqdSr,)r type).0dtyper/r/r0 Msz$disallow.__init__..)super__init__tupler3)selfr3 __class__r/r0r9Ks zdisallow.__init__r(r+cCst|dot|jj|jS)Nr6)hasattr issubclassr6r4r3)r;objr/r/r0checkOszdisallow.checkr)fr+cs"tfdd}tt|S)Nc st||}tfdd|DrDjdd}td|dz0tjdd||W5QRWSQRXWn:t k r}zt |d rt||W5d}~XYnXdS) Nc3s|]}|VqdSr,)rB)r5rA)r;r/r0r7Vsz0disallow.__call__.._f..nanzreduction operation 'z' not allowed for this dtypeignoreinvalidr) itertoolschainvaluesany__name__replace TypeErrornperrstate ValueErrorr)argskwargsZobj_iterf_nameerCr;r/r0_fSs "  zdisallow.__call__.._f functoolswrapsrr)r;rCrXr/rWr0__call__Rszdisallow.__call__)rM __module__ __qualname__r9rBr\ __classcell__r/r/r<r0r2Jsr2c@s,eZdZd ddddZddddd ZdS) bottleneck_switchNr)r>cKs||_||_dSr,)namerT)r;rarTr/r/r0r9kszbottleneck_switch.__init__r)altr+c spjp jzttWnttfk r6dYnXtdddddddfdd}tt |S) NTaxisskipna np.ndarray int | Noner()rKrdrecstjdkr2jD]\}}||kr|||<q|jdkrT|ddkrTt||Str|rt|jr|dddkr| dd|fd|i|}t |rΈ|f||d|}q|f||d|}n|f||d|}|S)Nr min_countmaskrdrc) lenrTitemssizeget_na_for_min_countr. _bn_ok_dtyper6pop _has_infs)rKrdrekwdskr*resultrbZbn_funcZbn_namer;r/r0rCws   z%bottleneck_switch.__call__..f) rarMgetattrbnAttributeError NameErrorrZr[rr)r;rbrCr/rur0r\os  "'zbottleneck_switch.__call__)N)rMr]r^r9r\r/r/r/r0r`jsr`r str)r6rar+cCst|st|s|dkSdS)N)nansumnanprodnanmeanF)rr)r6rar/r/r0rosror>c Cs`t|tjr0|jdks |jdkr0t|dSzt|WSt t fk rZYdSXdS)Nf8Zf4KF) isinstancerPndarrayr6r Zhas_infsZravelisinfrLrONotImplementedError)rtr/r/r0rqs rqz Scalar | None)r6 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_dtyperPrDinfr i8maxr )r6rfill_value_typr/r/r0_get_fill_values rrfnpt.NDArray[np.bool_] | None)rKrerir+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)rr6rrr")rKrerir/r/r0_maybe_get_masks !rrz str | NonezHtuple[np.ndarray, npt.NDArray[np.bool_] | None, np.dtype, np.dtype, Any])rKrerrrir+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)rAssertionErrorr%rr6rrPasarrayviewrrrLcopyputmaskwhererrint64rfloat64) rKrerrrir6 datetimelikeZdtype_ok dtype_maxr/r/r0 _get_valuess4.     r)r6r+cCst|r dSt|jtj S)NF)rr@r4rPintegerr6r/r/r0r^srznp.dtypercCs|tkr nt|r|dkrt}t|tjs~t|r:td||krHtj}t|r^t dd}nt | d}|j |dd}n | |}nzt |rt|tjs||kst|rtd |}n.t|tjkrtdnt |j |dd}n| d  |}|S) zwrap our results if neededNzExpected non-null fill_valuernszdatetime64[ns]Frzoverflow in timedelta operationm8[ns])rrr rrPrr"rrDZ datetime64rrastyperisnanZ timedelta64fabsr rrR)rtr6rr/r/r0 _wrap_resultsds.     rr)funcr+cs6tdddddddddfd 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. NTrdrerirfrgr(r)rKrdrericsr|}|jjdk}|r$|dkr$t|}|f|||d|}|rnt||jtd}|sn|dk s`tt||||}|S)NmMr)r)r6kindr"rr r_mask_datetimelike_result)rKrdrerirT orig_valuesrrtrr/r0new_funcs    z&_datetimelike_compat..new_funcrY)rrr/rr0_datetimelike_compats rrgzScalar | np.ndarray)rKrdr+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#r6ndimshaperPfull)rKrdrZ result_shaper/r/r0rns    rncs.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. Nrdrfrg)rKrdcs|dkr|jdkr|jdr|jdd|jdkr|jtkr|jtkrt|ddk rdfddt t D}nfd dD}t |S|fd |iS) NrZ C_CONTIGUOUSirrics(g|] }|fd|iqSrir/)r5i)arrsrrTrir/r0 sz:maybe_operate_rowwise..newfunc..csg|]}|fqSr/r/)r5x)rrTr/r0rsrd) rflagsrr6objectr(listrmrprangerjrParray)rKrdrTresultsr)rrTrir0newfuncs*    z&maybe_operate_rowwise..newfuncrY)rrr/rr0maybe_operate_rowwisesrrrKrdrerir+cCs6t||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 Frri)rrrr(rLrKrdreri_r/r/r0nananys" rcCs6t||d|d\}}}}}t|r,|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 -------- >>> 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(allrr/r/r0nanalls" rZM8)rdrerhriintfloat)rKrdrerhrir+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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, 2, np.nan]) >>> nanops.nansum(s) 3.0 rrrrh) rrrrPr6rsum_maybe_null_outr) rKrdrerhrir6rr dtype_sumthe_sumr/r/r0r{Ls" r{z+np.ndarray | np.datetime64 | np.timedelta64znpt.NDArray[np.bool_]z5np.ndarray | np.datetime64 | np.timedelta64 | NaTType)rtrdrirr+cCsRt|tjr4|d|j}|j|d}t||<n|rNtt|jS|S)Nrr) rrPrrrr6rLr r)rtrdrirZ axis_maskr/r/r0r}s   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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, 2, np.nan]) >>> nanops.nanmean(s) 1.5 rrrrNrFrFr)rrPr6rrrr _get_countsr_ensure_numericrrvrrrQrLrD) rKrdrerir6rrrZ dtype_countcountrZthe_meanZct_maskr/r/r0r}s4"    r}c sfdd}t||d\}}}}}t|jsz|d}Wn0tk rl}ztt||W5d}~XYnX|dk rtj||<|j }|j dkr|dk r|rވst |||} qt t ddt||} 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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, np.nan, 2, 2]) >>> nanops.nanmedian(s) 2.0 c sLt|}s|stjSt tddt||}W5QRX|S)NrFAll-NaN slice encountered)r$rrPrDwarningscatch_warningsfilterwarnings nanmedian)rriresrer/r0 get_medians   znanmedian..get_medianrr~NrrFr)rrr6rrRrOrzrPrDrlrZapply_along_axisrrrrget_empty_reduction_resultrZfloat_r) rKrdrerirr6rerrZnotemptyrr/rr0rs(      rztuple[int, ...]znp.dtype | type[np.floating])rrdr6rr+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)rPrZarangerjemptyfill)rrdr6rZshpZdimsretr/r/r0rs   rrz-tuple[float | np.ndarray, float | np.ndarray]) values_shaperirdddofr6r+cCst||||d}|||}t|r<||krxtj}tj}n>> import pandas.core.nanops as nanops >>> s = pd.Series([1, np.nan, 2, 3]) >>> nanops.nanstd(s) 1.0 M8[ns]rrr)r6rrrPsqrtnanvarr)rKrdrerri orig_dtyperrtr/r/r0nanstdgs   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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, np.nan, 2, 3]) >>> nanops.nanvar(s) 1.0 Trr~Nr)rdr6rFr)r%r6rrrrPrDrrrrrrrr expand_dims) rKrdrerrir6rravgZsqrrtr/r/r0rs.        r)rKrdrerrir+cCsnt|||||dt|||}t|js2|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 rr~)rdrer) rrrr6rrrrPr)rKrdrerrirrvarr/r/r0nansems&   rc s<tddtddddddddd d fd d }|S) NrD)raTrrfrgr(rr rc st|||d\}}}}}|dk r0|j|dks:|jdkrz"t|||d}|tjWqttt fk r|tj}YqXnt||}t ||||j}|S)Nrrirr) rrrlrvrrPrDrxrOrRr)rKrdrerir6rrrtrmethr/r0 reductions  z_nanminmax..reduction)r`r)rrrr/rr0 _nanminmaxs $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 -------- >>> 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)rZargmax_maybe_arg_null_outrKrdrerirrtr/r/r0 nanargmax's' 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 -------- >>> 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)rZargminrrr/r/r0 nanargminUs' rc Cst|dd}t|||}t|js<|d}t|j||}nt|j|||jd}|rr|dk rr|}t ||d|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| rX| j| d d} t| tjrt| dkd| } tj| |dk<n"| 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 Trr~rNrrrFrHdividerg?g?Fr)r%rrr6rrrrrPrrrr_zero_out_fperrrQrrrrD) rKrdrerirmeanadjusted adjusted2Z adjusted3m2Zm3rtr6r/r/r0nanskewsB'       .  rc Cst|dd}t|||}t|js<|d}t|j||}nt|j|||jd}|rr|dk rr|}t ||d|j |tj d|}|dk rt ||}||}|r|dk rt ||d|d}|d}|j |tj d} |j |tj d} tj ddd Vd |d d|d|d } ||d |d | } |d|d | d} W5QRXt| } t| } t| tjs|d krtjS| dkrdStj ddd | | | }W5QRX|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 Trr~rNrrrFrrrFr)r%rrr6rrrrrPrrrrrQrrrrDr)rKrdrerirrrrZ adjusted4rZm4Zadj numerator denominatorrtr6r/r/r0nankurtsN'        "   rcCsFt|||}|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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, 2, 3, np.nan]) >>> nanops.nanprod(s) 6.0 Nrr)rrprodrr)rKrdrerhrirtr/r/r0r|<s   r|znp.ndarray | int)rtrdrirer+cCsn|dkr |S|dks t|dds@|r2|r>dSqj|rjdSn*|rP||}n ||}|rjd||<|S)NrF)rvrrL)rtrdrireZna_maskr/r/r0ris  rzfloat | np.ndarray)rrirdr6r+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)rlrrPr r4rrr)rrirdr6nrr/r/r0rs   rznp.ndarray | float | NaTType)rtrdrirrhr+cCs|dk rt|tjr|dk r:|j||||dk}n8|||dk}|d|||dd}t||}t|rt|rt|r| d}nt |s|j ddd}tj ||<qd||<n|t k rt |||rtj }|S)zu Returns ------- Dtype The product of all elements on a given axis. ( NaNs are treated as 1) NrrZc16r~Fr)rrPrrrZ broadcast_torLrZ iscomplexobjrrrDrcheck_below_min_count)rtrdrirrhZ null_maskZ below_countZ new_shaper/r/r0rs$        r)rrirhr+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)rPr rlr)rrirhZ non_nullsr/r/r0r s r c Csht|tjrFtjdd&tt|dkd|W5QRSQRXnt|dkr`|jdS|SdS)NrFrGg+=r)rrPrrQrabsr6r4)argr/r/r0rs ,rpearson)method min_periods)abrr+cCspt|t|krtd|dkr$d}t|t|@}|sL||}||}t||kr^tjSt|}|||S)z a, b: ndarrays z'Operands to nancorr must have same sizeNr)rjrr$rrPrD get_corr_func)rrrrvalidrCr/r/r0nancorrs rz)Callable[[np.ndarray, np.ndarray], float]cs||dkr$ddlmfdd}|S|dkrHddlmfdd}|S|d kr\d d}|St|rh|Std |d dS) NZkendallr kendalltaucs||dSNrr/rrrr/r0rszget_corr_func..funcZspearman spearmanrcs||dSrr/rrr/r0r srcSst||dS)Nrr)rPZcorrcoefrr/r/r0r&szUnknown method 'z@', expected one of 'kendall', 'spearman', 'pearson', or callable)Z scipy.statsrrcallablerR)rrr/)rrr0rs      r)rr)rrrrr+cCsrt|t|krtd|dkr$d}t|t|@}|sL||}||}t||kr^tjStj|||ddS)Nz&Operands to nancov must have same sizerrr)rjrr$rrPrDZcov)rrrrrr/r/r0nancov3s rc 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)rrPrrrrrrZ complex128rOrRrLimagrealrrrrcomplex)rrr/r/r0rLs, *  *rcsfdd}|S)Nc sht|}t|}||B}tjdd||}W5QRX|rdt|rT|d}t||tj|S)NrFrr)r"rPrQrLrrrrD)ryZxmaskZymaskrirtopr/r0rCms zmake_nancomp..fr/)r%rCr/r$r0 make_nancompls r&r )rKrer+c Cstjdtjftjjtj tjftjdtjftjjtjtjfi|\}}|jj dkr8|j}t |}| d}|tjjk}z|rt j||<||dd} W5|rt ||<X|rt | |<n8|tjjkrt|d} t| rt | d| d<t|jtjr| |} n.t|tjr|nd} t|j| | |d } nX|rt|jjtjtjfs|} 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?grrrrNrr)rPZcumprodrDmaximum accumulaterZcumsumZminimumr6rr"rr r rrZnonzerorjrr4Z _simple_newr@rZbool_r) rKZ accum_funcreZmask_aZmask_brrir#changedrtZnzZnpdtypevalsr/r/r0 na_accum_funcsV            r+)T)NN)NNN)N)r)p __future__rrZrIoperatortypingrrrrZnumpyrPZpandas._configrZ pandas._libsrrr r Zpandas._typingr r r rrrrZpandas.compat._optionalrZpandas.core.dtypes.commonrrrrrrrrrrrrrr Zpandas.core.dtypes.dtypesr!Zpandas.core.dtypes.missingr"r#r$Zpandas.core.constructionr%rwr-r.r1r2r`rorqrrrrrrrnrrrr{rr}rrr6rrrrrrZnanminZnanmaxrrrrr|rrrr rrrrrr&gtZnangtgeZnangeltZnanltleZnanleeqZnaneqneZnanner+r/r/r/r0s   $ @     8/Y)"%1.". ?J /&C1  --V_ + .'