!h(ddlmZddlZddlZddlmZmZmZddlZddl 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 Z-e-duZ.da/dddZ0e0e dGddZ1GddZ2ddZ3ddZ4 ddd"Z5dd(Z6 ddd-Z7dd/Z8dd0Z9ddd1Z:dd4Z;dd8Zdddd:dd<Z?e1d=e;e=ddddd>ddBZ@ddHZAe2e;dddd:ddIZBe2dddd:ddJZCddNZDe jEe jFfddRZGe2dSTdddSddUddVZHe1d=dWe2dSTdddSddUddXZIe1d=dWdddSddUddYZJdZZKeKd[d\]ZLeKd^d_]ZMdddd:ddaZNdddd:ddbZOe1d=dWe=dddd:ddcZPe1d=dWe=dddd:dddZQe1d=dWe=ddddd>ddeZRddgZSe jEe jFfddjZT dddmZUddnZVdoZWe1d=dWdpddqddxZXddzZYe1d=dWddSd{dd|ZZd}Z[ddZ\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)errorsFTvboolreturnNonectr|adSdSN)_BOTTLENECK_INSTALLED_USE_BOTTLENECK)r%s Lc:\xampp_lite_8_4\www\timesheet\venv\Lib\site-packages\pandas/core/nanops.pyset_use_bottleneckr.9szcompute.use_bottleneckc0eZdZd fd Zd dZd d ZxZS)disallowdtypesrr'r(cttd|D|_dS)Nc3>K|]}t|jVdSr*)rtype).0dtypes r- z$disallow.__init__..Fs-IIL//4IIIIIIr/)super__init__tupler2)selfr2 __class__s r-r:zdisallow.__init__Ds; II&IIIII r/r&c`t|dot|jj|jS)Nr7)hasattr issubclassr7r5r2)r<objs r-checkzdisallow.checkHs'sG$$PCINDK)P)PPr/frcptjfd}tt|S)Ncftj||}tfd|Dr.jdd}t d|d |i|S#t$r+}t|drt ||d}~wwxYw)Nc3BK|]}|VdSr*)rB)r6rAr<s r-r8z0disallow.__call__.._f..Os-77s4::c??777777r/nanzreduction operation 'z' not allowed for this dtyper) itertoolschainvaluesany__name__replace TypeError ValueErrorr)argskwargsobj_iterf_nameerCr<s r-_fzdisallow.__call__.._fLs tV]]__==H7777h77777 ++E266PFPPP q$)&)))    #47++.#A,,A- s3A;; B0&B++B0 functoolswrapsrr)r<rCrVs`` r-__call__zdisallow.__call__KsG           $Ar{{r/)r2rr'r(r'r&)rCrr'r)rM __module__ __qualname__r:rBrZ __classcell__)r=s@r-r1r1CsoJJJJJJQQQQr/r1c eZdZdd dZd dZdS) bottleneck_switchNr'r(c "||_||_dSr*)namerR)r<rbrRs r-r:zbottleneck_switch.__init__cs  r/altrcjpj ttn#tt f$rdYnwxYwt jdddd fd }tt|S) NTaxisskipnarK np.ndarrayrfAxisInt | Nonergr&ct jdkr( jD]\}}||vr|||<|jdkr%|dt ||St rw|rut|j r`|dd=| dd|fd|i|}t|r |f||d|}n|f||d|}n |f||d|}|S)Nr min_countmaskrfre) lenrRitemssizeget_na_for_min_countr, _bn_ok_dtyper7pop _has_infs) rKrfrgkwdskr%resultrcbn_funcbn_namer<s r-rCz%bottleneck_switch.__call__..fos^4;!## K--//$$DAq}}"#Q{aDHH[$9$9$A)666 G6 Gl6<.Q.Q G88FD))1HHVT***$WV??$?$??F!((O!$V!N$v!N!N!N!N SJd6JJTJJFFVF$vFFFFMr/)rKrhrfrirgr&) rbrMgetattrbnAttributeError NameErrorrXrYrr)r<rcrCrxrys`` @@r-rZzbottleneck_switch.__call__gs)+s| b'**GG *   GGG    $( % % % % % % % % % %   % NAqzzs*AAr*)r'r()rcrr'r)rMr\r]r:rZr/r-r`r`bsA000000r/r`r7rrbstrcB|tkrt|s|dvSdS)N)nansumnanprodnanmeanF)objectr)r7rbs r-rrrrs+ 2599;;; 5r/ct|tjr0|jdvr't j|dS tj|S#ttf$rYdSwxYw)N)f8f4KF) isinstancenpndarrayr7r has_infsravelisinfrLrONotImplementedError)rws r-rtrts&"*%%3 << ' '< S 1 122 2x##%%% * +uus %A22BB fill_value Scalar | Nonec||St|r-| tjS|dkr tjStj S|dkr tjSt S)z9return the correct fill value for the dtype of the valuesN+inf) _na_ok_dtyperrGinfr i8maxr )r7rfill_value_typs r-_get_fill_valuers`E   !6M''v w V # #9 Kr/rKrhrgrlnpt.NDArray[np.bool_] | Nonech|/|jjdvrdS|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)r7kindr)rKrgrls r-_maybe_get_maskrsFB | <  % %4  V\&$..<.new_funcs |(D0  DL< 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)r7rrr ndimshaperfull)rKrfr result_shapes r-rqrqs"|G##y))#FL11J {a |ETE*V\$(**-EE w|Zv|DDDDr/cttjdddfd}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. NrfrKrhrfric|dkr|jdkr|jdr|jddz |jdkr|jtkr|jt krt |dAdfdttD}nfdD}tj |S|fd |iS) Nr C_CONTIGUOUSirrlc>g|]}|fd|iSrlr~)r6iarrsrrRrls r- z:maybe_operate_rowwise..newfunc..sE>?DDa99tAw9&99r/c"g|] }|fi Sr~r~)r6xrrRs r-rz:maybe_operate_rowwise..newfunc..s+;;;44,,V,,;;;r/rf) rflagsrr7rr&listrprsrangermrarray)rKrfrRresultsrrlrs ` @@r-newfuncz&maybe_operate_rowwise..newfuncs% AII q   ^,!a4'6<?:: && $$<B11111111. 7  r/rcf|jjdvr|||S|jjdkr(tjdt t t||d|\}}|jtkr| 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. stacklevelFrrl) r7rrLwarningsr# FutureWarningrrrrr&rKrfrgrl_s r-nananyrsD|E!!dlzz$ |C  J '))     FFu4HHHIFA|vt$$ ::d  r/cf|jjdvr|||S|jjdkr(tjdt t t||d|\}}|jtkr| 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 -------- >>> 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) r7rallrr#rrrrrr&rs r-nanallrsD|E!!dlzz$ |C  J '))     FFt$GGGIFA|vt$$ ::d  r/M8)rfrgrkrlrkintfloatc,|j}t||d|\}}t|}|jdkr|}n)|jdkrt jtj}|||}t||||j|}|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 rrrCrrrk) r7rrrrrsum_maybe_null_outr)rKrfrgrkrlr7 dtype_sumthe_sums r-rr\sD LEvv!$GGGLFDu%%I zS s  HRZ(( jjYj//GgtT6<9UUUG Nr/rw+np.ndarray | np.datetime64 | np.timedelta64npt.NDArray[np.bool_]r5np.ndarray | np.datetime64 | np.timedelta64 | NaTTypec`t|tjrN|d|j}||}t||<nE|r1tjt|jS|S)Nrr) rrrrrr7rLr r)rwrfrlr axis_masks r-rrs &"*%% :t$$))+*;<<HH$H'' !y 88:: :8D>>&&{'899 9 Mr/c|j}t||d|\}}t|}tjtj}|jdvrtjtj}n7|jdvrtjtj}n|jdkr|}|}t |j|||}|||}t|}|t|dd rvttj |}tj d 5||z } dddn #1swxYwY|dk} | rtj| | <n|dkr||z n tj} | 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 rrriurCrNrFignore)r)r7rrrrr _get_countsrr_ensure_numericrzrrerrstaterLrG) rKrfrgrlr7r dtype_countcountrthe_meanct_masks r-rrsB LEvv!$GGGLFDu%%I(2:&&K zTHRZ(( t  HRZ(( s     dD D D DEjjYj//Gg&&G GGVU;;RZ'' [X & & & ' 'H ' ' ' ' ' ' ' ' ' ' ' ' ' ' '1* ;;== ' "HW &+aii7U??RV Os*D<<EEc@|jjdko|du}dfd }|j}t||d\}}|jjdkr|jtkr+t j|}|dvrt d|d |d}n/#t$r"}t t||d}~wwxYw|s1|/|j j s| }tj||<|j} |jd kr|| r͉stj|||} nt%j5t%jd d t*|jd d kr|d ks|jd d kr/|d kr)tjtj|d } ntj||} dddn #1swxYwYn0t3|j|} n| r |||n tj} t5| |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 rCNc6|t|}n|}s |s tjSt j5t jddttj||}dddn #1swxYwY|S)NrAll-NaN slice encountered) r!rrrGrcatch_warningsfilterwarningsRuntimeWarning nanmedian)r_maskresrgs r- get_medianznanmedian..get_medians =!HHEEFE eiikk 6M  $ & & ) )  #5~   ,qx((C  ) ) ) ) ) ) ) ) ) ) ) ) ) ) )  s 6BBB)rlrstringmixedzCannot convert to numericrrrr rT)keepdimsrr*)r7rrrr infer_dtyperOrrPrr writeablerrrGrorapply_along_axisrrrrrrsqueeze_get_empty_reduction_resultr) rKrfrgrlusing_nan_sentinelrr7inferrederrnotemptyrs ` r-rrs6 *c1Bddl       LEvvDTJJJLFD |C <6 ! !v..H... E& E E EFFF /]]4((FF / / /CHH%%3 . / $"2|% #[[]]Fvt {H{Q4+  B >)*dFCC,.. > >+ "=~ Q1,, Q1,,!l2:f+=+=MMM l6=== > > > > > > > > > > > > > > >$.flDAACC+3>jj&&& e $ $$s+B C%CC?B GGGrrr ctj|}tjt|}tj|||ktj}|tj|S)z The result from a reduction on an empty ndarray. Parameters ---------- shape : Tuple[int, ...] axis : int Returns ------- np.ndarray r)rrarangermemptyrfillrG)rrfshpdimsrets r-rrCs^ (5//C 9SZZ D (3tt|$BJ 7 7 7CHHRV Jr/ values_shapeddof-tuple[float | np.ndarray, float | np.ndarray]ct||||}|||z }t|r||krtj}tj}ntt tj|}||k}|r@tj||tjtj||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) rr5rrrGrrrLr)r*rlrfr+r7rds r-_get_counts_nanvarr/Zs:  dD > > >E  4   A , D==FEARZ''} 88:: , Jq$ ' ' ' JudBF + + + !8Or/rr+rfrgr+rlc |jdkr|d}|j}t|||\}}tjt |||||}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]rrr1)r7rrrsqrtnanvarr)rKrfrgr+rl orig_dtyperws r-nanstdr6stH|xX&&JvvD999LFD WVFf4dSSS T TF  , ,,r/m8c|j}t|||}|jdvr&|d}|tj||<|jjdkr!t |j||||j\}}nt |j|||\}}|r,|*|}t j ||dt| |tj |z }|t j ||}t||z dz} |t j | |d| |tj |z } |jdkr| |d } | 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 rrNrCr)rfr7rFr)r7rrrrrGr/rrrrrr expand_dims) rKrfrgr+rlr7rr.avgsqrrws r-r4r4stJ LE 664 0 0D zTt$$  6F4L |C%flD$flSSqq%flD$EEq $$" 64### &**$bj*AA B BU JC nS$'' 3>> from pandas.core import nanops >>> s = pd.Series([1, np.nan, 2, 3]) >>> nanops.nansem(s.values) 0.5773502691896258 r1rCr) r4rr7rrrLrrGr/rr3)rKrfrgr+rlrrvars r-nansemr>sL 6V$TBBBB 664 0 0D |Ct$$ d&488::&v !&,dD&,OOHE1 d64 H H HC 73<<"'%.. ((r/cntdtdddddfd }|S)NrG)rbTrrKrhrfrirgr&rlrc|jdkrt||St|||\}}t||}t ||||j}|S)Nrrrl)rorqrrzrr)rKrfrgrlrwrmeths r- reductionz_nanminmax..reduction;sx ;!  $VT22 2" F>   '&&t,, tV\BB r/r)r`r)rBrrCs`` r- _nanminmaxrD:skL$LL))) $-1 *)" r/minr)rmax-infint | np.ndarrayct|dd|\}}||}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]) TrGrA)rargmax_maybe_arg_null_outrKrfrgrlrws r- nanargmaxrMUJLvtFNNNLFD ]]4 F!tV < >> 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]) TrrA)rargminrKrLs r- nanargminrQrNr/c4t|||}|jjdkr,|d}t |j||}nt |j|||j}|r-|+|}tj||dn$|s"| | r tj Stj dd5| |tj |z }dddn #1swxYwY|tj||}||z }|r|tj||d|dz}||z}| |tj } | |tj } t| } t| } tj dd5||d z d zz|dz z | | d zz z} dddn #1swxYwY|j} | jdkr| | d } t!| tjr.tj| dkd| } tj | |dk<n/| dkr| dn| } |dkr tj 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 rCrrNrrinvaliddividerrg?g?Fr)rr7rrrrrrrrLrGrrrr9_zero_out_fperrrrrr5) rKrfrgrlrmeanadjusted adjusted2 adjusted3m2m3rwr7s r-nanskewr^sJ 664 0 0D |Ct$$FL$55FL$FLIII $" 64#### (TXXZZ(v Xh 7 7 7::zz$bjz11E9::::::::::::::: ~dD))}H &$" 8T1%%%! IH$I t2: . .B t2: . .B   B   B Xh 7 7 7MM519,, :rBG|LMMMMMMMMMMMMMMM LE zSu511&"*%%"'1f--Fuqy"$''Av 1996M Ms$%DD  D G--G14G1ct|||}|jjdkr,|d}t |j||}nt |j|||j}|r-|+|}tj||dn$|s"| | r tj Stj dd5| |tj |z }dddn #1swxYwY|tj||}||z }|r|tj||d|dz}|dz}| |tj } | |tj } tj dd5d |d z dzz|dz |d z zz } ||d zz|d z z| z} |dz |d z z| dzz} dddn #1swxYwYt| } t| } t!| tjs2|d kr tj S| dkr|jdStj dd5| | z | z }dddn #1swxYwY|j}|jdkr||d }t!|tjr-tj| 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 rCrrNrrrSrrVrFr)rr7rrrrrrrrLrGrrrr9rWrrr5r)rKrfrgrlrrXrYrZ adjusted4r\m4adj numerator denominatorrwr7s r-nankurtrf sJ 664 0 0D |Ct$$FL$55FL$FLIII $" 64#### (TXXZZ(v Xh 7 7 7::zz$bjz11E9::::::::::::::: ~dD))}H &$" 8T1%%%! I1 I t2: . .B t2: . .B Xh 7 7 788519""uqyUQY&?@UQY'5195: qyUQY/"a%7 888888888888888 **I!+..K k2: . .( 1996M !  <$$Q'' ' Xh 7 7 7//[(3./////////////// LE zSu511&"*%%#+*Av66Fuqy Ms6%DD  D (:G..G25G29 JJJct|||}|r||}d||<||}t||||j|S)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)rKrfrgrkrlrws r-rrjsp@ 664 0 0D $"t [[  F dFLI   r/np.ndarray | intc ||S|t|dds0|r|rdSn]|rdSnF|r||}n||}|rd||<|S)NrF)rzrrL)rwrfrlrgna_masks r-rKrKs |  |766599|  xxzz r xxzz r   %hhtnnGGhhtnnG ;;== ! F7O Mr/np.dtype[np.floating]&np.floating | npt.NDArray[np.floating]ch|H||j|z }ntj|}||S|$|j|||z }n||}t |r||S||dS)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)rorrrhr5rrr)r*rlrfr7nrs r-rrs0 |   DHHJJ&AA %%Azz!}}  4 488D>>1T"%!zz%   <<E< * **r/np.ndarray | float | NaTTypetuple[int, ...]c||dkr|S| t|tjr|+|j|||z |z dk}n<|||z dk}|d|||dzdz}tj||}tj|rtt|r`tj|r| d}n&t|s| dd}tj ||<nbd||<n\|turSt|||rBt|dd}t|r|d }n tj }|S) zu Returns ------- Dtype The product of all elements on a given axis. ( NaNs are treated as 1) Nrrc16rFrr7rG)rrrrr broadcast_torLr iscomplexobjrrrGrcheck_below_min_countrzr5) rwrfrlrrk null_mask below_count new_shape result_dtypes r-rrs | Q  Jvrz::  D)DHHTNN:YF!KII + 1A5Kete uTAXZZ'88I Y??I 6)   )'' )?6**=#]]511FF'//=#]]4e]<.funcXs:a##A& &r/spearman) spearmanrc(||dSrr~)rrrs r-rzget_corr_func..func_s9Q??1% %r/rc8tj||dS)Nrr)rcorrcoef)rrs r-rzget_corr_func..funces;q!$$T* *r/zUnknown method 'z@', expected one of 'kendall', 'spearman', 'pearson', or callable) scipy.statsrrcallablerP)rrrrs @@r-rrRs****** ' ' ' ' ' :  )))))) & & & & & 9   + + + &    86 8 8 8  r/)rr+ct|t|krtd|d}t|t|z}|s||}||}t||kr tjSt |}t |}t j|||dS)Nz&Operands to nancov must have same sizerr0r)rmrr!rrrGrcov)rrrr+rs r-nancovrrs 1vvQEFFF !HHuQxx E 99;; eH eH 1vv v AA 6!QT " " "4 ((r/ct|tjr|jjdvr!|tj}n|jtkrtj |}|dvrtd|d |tj }tj tj |s|j}n#ttf$rJ |tj}n&#t$r}td|d|d}~wwxYwYnwxYwnt!|st#|st%|st|t&rtd|d t)|}nN#ttf$r: t+|}n&#t$r}td|d|d}~wwxYwYnwxYw|S)NrrzCould not convert rzCould not convert string 'z ' to numeric)rrrr7rrrrr rrO complex128rLimagrealrPrrrrrcomplex)rr r!s r-rrs6!RZ  N 7<5 $$AA W  q))H... CQ C C CDDD HHR]++vbgajj))Az* R R RR,,AA!RRR#$G$G$G$GHHcQRA R qkk NZ]] Njmm N a   JHHHHII I NaAA:& N N N NAJJ N N N CQ C C CDD#M N N HslCD0'DD0 D*D%%D**D0/D0 FG%,F<;G%< GGGG%$G%r c .tjdtjftjjtj tjftjdtjftjjtjtjfi|\}}|jj dvsJ|rkt|jj tj tj fs;|}t|}|||<||d}|||<n ||d}|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)rcumprodrGmaximum accumulatercumsumminimumr7rr@r5rbool_rr)rK accum_funcrgmask_amask_bvalsrlrws r- na_accum_funcrs S"&M 0 C= /   NFF < D ( ( ( (,j!2RZ4JKK,{{}}DzzT Dq)))t F+++ Mr/)T)r%r&r'r()r7rrbrr'r&r[)NN)r7rrr)rKrhrgr&rlrr'r)NNN) rKrhrgr&rrrrrlrr'r)r7rr'r)r7rr'r&r*)r7r)rrr'r)rKrhrfrir'r) rKrhrfrirgr&rlrr'r&) rKrhrfrirgr&rkrrlrr'r) rwrrfrirlrrrhr'r) rKrhrfrirgr&rlrr'r)rfrirgr&)rrrfr r'rh) r*rrlrrfrir+rr7rr'r,)rfrirgr&r+r)rKrhrfrirgr&r+r) rKrhrfrirgr&r+rrlrr'r) rKrhrfrirgr&rlrr'rH) rwrhrfrirlrrgr&r'ri) r*rrlrrfrir7rmr'rn)r) rwrqrfrirlrrrrrkrr'rq)rrrrlrrkrr'r&) rrhrrhrrrrr'r)rrr'r) rrhrrhrrr+rr'r)rKr rgr&r'r )] __future__rrXrItypingrrrrnumpyrpandas._configr pandas._libsrr r r pandas._typingr r rrrrrrrpandas.compat._optionalrpandas.util._exceptionsrpandas.core.dtypes.commonrrrrrrrrpandas.core.dtypes.missingrr r!r{r+r,r.r1r`rrrtrrrrrrrrqrrrrrrrrr7rr/r6r4r>rDnanminnanmaxrMrQr^rfrrKrrrwrWrrrrrr~r/r-rs"""""" %%%%%%                      ?>>>>>444444                       V<<<$::677888>55555555p(    GK,))))^!%)- DDDDDN    2222 &&&&&RDEEEE>J )- ::::::@ )- ::::::z $ )- ******Z& )- <<<<<<~04TPT_%_%_%_%_%_%D8bhrz** /////d  *-*-*-*-*-*-Z $  FFFFFFR $ )- 1)1)1)1)1)1)h. E& 1 1 1 E& 1 1 1  )- ++++++b )- ++++++\ $ )- SSSSSSl $ )- \\\\\\~ $ )- ((((((V>$,28BJ#7#7 &+&+&+&+&+\ -----`>AAA $ !*" >@ $ # ))))))6! ! ! H""""""r/