o թZh(@sddlmZddlZddlZddlmZmZmZddlZddl 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 d Z-e-duZ.da/ddddZ0e0e dGdddZ1GdddZ2ddd Z3dd!d"Z4 ddd%d&Z5dd,d-Z6   ddd2d3Z7dd5d6Z8dd7d8Z9ddd9d:Z:dd=d>Z;ddBdCZddddFddIdJZ?e1dKe;e=dddddLddPdQZ@ddWdXZAe2e;ddddFddYdZZBe2ddddFdd[d\ZCdd`daZDe Ee jFfddedfZGe2dgdhdddgddiddjdkZHe1dKdle2dgdhdddgddiddmdnZIe1dKdldddgddiddodpZJdqdrZKeKdsdtduZLeKdvdwduZMddddFddydzZNddddFdd{d|ZOe1dKdle=ddddFdd}d~ZPe1dKdle=ddddFdddZQe1dKdle=dddddLdddZRdddZSe Ee jFfdddZT gddddZUdddZVddZWe1dKdlddddddZXdddZYe1dKdlddgddddZZddZ[dddZ\dS)) 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_dtypenotnaZ bottleneckwarn)errorsFTvboolreturnNonecCstr|adSdSN)_BOTTLENECK_INSTALLED_USE_BOTTLENECK)r#r*I/var/www/html/lang_env/lib/python3.10/site-packages/pandas/core/nanops.pyset_use_bottleneck9sr,zcompute.use_bottleneckcs2eZdZdfdd Zddd Zdd d ZZS)disallowdtypesrr%r&cs"ttdd|D|_dS)Ncss|]}t|jVqdSr')rtype).0dtyper*r*r+ Fz$disallow.__init__..)super__init__tupler.)selfr. __class__r*r+r5Ds zdisallow.__init__r$cCst|do t|jj|jS)Nr1)hasattr issubclassr1r/r.)r7objr*r*r+checkHszdisallow.checkfrcs"tfdd}tt|S)Nc st||}tfdd|Dr"jdd}td|dz|i|WStyB}z t|dr=t||d}~ww)Nc3s|]}|VqdSr')r=)r0r<)r7r*r+r2Or3z0disallow.__call__.._f..nanzreduction operation 'z' not allowed for this dtyper) itertoolschainvaluesany__name__replace TypeError ValueErrorr)argskwargsZobj_iterf_nameer>r7r*r+_fLs   zdisallow.__call__.._f functoolswrapsrr)r7r>rNr*rMr+__call__Ks zdisallow.__call__)r.rr%r&r%r$)r>rr%r)rE __module__ __qualname__r5r=rR __classcell__r*r*r8r+r-Cs r-c@s"eZdZd d ddZd dd ZdS) bottleneck_switchNr%r&cKs||_||_dSr')namerJ)r7rXrJr*r*r+r5cs zbottleneck_switch.__init__altrc sfjpjzttWn ttfydYnwtdddd fd d }tt |S) NTaxisskipnarC np.ndarrayr[AxisInt | Noner\r$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_countmaskr[rZ) lenrJitemssizeget_na_for_min_countr) _bn_ok_dtyper1pop _has_infs)rCr[r\kwdskr#resultrYZbn_funcZbn_namer7r*r+r>os$  z%bottleneck_switch.__call__..f)rCr]r[r^r\r$) rXrEgetattrbnAttributeError NameErrorrPrQrr)r7rYr>r*rlr+rRgs  'zbottleneck_switch.__call__r')r%r&)rYrr%r)rErTrUr5rRr*r*r*r+rWbs rWr1rrXstrcCs|tkr t|s |dvSdS)N)nansumnanprodnanmeanF)objectr)r1rXr*r*r+rfsrfc CsPt|tjr|jdvrt|dSzt|WSt t fy'YdSw)N)f8Zf4KF) isinstancenpndarrayr1r Zhas_infsZravelisinfrDrGNotImplementedError)rkr*r*r+rhs  rh 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_dtyperyr?infr i8maxr )r1r}fill_value_typr*r*r+_get_fill_valuesrrCr]r\r`npt.NDArray[np.bool_] | NonecCs4|dur|jjdvr dS|s|jjdvrt|}|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)r1kindr)rCr\r`r*r*r+_maybe_get_masks ! rrr str | None/tuple[np.ndarray, npt.NDArray[np.bool_] | None]cCst|||}|j}d}|jjdvrt|d}d}|rM|durMt|||d}|durM|rM|s6t|rE| }t |||||fSt |||}||fS)a 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 Fri8TN)r}r) rr1rryZasarrayviewrrDrcopyputmaskwhere)rCr\r}rr`r1 datetimeliker*r*r+ _get_valuess$ )   rnp.dtypecCsR|}|jdvrttj}|S|jdkrttj}|S|jdkr'ttj}|S)NZbiur>)rryr1int64Zuint64float64)r1Z dtype_maxr*r*r+_get_dtype_maxDs    rcCst|rdSt|jtj S)NF)rr;r/ryintegerr1r*r*r+rPsrcCs|tur |S|jdkrM|durt}t|tjsFt|r Jd||kr'tj}t|r5tdd |}nt | |}|j |dd}|S| |}|S|jdkrt|tjs||ksat |rkt d |}|St|tjkrwtd t |j |dd}|S| d  |}|S) zwrap our results if neededMNzExpected non-null fill_valuernsFrmzoverflow in timedelta operationm8[ns])rrr rxryrzrr?Z datetime64astyperrisnanZ timedelta64fabsr rrH)rkr1r}r*r*r+ _wrap_resultsVs8#     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. NTr[r\r`rCr]r[r^r\r$r`rcsr|}|jjdv}|r|durt|}|f|||d|}|r7t||jtd}|s7|dus0Jt||||}|S)Nrr)r})r1rrrr _mask_datetimelike_result)rCr[r\r`rJ orig_valuesrrkrr*r+new_funcs   z&_datetimelike_compat..new_funcrCr]r[r^r\r$r`rrO)rrr*rr+_datetimelike_compats  rr[r^Scalar | np.ndarraycCsl|jjdvr |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. ZiufcbrNr)r1rrrndimshaperyfull)rCr[r}Z result_shaper*r*r+res     recs(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. Nr[rCr]r[r^cs|dkrT|jdkrT|jdrT|jdd|jdkrT|jtkrT|jtkrTt|ddurEdfddt t D}n fd dD}t |S|fd |iS) NrZ C_CONTIGUOUSirr`cs(g|]}|fd|iqSr`r*)r0i)arrsrrJr`r*r+ sz:maybe_operate_rowwise..newfunc..csg|] }|fiqSr*r*)r0x)rrJr*r+rsr[) rflagsrr1rur$listrdrgrangeraryarray)rCr[rJresultsr)rrJr`r+newfuncs       z&maybe_operate_rowwise..newfunc)rCr]r[r^rO)rrr*rr+maybe_operate_rowwises rrcCn|jjdvr|dur||S|jjdkrtjdttdt||d|d\}}|jtkr2| 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.values) True >>> from pandas.core import nanops >>> s = pd.Series([np.nan]) >>> nanops.nanany(s.values) False iubNrzz'any' with datetime64 dtypes is deprecated and will raise in a future version. Use (obj != pd.Timestamp(0)).any() instead. stacklevelFr}r`) r1rrDwarningsr! FutureWarningrrrurr$rCr[r\r`_r*r*r+nanany"     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 -------- >>> 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 rNrzz'all' with datetime64 dtypes is deprecated and will raise in a future version. Use (obj != pd.Timestamp(0)).all() instead.rTr) r1rallrr!rrrrurr$rr*r*r+nanallrrZM8)r[r\r_r`r_intfloatcCsn|j}t||d|d\}}t|}|jdkr|}n |jdkr$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.values) 3.0 rrr>rrr_) r1rrrryrsum_maybe_null_outr)rCr[r\r_r`r1 dtype_sumthe_sumr*r*r+rr\s"   rrrk+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) rxryrzrrr1rDr r)rkr[r`rZ axis_maskr*r*r+rs  rc Cs$|j}t||d|d\}}t|}ttj}|jdvr#ttj}n|jdvr/ttj}n |jdkr8|}|}t|j|||d}|j||d}t |}|durt |dd rt tj |}tj d d  ||} Wdn1sqwY|dk} | rtj| | <| 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 -------- >>> from pandas.core import nanops >>> s = pd.Series([1, 2, np.nan]) >>> nanops.nanmean(s.values) 1.5 rrriur>rNrFignore)r)r1rrryrr _get_countsrr_ensure_numericrmrrzerrstaterDr?) rCr[r\r`r1rZ dtype_countcountrZthe_meanZct_maskr*r*r+rts2!       rtc s|jjdko |du}dfdd }|j}t||dd\}}|jjdkrU|jtkr:t|}|dvr:td|dz|d }WntyT}ztt ||d}~ww|sh|durh|j j sc| }t j||<|j} |jd kr|dur| rĈst |||} nUt7td d t|jd d kr|d ks|jd d kr|d krt jt |dd} nt j||d} Wdn1swYnt|j|} n | r|||nt j} 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.values) 2.0 r>Ncst|dur t|}n|}s|stjSttddtt||}Wd|S1s3wY|S)NrAll-NaN slice encountered) r rryr?rcatch_warningsfilterwarningsRuntimeWarning nanmedian)rZ_maskresr\r*r+ get_medians    znanmedian..get_median)r`r}stringmixedzCannot convert to numericrvrrrrT)Zkeepdimsrr')r1rrrur infer_dtyperGrrHrqrZ writeablerryr?rcrZapply_along_axisrrrrrrZsqueeze_get_empty_reduction_resultr) rCr[r\r`Zusing_nan_sentinelrr1inferrederrZnotemptyrr*rr+rsL       rrrr cCs@t|}tt|}tj|||ktjd}|tj|S)z The result from a reduction on an empty ndarray. Parameters ---------- shape : Tuple[int, ...] axis : int Returns ------- np.ndarray r)ryrZarangeraemptyrfillr?)rr[Zshpdimsretr*r*r+rCs  r values_shapeddof-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) rr/rryr?rrzrDr)rr`r[rr1rdr*r*r+_get_counts_nanvarZs rrrr[r\rr`c CsN|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 -------- >>> from pandas.core import nanops >>> s = pd.Series([1, np.nan, 2, 3]) >>> nanops.nanstd(s.values) 1.0 zM8[ns]rrr)r1rrrysqrtnanvarr)rCr[r\rr`Z orig_dtyperkr*r*r+nanstds $  rZm8c Cs|j}t|||}|jdvr|d}|durtj||<|jjdkr/t|j||||j\}}n t|j|||\}}|rJ|durJ|}t ||dt |j |tj d|}|dur`t ||}t ||d} |durst | |d| j |tj d|} |jdkr| 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.values) 1.0 rrvNr>r)r[r1rFr)r1rrrryr?rrrrrrr expand_dims) rCr[r\rr`r1rrZavgZsqrrkr*r*r+rs,%        rcCst|||||dt|||}|jjdkr|d}|s'|dur'|r'tjSt|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.values) 0.5773502691896258 rr>rvN) rrr1rrrDryr?rrr)rCr[r\rr`rrvarr*r*r+nansems&   rcs2tddtdddddfd d}|S)Nr?)rXTrrCr]r[r^r\r$r`rcsJ|jdkr t||St|||d\}}t||}t||||j}|S)Nrrr`)rcrerrmrrrCr[r\r`rkrmethr*r+ reduction;s  z_nanminmax..reductionr)rWr)rrrr*rr+ _nanminmax:srminr)rmax-infint | np.ndarraycC0t|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_outrr*r*r+ nanargmaxU& rcCr)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)rZargminrrr*r*r+ nanargminr r c Cst|||}|jjdkr|d}t|j||}n t|j|||jd}|r5|dur5|}t||dn |sB|durB| rBtj Stj ddd|j |tj d|}Wdn1s^wY|durmt||}||}|r~|dur~t||d|d}||}|j |tj d} |j |tj d} t| } t| } tj ddd||d d |d| | d } Wdn1swY|j} | jdkr| j| d d } t| tjrt| dkd| } tj | |dk<| S| dkr| dn| } |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.values) 1.7320508075688787 r>rvrNrrinvaliddividerrg?g?Fr)rr1rrrrrryrrDr?rrrr_zero_out_fperrrxrzrr/) rCr[r\r`rmeanadjusted adjusted2Z adjusted3m2Zm3rkr1r*r*r+nanskewsL %     &   rcCsvt|||}|jjdkr|d}t|j||}n t|j|||jd}|r5|dur5|}t||dn |sB|durB| rBtj Stj ddd|j |tj d|}Wdn1s^wY|durmt||}||}|r~|dur~t||d|d}|d}|j |tj d} |j |tj d} tj ddd0d |d d|d|d } ||d |d | } |d|d | d} Wdn1swYt| } t| } t| tjs|d krtj S| dkr|jdStj ddd| | | }Wdn 1s wY|j}|jdkr"|j|d d }t|tjr9t| 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.values) -1.2892561983471076 r>rvrNrrr rrrFr)rr1rrrrrryrrDr?rrrrrrxrzr/r)rCr[r\r`rrrrZ adjusted4rZm4Zadj numerator denominatorrkr1r*r*r+nankurt sX %          rcCsFt|||}|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 -------- >>> from pandas.core import nanops >>> s = pd.Series([1, 2, 3, np.nan]) >>> nanops.nanprod(s.values) 6.0 Nrr)rrprodrr)rCr[r\r_r`rkr*r*r+rsjs   rsnp.ndarray | intcCsr|dur|S|dust|dds"|r|rdS|S|r dS|S|r*||}n||}|r7d||<|S)NrF)rmrrD)rkr[r`r\Zna_maskr*r*r+rs    rnp.dtype[np.floating]&np.floating | npt.NDArray[np.floating]cCsz|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)rcrryrr/rrr)rr`r[r1nrr*r*r+rs   rnp.ndarray | float | NaTTypetuple[int, ...]c Cs|dur |dkr |S|durot|tjro|dur'|j||||dk}n|||dk}|d|||dd}t||}t|rmt|rit|rW| d}n t |sb|j ddd}tj ||<|Sd||<|S|t urt |||rt|dd}t |r|d }|Stj }|S) zu Returns ------- Dtype The product of all elements on a given axis. ( NaNs are treated as 1) NrrZc16rvFrr1r?)rxryrzrrZ broadcast_torDrZ iscomplexobjrrr?rcheck_below_min_countrmr/) rkr[r`rr_Z null_maskZ below_countZ new_shapeZ result_dtyper*r*r+rs4           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)ryrrcr)rr`r_Z non_nullsr*r*r+r! s r!cCsBt|tjrtt|dkd|St|dkr|jdS|S)Ng+=r)rxryrzrabsr1r/)argr*r*r+r*s rpearson)method min_periodsabr%r r& int | NonecCst|t|kr td|durd}t|t|@}|s&||}||}t||kr/tjSt|}t|}t|}|||S)z a, b: ndarrays z'Operands to nancorr must have same sizeNr)raAssertionErrorr rryr?r get_corr_func)r'r(r%r&validr>r*r*r+nancorr2s   r-)Callable[[np.ndarray, np.ndarray], float]csx|dkrddlmfdd}|S|dkr$ddlmfdd}|S|d kr.d d}|St|r4|Std |d ) NZkendallr kendalltauc||dSNrr*r'r(r/r*r+rXzget_corr_func..funcZspearman spearmanrcr1r2r*r3r5r*r+r_r4r$cSst||dS)Nrr)ryZcorrcoefr3r*r*r+reszUnknown method 'z@', expected one of 'kendall', 'spearman', 'pearson', or callable)Z scipy.statsr0r6callablerH)r%rr*)r0r6r+r+Rs      r+)r&rcCst|t|kr td|durd}t|t|@}|s&||}||}t||kr/tjSt|}t|}tj|||ddS)Nz&Operands to nancov must have same sizerrr7)rar*r rryr?rZcov)r'r(r&rr,r*r*r+nancovrs r9c Csft|tjri|jjdvr|tj}|S|jtkrgt |}|dvr*t d|dz|tj }Wn)t t fy[z |tj}WY|St yZ}z t d|d|d}~wwwt t|sg|j}|St|st|st|st|trt d|dzt|}W|St t fyzt|}WY|St y}z t d|d|d}~www|S)NrrzCould not convert rzCould not convert string 'z ' to numeric)rxryrzr1rrrrur rrGZ complex128rHrDimagrealrrrrqrcomplex)rrrr*r*r+rsL       rr c Cstjdtjftjjtj tjftjdtjftjjtjtjfi|\}}|jj dvs+J|rPt |jj tj tj fsP|}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?grrr)ryZcumprodr?maximum accumulaterZcumsumminimumr1rr;r/rZbool_rr)rCZ accum_funcr\Zmask_aZmask_bvalsr`rkr*r*r+ na_accum_funcs"    rA)T)r#r$r%r&)r1rrXrqr%r$rS)NN)r1rr}r~)rCr]r\r$r`rr%r)NNN) rCr]r\r$r}rrrr`rr%r)r1rr%r)r1rr%r$r')r1r)rrr%r)rCr]r[r^r%r) rCr]r[r^r\r$r`rr%r$) rCr]r[r^r\r$r_rr`rr%r) rkrr[r^r`rrr]r%r) rCr]r[r^r\r$r`rr%r)r[r^r\r$)rrr[r r%r]) rrr`rr[r^rrr1rr%r)r[r^r\r$rr)rCr]r[r^r\r$rr) rCr]r[r^r\r$rrr`rr%r) rCr]r[r^r\r$r`rr%r) rkr]r[r^r`rr\r$r%r) rrr`rr[r^r1rr%r)r) rkrr[r^r`rrr r_rr%r)rr r`rr_rr%r$) r'r]r(r]r%r r&r)r%r)r%r r%r.) r'r]r(r]r&r)rr)r%r)rCr r\r$r%r )] __future__rrPrAtypingrrrrnumpyryZpandas._configrZ pandas._libsrrr r Zpandas._typingr r r rrrrrrZpandas.compat._optionalrZpandas.util._exceptionsrZpandas.core.dtypes.commonrrrrrrrrZpandas.core.dtypes.missingrrr rnr(r)r,r-rWrfrhrrrrrrrrerrrrrrrtrrr1rrrrrrZnanminZnanmaxrr rrrsrrrr!rr-r+r9rrAr*r*r*r+s  , (    8  / G  ) " %@= -? b  2-I4  1.V_ +  . 0  $