a pEbR @sddlmZddlZddlZddlZddlmZmZddlZddl Z ddl m Z ddl mZmZmZmZmZddlmZmZmZmZmZmZmZddlmZddlmZmZm 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 dZ4e4duZ5da6ddddddZ7e7e 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=dddZ^ddZ_e8dJdjddedd'd'd=d=dddZ`ddZaddZbebejcZdebejeZfebejgZhebejiZjebejkZlebejmZnddddddZodS)) annotationsN)Anycast) get_option)NaTNaTType TimedeltaiNaTlib) 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/R/home/ja/django-apps/lartica_env/lib/python3.9/site-packages/pandas/core/nanops.pyset_use_bottleneck@sr1zcompute.use_bottleneckcs@eZdZddfdd ZddddZd d d d d ZZS) disallowr )dtypescs"ttdd|D|_dS)Ncss|]}t|jVqdSr,)r type).0dtyper/r/r0 Mz$disallow.__init__..)super__init__tupler3)selfr3 __class__r/r0r:Ks 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|dz@tjdd |i|WdWS1sx0YWn<t y}z$t |d rt||WYd}~n d}~00dS) Nc3s|]}|VqdSr,)rC)r5rB)r<r/r0r7Vr8z0disallow.__call__.._f..nanzreduction operation 'z' not allowed for this dtypeignoreinvalidr) itertoolschainvaluesany__name__replace TypeErrornperrstate ValueErrorr)argskwargsZobj_iterf_nameerDr<r/r0_fSs 2  zdisallow.__call__.._f functoolswrapsrr)r<rDrYr/rXr0__call__Rszdisallow.__call__)rN __module__ __qualname__r:rCr] __classcell__r/r/r=r0r2Jsr2c@s&eZdZdddZdddddZdS) bottleneck_switchNcKs||_||_dSr,)namerU)r<rbrUr/r/r0r:kszbottleneck_switch.__init__r)altr+c snjp jzttWnttfy4dYn0tdddddddfdd}tt |S) NTaxisskipna np.ndarray int | Noner()rLrerfcstjdkr2jD]\}}||vr|||<q|jdkrT|ddurTt||Str|rt|jr|dddur| dd|fd|i|}t |rΈ|f||d|}q|f||d|}n|f||d|}|S)Nr min_countmaskrerd) lenrUitemssizeget_na_for_min_countr. _bn_ok_dtyper6pop _has_infs)rLrerfkwdskr*resultrcZbn_funcZbn_namer<r/r0rDws   z%bottleneck_switch.__call__..f) rbrNgetattrbnAttributeError NameErrorr[r\rr)r<rcrDr/rvr0r]os  "'zbottleneck_switch.__call__)N)rNr^r_r:r]r/r/r/r0rajs rar str)r6rbr+cCst|st|s|dvSdS)N)nansumnanprodF)rr)r6rbr/r/r0rps rpr?c Cs^t|tjr0|jdks |jdkr0t|dSzt|WSt t fyXYdS0dS)Nf8Zf4KF) isinstancerQndarrayr6r Zhas_infsZravelisinfrMrPNotImplementedError)rur/r/r0rrs rrz Scalar | None)r6 fill_valuecCsP|dur |St|r:|dur"tjS|dkr0tjStj Sn|dkrHtjStSdS)z9return the correct fill value for the dtype of the valuesN+inf) _na_ok_dtyperQrEinfr i8maxr )r6rfill_value_typr/r/r0_get_fill_values rrgnpt.NDArray[np.bool_] | None)rLrfrjr+cCs:|dur6t|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")rLrfrjr/r/r0_maybe_get_masks !rrz str | NonezHtuple[np.ndarray, npt.NDArray[np.bool_] | None, np.dtype, np.dtype, Any])rLrfrrrjr+c Cst|s Jt|dd}t|||}|j}d}t|jrLt|d}d}t|}t |||d}|r|dur|dur| 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)rr%rr6rrQasarrayviewrrrMcopyputmaskwhererrint64rfloat64) rLrfrrrjr6 datetimelikeZdtype_ok dtype_maxr/r/r0 _get_valuess0.     r)r6r+cCst|r dSt|jtj S)NF)rrAr4rQintegerr6r/r/r0rZsrznp.dtypercCs|tur nt|r||durt}t|tjspt|r:Jd||krHtj}t|r^tdd}qzt | d}q| |}nXt |rt|tjs||krtj}t |tjkrtdt|dd}n| d |}|S) zwrap our results if neededNzExpected non-null fill_valuernszdatetime64[ns]zoverflow in timedelta operation)unitm8[ns])rrr rrQrr"rEZ datetime64rrastyperfabsr rrSr)rur6rr/r/r0 _wrap_results`s,   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. NTrerfrjrgrhr(r)rLrerfrjcsr|}|jjdv}|r$|dur$t|}|f|||d|}|rnt||jtd}|sn|dus`Jt||||}|S)NmMr)r)r6kindr"rr _mask_datetimelike_result)rLrerfrjrU orig_valuesrrurr/r0new_funcs    z&_datetimelike_compat..new_funcrZ)rrr/rr0_datetimelike_compats rrhzScalar | np.ndarray)rLrer+cCslt|r|d}t|j}|jdkr*|S|dur6|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#r6ndimshaperQfull)rLrerZ result_shaper/r/r0ros    rocs.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. Nrergrh)rLrecs|dkr|jdkr|jdr|jdd|jdkr|jtkr|jtkrt|ddurdfddt t D}nfd dD}t |S|fd |iS) NrZ C_CONTIGUOUSirrjcs(g|] }|fd|iqSrjr/)r5i)arrsrrUrjr/r0 sz:maybe_operate_rowwise..newfunc..csg|]}|fiqSr/r/)r5x)rrUr/r0rr8re) rflagsrr6objectr(listrnrqrangerkrQarray)rLrerUresultsr)rrUrjr0newfuncs*    z&maybe_operate_rowwise..newfuncrZ)rrr/rr0maybe_operate_rowwisesrrrLrerfrjr+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 Frrj)rrrr(rMrLrerfrj_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)rerfrirjintfloat)rLrerfrirjr+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 rrrri) rrrrQr6rsum_maybe_null_outr) rLrerfrirjr6rr dtype_sumthe_sumr/r/r0r|Ds" r|z+np.ndarray | np.datetime64 | np.timedelta64znpt.NDArray[np.bool_]z5np.ndarray | np.datetime64 | np.timedelta64 | NaTType)rurerjrr+cCsDt|tjr4|d|j}|j|d}t||<n |r@tS|S)Nrr) rrQrrrr6rMr r)rurerjrZ axis_maskr/r/r0rus   rc Cst||d|d\}}}}}|}ttj}|jdvrBttj}n&t|rXttj}nt|rh|}|}t|j|||d} t |j ||d} |durt | ddrt tj | } tjdd | | } Wdn1s0Y| 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 rrrrNrFrGr)rrQr6rrrr _get_countsr_ensure_numericrrwrrrRrMrE) rLrerfrjr6rrrZ dtype_countcountrZthe_meanZct_maskr/r/r0nanmeans."   & rc s,fdd}t||d\}}}}}t|jsz|d}Wn2tyn}ztt||WYd}~n d}~00|durtj||<|j }|j dkr|dur|rst |||} n@t (t ddt||} Wdn1s0Ynt|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 cs`t|}s|stjSt*tddt||}Wdn1sR0Y|S)NrGAll-NaN slice encountered)r$rrQrEwarningscatch_warningsfilterwarnings nanmedian)rrjresrfr/r0 get_medians   ,znanmedian..get_medianrr~NrrGr)rrr6rrSrPr{rQrErmrZapply_along_axisrrrrget_empty_reduction_resultrZfloat_r) rLrerfrjrr6rerrZnotemptyrr/rr0rs(  $   ,rztuple[int, ...]znp.dtype | type[np.floating])rrer6rr+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)rQrZarangerkemptyfill)rrer6rZshpdimsretr/r/r0rs   rrz9tuple[int | float | np.ndarray, int | float | np.ndarray]) values_shaperjreddofr6r+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)r6rrrQsqrtnanvarr)rLrerfrrj orig_dtyperrur/r/r0nanstd_s   rZm8c Cst|dd}|j}t|||}t|rB|d}|durBtj||<t|jrft|j ||||j\}}nt|j |||\}}|r|dur| }t ||dt |j |tjd|}|durt||}t ||d} |durt | |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)rer6rFr)r%r6rrrrQrErrrrrrrr expand_dims) rLrerfrrjr6rravgZsqrrur/r/r0rs.        r)rLrerfrrjr+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~)rerfr) rrrr6rrrrQr)rLrerfrrjrrvarr/r/r0nansems&   rc s<tddtddddddddd d fd d }|S) NrE)rbTrrgrhr(rr rc st|||d\}}}}}|dur0|j|dks:|jdkr~z"t|||d}|tjWqttt fyztj}Yq0nt||}t ||||j}|S)Nrrjrr) rrrmrwrrQrEryrPrSr)rLrerfrjr6rrrurmethr/r0 reductions  z_nanminmax..reduction)rar)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_outrLrerfrjrrur/r/r0 nanargmaxs' 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 nanargminMs' rc Cst|dd}t|||}t|js<|d}t|j||}nt|j|||jd}|rr|durr|}t ||d|j |tj d|}|durt ||}||}|r|durt ||d|d}||}|j |tj d} |j |tj d} t | } t | } tjddd 4||d d |d| | d } Wdn1sF0Y|j} t| rn| 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~rNrrrGrIdividerg?g?Fr)r%rrr6rrrrrQrrrr_zero_out_fperrrRrrrrE) rLrerfrjrmeanadjusted adjusted2Z adjusted3m2Zm3rur6r/r/r0nanskew{sB'       D  rcCs4t|dd}t|||}t|js<|d}t|j||}nt|j|||jd}|rr|durr|}t ||d|j |tj d|}|durt ||}||}|r|durt ||d|d}|d}|j |tj d} |j |tj d} tj ddd `d |d d|d|d } ||d |d | } |d|d | d} Wdn1sb0Yt| } t| } t| tjs|d krtjS| dkrdStj ddd | | | }Wdn1s0Y|j}t|r|j|d d}t|tjr0t| 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~rNrrrGrrrFr)r%rrr6rrrrrQrrrrrRrrrrEr)rLrerfrjrrrrZ adjusted4rZm4Zadj numerator denominatorrur6r/r/r0nankurtsN'        8  , r cCsFt|||}|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)rLrerfrirjrur/r/r0r}4s    r}znp.ndarray | int)rurerjrfr+cCsn|dur |S|dus t|dds@|r2|r>dSqj|rjdSn*|rP||}n ||}|rjd||<|S)NrF)rwrrM)rurerjrfZna_maskr/r/r0ras  rzint | float | np.ndarray)rrjrer6r+cCsz|dur4|dur |j|}n t|}||S|durR|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)rmrrQr r4rrr)rrjrer6nrr/r/r0r|s   rznp.ndarray | float | NaTType)rurerjrrir+cCs|durt|tjr|dur:|j||||dk}n8|||dk}|d|||dd}t||}t|rt|rt|r| d}n | d}tj ||<qd||<n|t urt |||rtj }|S)zu Returns ------- Dtype The product of all elements on a given axis. ( NaNs are treated as 1) NrrZc16r~) rrQrrrZ broadcast_torMrZ iscomplexobjrrErcheck_below_min_count)rurerjrriZ null_maskZ below_countZ new_shaper/r/r0rs"         r)rrjrir+cCs:|dkr6|durt|}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)rQr rmr)rrjriZ non_nullsr/r/r0r s r cCstt|tjrRtjdd(tt|dkd|WdS1sF0Ynt|dkrl|jdS|SdS)NrGrHg+=r)rrQrrRrabsr6r4)argr/r/r0rs 8rpearson)method min_periods)abrcCspt|t|krtd|dur$d}t|t|@}|sL||}||}t||kr^tjSt|}|||S)z a, b: ndarrays z'Operands to nancorr must have same sizeNr)rkAssertionErrorr$rrQrE get_corr_func)rrrrvalidrDr/r/r0nancorrs rcs||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/r0rsrcSst||dS)Nrr)rQZcorrcoefrr/r/r0rszUnknown method 'z@', expected one of 'kendall', 'spearman', 'pearson', or callable)Z scipy.statsrrcallablerS)rrr/)rrr0r s      r)rr)rrrrcCsrt|t|krtd|dur$d}t|t|@}|sL||}||}t||kr^tjStj|||ddS)Nz&Operands to nancov must have same sizerrr)rkrr$rrQrEZcov)rrrrrr/r/r0nancov+s r!c CsHt|tjrt|st|r*|tj}nt|rz|tj}Wn^t t fyz|tj}Wn6t y}zt d|d|WYd}~n d}~00Yn0t t |s|j }nt|sDt|sDt|sDz t|}Wn^t t fyBz t|}Wn8t y<}zt d|d|WYd}~n d}~00Yn0|S)NzCould not convert z to numeric)rrQrrrrrrZ complex128rPrSrMimagrealrrrrcomplex)rrr/r/r0rDs, .  .rcsfdd}|S)Ncs|t|}t|}||B}tjdd||}Wdn1sD0Y|rxt|rh|d}t||tj|S)NrGrr)r"rQrRrMrrrrE)ryZxmaskZymaskrjruopr/r0rDes( zmake_nancomp..fr/)r'rDr/r&r0 make_nancompds r(r )rLrfr+c Cstjdtjftjjtj tjftjdtjftjjtjtjfi|\}}|jj dvrD|j}t |}| d}|tjjk}z*|rt j ||<||dd} W|rt||<n|rt||<0|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)rQZcumprodrEmaximum accumulaterZcumsumminimumr6rr"rr rr rZnonzerorkrr4Z _simple_newrArZbool_r) rLZ accum_funcrfZmask_aZmask_brrjr%changedruZnzZnpdtypevalsr/r/r0 na_accum_funcsP              r.)T)NN)NNN)N)r)p __future__rr[rJoperatortypingrrrnumpyrQZpandas._configrZ pandas._libsrrrr r Zpandas._typingr r r rrrrZpandas.compat._optionalrZpandas.core.dtypes.commonrrrrrrrrrrrrrr Zpandas.core.dtypes.dtypesr!Zpandas.core.dtypes.missingr"r#r$Zpandas.core.constructionr%rxr-r.r1r2rarprrrrrrrrrorrrr|rrrrr6rrrrrrZnanminZnanmaxrrrr r}rrrr rrrr!rr(gtZnangtgeZnangeltZnanltleZnanleeqZnaneqneZnanner.r/r/r/r0s  $ @     8/Y%"%1.". ?J /&C1  --V_ + .'