a 鴫j( @sfddlmZddlZddlZddlmZmZmZddlZddl 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/ddddddZ0e0e dGdddZ1GdddZ2ddddddZ3ddd d!Z4ddd"d#d$d%Z5d&dd'd'd(d)d*Z6dd&dd+d,d'd-d.d/d0Z7d1d1d2d3d4Z8ddd2d5d6Z9dd1d7d8d9Z:d:d:d;dd?d@dAdBZdd'ddFdGdHZ>ddddEd&d>dd'ddFdIdJZ?e1dKe;e=dddddLd&d>ddMd'dNdOdPdQZ@dRd>dSd&dTdUdVdWZAe2e;ddddEd&d>dd'dNdFdXdYZBe2ddddEd>ddZd[d\ZCd]d^d&d_d`daZDe Ee jFfd]d'd>dMd1dbdcdddeZGe2dfdgdddfddhd>ddMdidjdkZHe1dKdle2dfdgdddfddhd&d>ddMdmdndoZIe1dKdldddfddhd&d>ddMd'dNdpdqdrZJdsdtZKeKdudvdwZLeKdxdydwZMddddEd&d>dd'dzdFd{d|ZNddddEd&d>dd'dzdFd}d~ZOe1dKdle=ddddEd&d>dd'dNdFddZPe1dKdle=ddddEd&d>dd'dNdFddZQe1dKdle=dddddLd&d>ddMd'dNdOddZRd&d>d'dddddZSe Ee jFfd]d'd>dddddZTddd>d'ddMddddZUdd'dMddddZVddZWe1dKdldddd&d&dddNdddZXdddddZYe1dKdlddfdd&d&dddNdddZZddZ[ddddddZ\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)errorsFTboolNone)vreturncCs tr|adSN)_BOTTLENECK_INSTALLED_USE_BOTTLENECK)r%r*Q/var/www/html/laksyashrimp/venv/lib/python3.9/site-packages/pandas/core/nanops.pyset_use_bottleneck9sr,zcompute.use_bottleneckcsBeZdZdddfdd Zdddd Zd d d d d ZZS)disallowrr$)dtypesr&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#r&cCst|dot|jj|jS)Nr1)hasattr issubclassr1r/r.)r7objr*r*r+checkHszdisallow.checkr)fr&cs"tfdd}tt|S)Nc st||}tfdd|DrDjdd}td|dz|i|WSty}z$t|drzt||WYd}~n d}~00dS)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?rOr*rNr+__call__Kszdisallow.__call__)rF __module__ __qualname__r5r>rS __classcell__r*r*r8r+r-Csr-c@s,eZdZd ddddZddddd ZdS) bottleneck_switchNr$r:cKs||_||_dSr')namerK)r7rXrKr*r*r+r5cszbottleneck_switch.__init__r)altr&c snjp jzttWnttfy4dYn0tdddddddfdd}tt |S) NTaxisskipna np.ndarrayAxisInt | Noner#)rDr[r\cstjdkr2jD]\}}||vr|||<q|jdkrT|ddurTt||Str|rt|jr|dddur| dd|fd|i|}t |rΈ|f||d|}q|f||d|}n|f||d|}|S)Nr min_countmaskr[rZ) lenrKitemssizeget_na_for_min_countr) _bn_ok_dtyper1pop _has_infs)rDr[r\kwdskr%resultrYZbn_funcZbn_namer7r*r+r?os   z%bottleneck_switch.__call__..f) rXrFgetattrbnAttributeError NameErrorrQrRrr)r7rYr?r*rlr+rSgs  "'zbottleneck_switch.__call__)N)rFrTrUr5rSr*r*r*r+rWbsrWrstr)r1rXr&cCs|tkrt|s|dvSdS)N)nansumnanprodnanmeanF)objectr)r1rXr*r*r+rfsrfr:c CsTt|tjr&|jdvr&t|dSzt|WSt t fyNYdS0dS)N)f8Zf4KF) isinstancenpndarrayr1r Zhas_infsZravelisinfrErHNotImplementedError)rkr*r*r+rhs  rhz Scalar | None)r1 fill_valuecCsP|dur |St|r:|dur"tjS|dkr0tjStj Sn|dkrHtjStSdS)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_values rr]npt.NDArray[np.bool_] | None)rDr\r`r&cCs4|dur0|jjdvrdS|s(|jjdvr0t|}|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)rDr\r`r*r*r+_maybe_get_masks ! rrz str | Nonez/tuple[np.ndarray, npt.NDArray[np.bool_] | None])rDr\r}rr`r&cCst|||}|j}d}|jjdvr6t|d}d}|r|durt|||d}|dur|r|slt|r| }t |||nt |||}||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) rr1rryZasarrayviewrrErcopyputmaskwhere)rDr\r}rr`r1 datetimeliker*r*r+ _get_valuess")    rznp.dtype)r1r&cCsN|}|jdvrttj}n.|jdkr4ttj}n|jdkrJttj}|S)NZbiur?)rryr1int64Zuint64float64)r1Z dtype_maxr*r*r+_get_dtype_maxDs    rcCst|r dSt|jtj S)NF)rr<r/ryintegerr1r*r*r+rPsrrcCs|tur n|jdkr|dur"t}t|tjst|r>Jd||krLtj}t|rhtdd |}nt | |}|j |dd}n | |}n~|jdkrt|tjs||kst |rt d |}n.t|tjkrtd nt |j |dd}n| d  |}|S) zwrap our results if neededMNzExpected non-null fill_valuernsFrmzoverflow in timedelta operationm8[ns])rrr rxryrzrr@Z datetime64astyperrisnanZ timedelta64fabsr rrI)rkr1r}r*r*r+ _wrap_resultsVs.     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. NTr[r\r`r]r^r#rrDr[r\r`csr|}|jjdv}|r$|dur$t|}|f|||d|}|rnt||jtd}|sn|dus`Jt||||}|S)Nrr)r})r1rrrr _mask_datetimelike_result)rDr[r\r`rK orig_valuesrrkrr*r+new_funcs    z&_datetimelike_compat..new_funcrP)rrr*rr+_datetimelike_compats rr^zScalar | np.ndarray)rDr[r&cCsp|jjdvr|d}t|j}|jdkr.|S|dur:|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. ZiufcbrNr)r1rrrndimshaperyfull)rDr[r}Z result_shaper*r*r+res     recs.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. Nr[r]r^)rDr[cs|dkr|jdkr|jdr|jdd|jdkr|jtkr|jtkrt|ddurdfddt t D}nfd dD}t |S|fd |iS) NrZ C_CONTIGUOUSirr`cs(g|] }|fd|iqSr`r*)r0i)arrsrrKr`r*r+ sz:maybe_operate_rowwise..newfunc..csg|]}|fiqSr*r*)r0x)rrKr*r+rr3r[) rflagsrr1rur#listrdrgrangeraryarray)rDr[rKresultsr)rrKr`r+newfuncs*    z&maybe_operate_rowwise..newfuncrP)rrr*rr+maybe_operate_rowwisesrr)rDr[r\r`r&cCsn|jjdvr|dur||S|jjdkr>> 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`) r1rrEwarningsr! FutureWarningrrrurr#rDr[r\r`_r*r*r+nananys"    rcCsn|jjdvr|dur||S|jjdkr>> 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+nanalls"    rZM8)r[r\r_r`intfloat)rDr[r\r_r`r&cCsn|j}t||d|d\}}t|}|jdkr2|}n|jdkrHttj}|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)rDr[r\r_r`r1 dtype_sumthe_sumr*r*r+rr\s"   rrz+np.ndarray | np.datetime64 | np.timedelta64znpt.NDArray[np.bool_]z5np.ndarray | np.datetime64 | np.timedelta64 | NaTType)rkr[r`rr&cCsRt|tjr4|d|j}|j|d}t||<n|rNtt|jS|S)Nrr) rxryrzrrr1rEr r)rkr[r`rZ axis_maskr*r*r+rs   rc Cs*|j}t||d|d\}}t|}ttj}|jdvrFttj}n*|jdvr^ttj}n|jdkrp|}|}t|j|||d}|j||d}t |}|durt |dd rt tj |}tj d d ||} Wdn1s0Y|dk} | r&tj| | <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.values) 1.5 rrriur?rNrFignore)r)r1rrryrr _get_countsrr_ensure_numericrmrrzerrstaterEr@) rDr[r\r`r1rZ dtype_countcountrZthe_meanZct_maskr*r*r+rts.!     &  rtrZc s|jjdko|du}dfdd }|j}t||dd\}}|jjdkr|jtkrtt|}|dvrttd|dz|d }Wn2ty}ztt ||WYd}~n d}~00|s|dur|j j s| }t j||<|j} |jd kr|dur| rst |||} ntvtd d t|jd d krF|d ks`|jd d krv|d krvt jt |dd} nt j||d} Wdn1s0Yn t|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?Ncsr|durt|}n|}s*|s*tjSt,tddtt||}Wdn1sd0Y|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)Zkeepdimsr)N)r1rrrur infer_dtyperHrrIrqrZ writeablerryr@rcrZapply_along_axisrrrrrrZsqueeze_get_empty_reduction_resultr) rDr[r\r`Zusing_nan_sentinelrr1inferrederrZnotemptyrr*rr+rsH   $    0rrr )rr[r&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   rz-tuple[float | np.ndarray, float | np.ndarray]) values_shaper`r[ddofr1r&cCst||||d}|||}t|r<||krxtj}tj}n>> from pandas.core import nanops >>> s = pd.Series([1, np.nan, 2, 3]) >>> nanops.nanstd(s.values) 1.0 zM8[ns]rrr)r1rrrysqrtnanvarr)rDr[r\rr`Z orig_dtyperkr*r*r+nanstds $  rZm8)rDr[r\rc Cs|j}t|||}|jdvr8|d}|dur8tj||<|jjdkr^t|j||||j\}}nt|j|||\}}|r|dur|}t ||dt |j |tj d|}|durt ||}t ||d} |durt | |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) rDr[r\rr`r1rravgZsqrrkr*r*r+rs,%        r)rDr[r\rr`r&cCst|||||dt|||}|jjdkr4|d}|sN|durN|rNtjSt|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) rrr1rrrEryr@rrr)rDr[r\rr`rrvarr*r*r+nansems&   rcs<tddtddddddddd fd d }|S) Nr@)rXTrr]r^r#rrcsJ|jdkrt||St|||d\}}t||}t||||j}|S)Nrrr`)rcrerrmrrrDr[r\r`rkrmethr*r+ reduction;s   z_nanminmax..reduction)rWr)rrrr*rr+ _nanminmax:s"rminr~)rmax-infzint | np.ndarraycCs0t|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+ nanargmaxUs& rcCs0t|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]) Tr~r)rZargminrrr*r*r+ nanargmins& rc Cs t|||}|jjdkr2|d}t|j||}nt|j|||jd}|rj|durj|}t||dn|s|dur| rtj Stj ddd$|j |tj d|}Wdn1s0Y|durt||}||}|r|durt||d|d}||}|j |tj d} |j |tj d} t| } t| } tj ddd4||d d |d| | d } Wdn1s0Y|j} | jdkr| j| d d } t| tjrt| dkd| } tj | |dk<n(| 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)rr1rrrrrryrrEr@rrrr_zero_out_fperrrxrzrr/) rDr[r\r`rmeanadjusted adjusted2Z adjusted3m2Zm3rkr1r*r*r+nanskewsF%    2  D  rcCs~t|||}|jjdkr2|d}t|j||}nt|j|||jd}|rj|durj|}t||dn|s|dur| rtj Stj ddd$|j |tj d|}Wdn1s0Y|durt||}||}|r|durt||d|d}|d}|j |tj d} |j |tj d} tj ddd`d |d d|d|d } ||d |d | } |d|d | d} Wdn1s0Yt| } t| } t| tjs|d krtj S| dkr|jdStj ddd| | | }Wdn1s"0Y|j}|jdkrL|j|d d }t|tjrzt| 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?rvrNrrrrrrFr)rr1rrrrrryrrEr@rrrrrrxrzr/r)rDr[r\r`rrrrZ adjusted4rZm4Zadj numerator denominatorrkr1r*r*r+nankurt sR%    2   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 -------- >>> from pandas.core import nanops >>> s = pd.Series([1, 2, 3, np.nan]) >>> nanops.nanprod(s.values) 6.0 Nrr)rrprodrr)rDr[r\r_r`rkr*r*r+rsjs    rsznp.ndarray | int)rkr[r`r\r&cCsn|dur |S|dus t|dds@|r2|r>dSqj|rjdSn*|rP||}n ||}|rjd||<|S)NrF)rmrrE)rkr[r`r\Zna_maskr*r*r+rs  rznp.dtype[np.floating]z&np.floating | npt.NDArray[np.floating])rr`r[r1r&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)rcrryr r/rrr)rr`r[r1nrr*r*r+rs   rznp.ndarray | float | NaTTypeztuple[int, ...])rkr[r`rr_r&c Cs|dur|dkr|S|durt|tjr|durN|j||||dk}n8|||dk}|d|||dd}t||}t|rt|rt|r| d}nt |s|j ddd}tj ||<nd||<n@|t urt |||rt|dd}t |r|d }ntj }|S) zu Returns ------- Dtype The product of all elements on a given axis. ( NaNs are treated as 1) NrrZc16rvFrr1r@)rxryrzrrZ broadcast_torErZ iscomplexobjrrr@rcheck_below_min_countrmr/) rkr[r`rr_Z null_maskZ below_countZ new_shapeZ result_dtyper*r*r+rs.           r)rr`r_r&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)ryr rcr)rr`r_Z non_nullsr*r*r+r s rcCsFt|tjr$tt|dkd|St|dkr>|jdS|SdS)Ng+=r)rxryrzrabsr1r/)argr*r*r+r*s rpearson)method min_periodsr z int | None)abrrr&cCst|t|krtd|dur$d}t|t|@}|sL||}||}t||kr^tjSt|}t|}t|}|||S)z a, b: ndarrays z'Operands to nancorr must have same sizeNr)raAssertionErrorr rryr@r get_corr_func)rrrrvalidr?r*r*r+nancorr2s  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||dSNrr*rrrr*r+rXszget_corr_func..funcZspearman spearmanrcs||dSrr*rrr*r+r_srcSst||dS)Nrr)ryZcorrcoefrr*r*r+reszUnknown method 'z@', expected one of 'kendall', 'spearman', 'pearson', or callable)Z scipy.statsrr callablerI)rrr*)rr r+rRs      r)rr)rrrrr&cCst|t|krtd|dur$d}t|t|@}|sL||}||}t||kr^tjSt|}t|}tj|||ddS)Nz&Operands to nancov must have same sizerrr!)rarr rryr@rZcov)rrrrrr*r*r+nancovrs r#c Cst|tjr|jjdvr&|tj}n|jtkrt |}|dvrRt d|dz|tj }Wn^t t fyz|tj}Wn6t y}zt d|d|WYd}~n d}~00Yn0t t|s|j}nt|st|st|st|trt d|dz t|}Wn^t t fy~z t|}Wn8t yx}zt d|d|WYd}~n d}~00Yn0|S)NrrzCould not convert rzCould not convert string 'z ' to numeric)rxryrzr1rrrrur rrHZ complex128rIrEimagrealrrrrqrcomplex)rrrr*r*r+rs6    .   .rr )rDr\r&c Cstjdtjftjjtj tjftjdtjftjjtjtjfi|\}}|jj dvsVJ|rt |jj tj tj fs|}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)ryZcumprodr@maximum accumulaterZcumsumminimumr1rr<r/rZbool_rr)rDZ accum_funcr\Zmask_aZmask_bvalsr`rkr*r*r+ na_accum_funcs      r+)T)NN)NNN)N)r)] __future__rrQrBtypingrrrrnumpyryZpandas._configrZ pandas._libsrrr r Zpandas._typingr r r rrrrrrZpandas.compat._optionalrZpandas.util._exceptionsrZpandas.core.dtypes.commonrrrrrrrrZpandas.core.dtypes.missingrrr rnr(r)r,r-rWrfrhrrrrrrrrerrrrrrrtrrr1rrrrrrZnanminZnanmaxrrrr rsrrrrrrrr#rr+r*r*r*r+s  ,  (   8/G )"%@="-?b 2-I4  1.V_ + .0 $