o d@sddlmZddlZddlZddlZddlmZmZmZddl Z ddl Z ddl m Z ddlmZmZmZmZddlmZmZmZmZmZmZmZmZmZddlmZddlm Z dd l!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/dd l0m1Z1dd l2m3Z3m4Z4m5Z5dd l6m7Z7ed ddZ8e8duZ9da:ddddZ;e;e dGdddZdd#d$Z? ddd'd(Z@dd.d/ZA   ddd4d5ZBdd6d7ZCddd9d:ZDdd=d>ZEddBdCZFddDdEZGddddFddGdHZHddddFddIdJZIePz$disallow.__init__..)super__init__tupler7)selfr7 __class__r3r4r>Ns zdisallow.__init__r-cCst|do t|jj|jS)Nr:)hasattr issubclassr:r8r7)r@objr3r3r4checkRszdisallow.checkfrcs"tfdd}tt|S)Nc st||}tfdd|Dr"jdd}td|dz!tjdd|i|WdWS1s._f..nanzreduction operation 'z' not allowed for this dtypeignoreinvalidr) itertoolschainvaluesany__name__replace TypeErrornperrstate ValueErrorr)argskwargsobj_iterf_nameerGr@r3r4_fVs   (  zdisallow.__call__.._f functoolswrapsrr)r@rGr]r3r\r4__call__Us zdisallow.__call__)r7rr.r/r.r-)rGrr.r)rQ __module__ __qualname__r>rFra __classcell__r3r3rAr4r6Ms r6c@s"eZdZd d ddZd dd ZdS) bottleneck_switchNr.r/cKs||_||_dSr0)namerX)r@rgrXr3r3r4r>ns zbottleneck_switch.__init__altrc sfjpjzttWn ttfydYnwtdddd fd d }tt |S) NTaxisskipnarO np.ndarrayrjAxisInt | Nonerkr-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_countmaskrjri) lenrXitemssizeget_na_for_min_countr2 _bn_ok_dtyper:pop _has_infs)rOrjrkkwdskr,resultrhbn_funcbn_namer@r3r4rGzs$  z%bottleneck_switch.__call__..f)rOrlrjrmrkr-) rgrQgetattrbnAttributeError NameErrorr_r`rr)r@rhrGr3r{r4rars  'zbottleneck_switch.__call__r0)r.r/)rhrr.r)rQrcrdr>rar3r3r3r4rfms rfr:rrgstrcCst|s t|s |dvSdS)N)nansumnanprodnanmeanF)rr")r:rgr3r3r4rusruc CsPt|tjr|jdvrt|dSzt|WSt t fy'YdSw)N)f8f4KF) isinstancerTndarrayr:r has_infsravelisinfrPrSNotImplementedError)rzr3r3r4rws  rw 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_dtyperTrHinfr i8maxr )r:rfill_value_typr3r3r4_get_fill_valuesrrOrlrkronpt.NDArray[np.bool_] | NonecCs:|durt|jst|jrdS|st|jrt|}|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)rr:rr"r%)rOrkror3r3r4_maybe_get_masks !rrr str | NoneHtuple[np.ndarray, npt.NDArray[np.bool_] | None, np.dtype, np.dtype, Any]c Cst|sJt|dd}t|||}|j}d}t|jr&t|d}d}t|}t |||d}|rW|durW|durW| rW|sC|rO| }t |||nt |||}|}t|sat|rhttj}n t|rrttj}|||||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 T extract_numpyFi8)rrN)r r(rr:r"rTasarrayviewrrrPcopyputmaskwhererrint64rfloat64) rOrkrrror: datetimelikedtype_ok dtype_maxr3r3r4 _get_valuess0 .    rcCst|rdSt|jtj S)NF)r"rDr8rTintegerr:r3r3r4rasrnp.dtypecCs|tur |St|rL|durt}t|tjsEt|rJd||kr&tj}t|r4tdd |}nt | |}|j |dd}|S| |}|St |rt|tjs||ks_t |ritd |}|St|tjkrutdt |j |dd}|S| d |}|S) zwrap our results if neededNzExpected non-null fill_valuernsFrzoverflow in timedelta operationm8[ns])rrr rrTrr%rH datetime64astyperrr!isnan timedelta64fabsr rrV)rzr:rr3r3r4 _wrap_resultsgs8#    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. NTrjrkrorOrlrjrmrkr-rorcsr|}|jjdv}|r|durt|}|f|||d|}|r7t||jtd}|s7|dus0Jt||||}|S)NmMr)r)r:kindr%rr _mask_datetimelike_result)rOrjrkrorX orig_valuesrrzrr3r4new_funcs   z&_datetimelike_compat..new_func)rOrlrjrmrkr-rorr^)rrr3rr4_datetimelike_compats  rrjrmScalar | np.ndarraycCsht|r |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. rNr)rrr&r:ndimshaperTfull)rOrjr result_shaper3r3r4rts    rtcs(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. NrjrOrlrjrmcs|dkrT|jdkrT|jdrT|jdd|jdkrT|jtkrT|jtkrTt|ddurEdfddt t D}n fd dD}t |S|fd |iS) Nr C_CONTIGUOUSirrocs(g|]}|fd|iqSror3)r9i)arrsrrXror3r4 sz:maybe_operate_rowwise..newfunc..csg|] }|fiqSr3r3)r9x)rrXr3r4rsrj) rflagsrr:objectr-listrsrvrangerprTarray)rOrjrXresultsr)rrXror4newfuncs*    z&maybe_operate_rowwise..newfunc)rOrlrjrmr^)rrr3rr4maybe_operate_rowwises rrcC^t|jr|jjdkrtjdttdt||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 -------- >>> from pandas.core import nanops >>> s = pd.Series([1, 2]) >>> nanops.nanany(s) True >>> from pandas.core import nanops >>> s = pd.Series([np.nan]) >>> nanops.nanany(s) False rzz'any' with datetime64 dtypes is deprecated and will raise in a future version. Use (obj != pd.Timestamp(0)).any() instead. stacklevelFrro) r"r:rwarningsr* FutureWarningrrrrr-rPrOrjrkro_r3r3r4nanany"  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) True >>> from pandas.core import nanops >>> s = pd.Series([1, 0]) >>> nanops.nanall(s) False rzz'all' with datetime64 dtypes is deprecated and will raise in a future version. Use (obj != pd.Timestamp(0)).all() instead.rTr) r"r:rrr*rrrrrr-allrr3r3r4nanall*rrM8)rjrkrnrornintfloatc Csft||d|d\}}}}}|}t|r|}n t|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 -------- >>> from pandas.core import nanops >>> s = pd.Series([1, 2, np.nan]) >>> nanops.nansum(s) 3.0 rrrrn) rrr!rTr:rsum_maybe_null_outr) rOrjrkrnror:rr dtype_sumthe_sumr3r3r4ras" rrz+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) rrTrrrr:rPr r)rzrjror axis_maskr3r3r4rs  rc Cst||d|d\}}}}}|}ttj}|jdvr!ttj}nt|r,ttj}nt|r4|}|}t|j|||d} t |j ||d} |durt | ddrt tj | } tjdd  | | } Wdn1skwY| dk} | r}tj| | <| 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) 1.5 rrrrNrFrJr)rrTr:rrrr _get_countsr_ensure_numericrr~rrrUrPrH) rOrjrkror:rrr dtype_countcountrthe_meanct_maskr3r3r4rs2"     rc s"d fdd }t||dd\}}}}}t|js4z|d}Wnty3}ztt||d}~ww|dur=tj||<|j }|j dkr|dur|rwsUt |||} n7t t dd tt||} Wdn1sqwYnt|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 -------- >>> from pandas.core import nanops >>> s = pd.Series([1, np.nan, 2, 2]) >>> nanops.nanmedian(s) 2.0 Ncst|dur t|}n|}s|stjSttddtt||}Wd|S1s3wY|S)NrJAll-NaN slice encountered) r'rrTrHrcatch_warningsfilterwarningsRuntimeWarning nanmedian)r_maskresrkr3r4 get_medians    znanmedian..get_medianr)rorrrrJrr0)rrr:rrVrSrrTrHrrrapply_along_axisrrrrrget_empty_reduction_resultrfloat_r) rOrjrkrorr:rerrnotemptyrr3rr4rs4     rrtuple[int, ...]r np.dtype | type[np.floating]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)rTrarangerpemptyfill)rrjr:rshpdimsretr3r3r4r8s  r values_shaperddof-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) rr8r rTrHrrrPr)r rorjr r:rdr3r3r4_get_counts_nanvarSs rrr rjrkr roc CsT|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) 1.0 zM8[ns]rrr)r:rrrTsqrtnanvarr)rOrjrkr ro orig_dtyperrzr3r3r4nanstds $  rm8c Cst|dd}|j}t|||}t|r!|d}|dur!tj||<t|jr3t|j ||||j\}}n t|j |||\}}|rN|durN| }t ||dt |j |tjd|}|durdt||}t ||d} |durwt | |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 -------- >>> from pandas.core import nanops >>> s = pd.Series([1, np.nan, 2, 3]) >>> nanops.nanvar(s) 1.0 TrrNr)rjr:rFr)r(r:rrrrTrHrrrrrrrr expand_dims) rOrjrkr ror:rravgsqrrzr3r3r4rs. %      rcCst|||||dt|||}t|js|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) 0.5773502691896258 rrN) rrrr:rrPrTrHrrr)rOrjrkr rorrvarr3r3r4nansems&   rcs2tddtdddddfdd}|S)NrH)rgTrrOrlrjrmrkr-rorr.rc st|||d\}}}}}|dur|j|dks|jdkr>zt|||d}|tjWnttt fy=tj}Ynwt||}t ||||j}|S)Nrrorr) rrrrr~rrTrHrrSrVr)rOrjrkror:rrrzrmethr3r4 reduction2s   z_nanminmax..reduction) rOrlrjrmrkr-rorr.r)rfr)rrrr3rr4 _nanminmax1sr minr)rmax-infOint | np.ndarraycC6t|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_outrOrjrkrorrzr3r3r4 nanargmaxR' 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(r)r3r3r4 nanargminr+r-c Cst|dd}t|||}t|js|d}t|j||}n t|j|||jd}|r:|dur:|}t ||dn |sG|durG| rGtj S|j |tj d|}|dur[t||}||}|rl|durlt ||d|d}||}|j |tj d} |j |tj d} t| } t| } tjddd ||d d |d| | d } Wdn1swY|j} t| r| j| d d} t| tjrt| dkd| } tj | |dk<| S| dkrdn| } |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) 1.7320508075688787 TrrrNrrrJrLdividerg?g?Fr)r(rrr:rrrrrTrrPrHrrr_zero_out_fperrrUrrr) rOrjrkrormeanadjusted adjusted2 adjusted3m2m3rzr:r3r3r4nanskewsJ '      & r8cCsFt|dd}t|||}t|js|d}t|j||}n t|j|||jd}|r:|dur:|}t ||dn |sG|durG| rGtj S|j |tj d|}|dur[t||}||}|rl|durlt ||d|d}|d}|j |tj d} |j |tj d} tjddd 0d |d d|d|d } ||d |d | } |d|d | d} Wdn1swYt| } t| } t| tjs|d krtj S| dkrdStjddd | | | }Wdn1swY|j}t|r |j|d d}t|tjr!t| 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) -1.2892561983471076 TrrrNrrrJr.r0rFr)r(rrr:rrrrrTrrPrHrrrrUr1rrr)rOrjrkrorr2r3r4 adjusted4r6m4adj numerator denominatorrzr:r3r3r4nankurtsV '          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) 6.0 Nrr)rrprodrr)rOrjrkrnrorzr3r3r4rks   rnp.ndarray | intcCsr|dur|S|dust|dds"|r|rdS|S|r dS|S|r*||}n||}|r7d||<|S)NrF)r~rrP)rzrjrorkna_maskr3r3r4r(s    r(float | np.ndarraycCsz|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)rrrrTr@r8rr r)r rorjr:nrr3r3r4rs   rnp.ndarray | float | NaTTypec 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) Nrrc16rFrr:rH)rrTrrr broadcast_torPr iscomplexobjrrrHrcheck_below_min_countr~r8) rzrjrorrn null_mask below_count new_shape result_dtyper3r3r4rs4           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)rTr@rrr)rrorn non_nullsr3r3r4rJ s rJcCsrt|tjr*tjddtt|dkd|WdS1s#wYdSt|dkr7|jdS|S)NrJrKg+=r)rrTrrUrabsr:r8)argr3r3r4r1+s $r1pearson)method min_periodsabrSr rT int | NonecCspt|t|kr td|durd}t|t|@}|s&||}||}t||kr/tjSt|}|||S)z a, b: ndarrays z'Operands to nancorr must have same sizeNr)rpAssertionErrorr'rrTrH get_corr_func)rUrVrSrTvalidrGr3r3r4nancorr4s   r[)Callable[[np.ndarray, np.ndarray], float]csx|dkrddlmfdd}|S|dkr$ddlmfdd}|S|d kr.d d}|St|r4|Std |d ) Nkendallr kendalltauc||dSNrr3rUrVr^r3r4rWzget_corr_func..funcspearman spearmanrcr`rar3rbrer3r4r^rcrRcSst||dS)Nrr)rTcorrcoefrbr3r3r4rdszUnknown method 'z@', expected one of 'kendall', 'spearman', 'pearson', or callable) scipy.statsr_rfcallablerV)rSrr3)r_rfr4rYQs      rY)rTr cCsrt|t|kr td|durd}t|t|@}|s&||}||}t||kr/tjStj|||ddS)Nz&Operands to nancov must have same sizerrrg)rprXr'rrTrHcov)rUrVrTr rZr3r3r4nancovqs rlc Cs,t|tjrYt|st|r|tj}|St|rWz|tj}Wn)t t fyKz |tj}WY|St yJ}z t d|d|d}~wwwt t |sW|j }|St|st|st|szt|}W|St t fyzt|}WY|St y}z t d|d|d}~www|S)NzCould not convert z to numeric)rrTrrrrrr complex128rSrVrPimagrealrrrrcomplex)rrr3r3r4rsB     rcsfdd}|S)Ncs|t|}t|}||B}tjdd ||}Wdn1s"wY|r.fr3)rurGr3rtr4 make_nancomps rvr 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)rTcumprodrHmaximum accumulatercumsumminimumr:rrDr8rbool_rr%)rO accum_funcrkmask_amask_bvalsrorzr3r3r4 na_accum_funcs"    r)T)r,r-r.r/)r:rrgrr.r-rb)NN)r:rrr)rOrlrkr-rorr.r)NNN) rOrlrkr-rrrrrorr.r)r:rr.r-r0)r:r)rrr.r)rOrlrjrmr.r) rOrlrjrmrkr-rorr.r-) rOrlrjrmrkr-rnrrorr.r) rzrrjrmrorrrlr.r) rOrlrjrmrkr-rorr.r)rjrmrkr-) rrrjr r:rrrr.rl) r rrorrjrmr rr:rr.r )rjrmrkr-r r) rOrlrjrmrkr-r rrorr.r) rOrlrjrmrkr-rorr.r%) rzrlrjrmrorrkr-r.rA) r rrorrjrmr:rr.rD)r) rzrFrjrmrorrrrnrr.rF)rrrorrnrr.r-) rUrlrVrlrSr rTrWr.r)rSr r.r\) rUrlrVrlrTrWr rWr.r)rOr rkr-r.r )t __future__rr_rMoperatortypingrrrrnumpyrTpandas._configr pandas._libsrrr r pandas._typingr r r rrrrrrpandas.compat._optionalrpandas.util._exceptionsrpandas.core.dtypes.commonrrrrrrrrrrr r!r"r#pandas.core.dtypes.dtypesr$pandas.core.dtypes.missingr%r&r'pandas.core.constructionr(rr1r2r5r6rfrurwrrrrrrrtrrrrrrrrr:rrrrrr nanminnanmaxr*r-r8r?rr(rrrJr1r[rYrlrrvgtnangtgenangeltnanltlenanleeqnaneqnenannerr3r3r3r4s  , @      8  / Y  ) " %:7 .? P /-J4  --Xa +  . 0