o ۭj(@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_dtypenotna bottleneckwarn)errorsFTvboolreturnNonecCstr|adSdSN)_BOTTLENECK_INSTALLED_USE_BOTTLENECK)r$r+O/var/www/html/CropPilot/venv/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,r6Ds zdisallow.__init__r%cCst|do t|jj|jS)Nr2)hasattr issubclassr2r0r/)r8objr+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>)r1r=)r8r+r,r3Or4z0disallow.__call__.._f..nanzreduction operation 'z' not allowed for this dtyper) itertoolschainvaluesany__name__replace TypeError ValueErrorr)argskwargsobj_iterf_nameer?r8r+r,_fLs   zdisallow.__call__.._f functoolswrapsrr)r8r?rPr+rOr,__call__Ks zdisallow.__call__)r/rr&r'r&r%)r?rr&r)rF __module__ __qualname__r6r>rT __classcell__r+r+r9r,r.Cs r.c@s"eZdZd d ddZd dd ZdS) bottleneck_switchNr&r'cKs||_||_dSr()namerK)r8rZrKr+r+r,r6cs zbottleneck_switch.__init__altrc sfjpjzttWn ttfydYnwtdddd fd d }tt |S) NTaxisskipnarD 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]r\) lenrKitemssizeget_na_for_min_countr* _bn_ok_dtyper2pop _has_infs)rDr]r^kwdskr$resultr[bn_funcbn_namer8r+r,r?os$  z%bottleneck_switch.__call__..f)rDr_r]r`r^r%) rZrFgetattrbnAttributeError NameErrorrRrSrr)r8r[r?r+rnr,rTgs  'zbottleneck_switch.__call__r()r&r')r[rr&r)rFrVrWr6rTr+r+r+r,rYbs rYr2rrZstrcCs|tkr t|s |dvSdS)N)nansumnanprodnanmeanF)objectr)r2rZr+r+r,rhsrhc CsPt|tjr|jdvrt|dSzt|WSt t fy'YdSw)N)f8f4KF) isinstancenpndarrayr2r has_infsravelisinfrErHNotImplementedError)rmr+r+r,rjs  rj 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_dtyper~r@infr i8maxr )r2rfill_value_typr+r+r,_get_fill_valuesrrDr_r^rbnpt.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)r2kindr)rDr^rbr+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)rr) rr2rr~asarrayviewrrErcopyputmaskwhere)rDr^rrrbr2 datetimeliker+r+r, _get_valuess$ )   rnp.dtypecCsR|}|jdvrttj}|S|jdkrttj}|S|jdkr'ttj}|S)Nbiur?)rr~r2int64uint64float64)r2 dtype_maxr+r+r,_get_dtype_maxDs    rcCst|rdSt|jtj S)NF)rr<r0r~integerr2r+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 r}r~rrr@ datetime64astyperrisnan timedelta64fabsr rrI)rmr2rr+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^rbrDr_r]r`r^r%rbrcsr|}|jjdv}|r|durt|}|f|||d|}|r7t||jtd}|s7|dus0Jt||||}|S)Nrr)r)r2rrrr _mask_datetimelike_result)rDr]r^rbrK orig_valuesrrmrr+r,new_funcs   z&_datetimelike_compat..new_funcrDr_r]r`r^r%rbrrQ)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. iufcbrNr)r2rrrndimshaper~full)rDr]r result_shaper+r+r,rgs     rgcs(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]rDr_r]r`cs|dkrT|jdkrT|jdrT|jdd|jdkrT|jtkrT|jtkrTt|ddurEdfddt t D}n fd dD}t |S|fd |iS) Nr C_CONTIGUOUSirrbcs(g|]}|fd|iqSrbr+)r1i)arrsrrKrbr+r, sz:maybe_operate_rowwise..newfunc..csg|] }|fiqSr+r+)r1x)rrKr+r,rsr]) rflagsrr2ryr%listrfrirangercr~array)rDr]rKresultsr)rrKrbr,newfuncs       z&maybe_operate_rowwise..newfunc)rDr_r]r`rQ)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. stacklevelFrrb) r2rrEwarningsr" FutureWarningrrryrr%rDr]r^rb_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) r2rallrr"rrrryrr%rr+r+r,nanallrrM8)r]r^rarbraintfloatcCsn|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?rrra) r2rrrr~rsum_maybe_null_outr)rDr]r^rarbr2 dtype_sumthe_sumr+r+r,rv\s"   rvrm+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) r}r~rrrr2rEr r)rmr]rbr 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)r2rrr~rr _get_countsrr_ensure_numericrqrrerrstaterEr@) rDr]r^rbr2r dtype_countcountrthe_meanct_maskr+r+r,rxs2!       rxc 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 rr~r@rcatch_warningsfilterwarningsRuntimeWarning nanmedian)r_maskresr^r+r, get_medians    znanmedian..get_median)rbrstringmixedzCannot convert to numericrzrrrrT)keepdimsrr()r2rrryr infer_dtyperHrrIrur writeablerr~r@rerapply_along_axisrrrrrrsqueeze_get_empty_reduction_resultr) rDr]r^rbusing_nan_sentinelrr2inferrederrnotemptyrr+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)r~rarangercemptyrfillr@)rr]shpdimsretr+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) rr0rr~r@rrrEr)r rbr]rr2rdr+r+r,_get_counts_nanvarZs rrrr]r^rrbc 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)r2rrr~sqrtnanvarr)rDr]r^rrb orig_dtypermr+r+r,nanstds $  rm8c 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 rrzNr?r)r]r2rFr)r2rrrr~r@rrrrrrr expand_dims) rDr]r^rrbr2rravgsqrrmr+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?rzN) rrr2rrrEr~r@rrr)rDr]r^rrbrrvarr+r+r,nansems&   rcs2tddtdddddfd d}|S)Nr@)rZTrrDr_r]r`r^r%rbrcsJ|jdkr t||St|||d\}}t||}t||||j}|S)Nrrrb)rergrrqrrrDr]r^rbrmrmethr+r, reduction;s  z_nanminmax..reductionr)rYr)r!rr"r+r r, _nanminmax:sr#minr)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]) Tr&r)rargmax_maybe_arg_null_outrr+r+r, nanargmaxU& r+cCr()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)rargminr*rr+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?rzrNrrinvaliddividerrg?g?Fr)rr2rrrrrr~rrEr@rrrr_zero_out_fperrr}rrr0) rDr]r^rbrmeanadjusted adjusted2 adjusted3m2m3rmr2r+r+r,nanskewsL %     &   r:cCsvt|||}|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?rzrNrrr/rr2rFr)rr2rrrrrr~rrEr@rrrrr3r}rr0r)rDr]r^rbrr4r5r6 adjusted4r8m4adj numerator denominatorrmr2r+r+r,nankurt sX %          rAcCsFt|||}|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^rarbrmr+r+r,rwjs   rwnp.ndarray | intcCsr|dur|S|dust|dds"|r|rdS|S|r dS|S|r*||}n||}|r7d||<|S)NrF)rqrrE)rmr]rbr^na_maskr+r+r,r*s    r*np.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)rerr~rBr0rrr)r rbr]r2nrr+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) Nrrc16rzFrr2r@)r}r~rrr broadcast_torEr iscomplexobjrrr@rcheck_below_min_countrqr0) rmr]rbrra null_mask below_count new_shape 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)r~rBrer)rrbra non_nullsr+r+r,rN s rNcCsBt|tjrtt|dkd|St|dkr|jdS|S)Ng+=r)r}r~rrabsr2r0)argr+r+r,r3*s r3pearson)method min_periodsabrWr rX 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)rcAssertionErrorr rr~r@r get_corr_func)rYrZrWrXvalidr?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 ) Nkendallr kendalltauc||dSNrr+rYrZrbr+r,rXzget_corr_func..funcspearman spearmanrcrdrer+rfrir+r,r_rgrVcSst||dS)Nrr)r~corrcoefrfr+r+r,reszUnknown method 'z@', expected one of 'kendall', 'spearman', 'pearson', or callable) scipy.statsrcrjcallablerI)rWrr+)rcrjr,r]Rs      r])rXrcCst|t|kr td|durd}t|t|@}|s&||}||}t||kr/tjSt|}t|}tj|||ddS)Nz&Operands to nancov must have same sizerrrk)rcr\r rr~r@rcov)rYrZrXrr^r+r+r,nancovrs rpc 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)r}r~rr2rrrryr rrH complex128rIrEimagrealrrrrurcomplex)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)r~cumprodr@maximum accumulatercumsumminimumr2rr<r0rbool_rr)rD accum_funcr^mask_amask_bvalsrbrmr+r+r, na_accum_funcs"    r)T)r$r%r&r')r2rrZrur&r%rU)NN)r2rrr)rDr_r^r%rbrr&r)NNN) rDr_r^r%rrrrrbrr&r)r2rr&r)r2rr&r%r()r2r)rrr&r)rDr_r]r`r&r) rDr_r]r`r^r%rbrr&r%) rDr_r]r`r^r%rarrbrr&r) rmrr]r`rbrrr_r&r) rDr_r]r`r^r%rbrr&r)r]r`r^r%)rrr]r r&r_) r rrbrr]r`rrr2rr&r)r]r`r^r%rr)rDr_r]r`r^r%rr) rDr_r]r`r^r%rrrbrr&r) rDr_r]r`r^r%rbrr&r') rmr_r]r`rbrr^r%r&rC) r rrbrr]r`r2rFr&rG)r) rmrIr]r`rbrrrJrarr&rI)rrJrbrrarr&r%) rYr_rZr_rWr rXr[r&r)rWr r&r`) rYr_rZr_rXr[rr[r&r)rDr r^r%r&r )] __future__rrRrBtypingrrrrnumpyr~pandas._configr pandas._libsrrr r pandas._typingr r r rrrrrrpandas.compat._optionalrpandas.util._exceptionsrpandas.core.dtypes.commonrrrrrrrrpandas.core.dtypes.missingrrr rrr)r*r-r.rYrhrjrrrrrrrrgrrrrvrrxrrr2rrrrrr#nanminnanmaxr+r.r:rArwr*rrrNr3r_r]rprrr+r+r+r,s  , (    8  / G  ) " %@= -? b  2-I4  1.V_ +  . 0  $