uj ddlmZddlZddlZddlmZmZmZmZddl Z ddl Z ddl m ZddlmZmZmZmZddlmcmZddlmZddlmZddlmZmZmZm Z m!Z!m"Z"m#Z#m$Z$dd l%m&Z&m'Z'm(Z(erdd l)m*Z*dd l+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4ed d Z5e5duZ6da7dYdZdZ8e8eddGddZ9GddZ:d[dZ;d\dZ< d] d^dZ= d_dZ> d` dadZ?dbdZ@dcdZAd]dddZBded ZCdfd!ZDded"ZEdgd#ZFdhd$ZGdid%ZHdjd&ZIded'ZJdkd(ZKdddd) dld*ZLdddd) dld+ZMe9d,eCeEddddd- dmd.ZN dnd/ZO dod0ZPeJe:eCdddd) dpd1ZQeJe:dddd) dqd2ZR drd3ZSe je jf dsd4ZVeJe:d56ddd5dd7 dtd8ZWeJe9d,d9e:d56ddd5dd7 dud:ZXeJe9d,d9ddd5dd7 dvd;ZY dwd<ZZdxd=Z[ dyd>Z\dd? dzd@Z]dAZ^e^dBdCDZ_e^dEdFDZ`dddd) d{dGZadddd) d{dHZbeJe9d,d9eEdddd) d|dIZceJe9d,d9eEdddd) d|dJZde9d,d9eEddddd- d}dKZe d~dLZf ddMZge je jf ddNZh d ddOZi ddPZje9d,d9dQddR ddSZk ddTZlddUZme9d,d9dd5dV ddWZnddXZoy)) annotationsN) TYPE_CHECKINGAnyLiteralcast)_global_config)NaTNaTTypeiNaTlib)OutOfBoundsTimedelta)import_optional_dependency)ensure_float64is_floatis_float_dtype is_integeris_numeric_dtypeis_object_dtypeneeds_i8_conversion pandas_dtype)isnana_value_for_dtypenotna)Callable) ArrayLikeAxisIntCorrelationMethodDtypeDtypeObjFScalarShapenpt bottleneckwarn)errorsFTctr|ayyN)_BOTTLENECK_INSTALLED_USE_BOTTLENECK)vs ]/var/www/html/python-recuperauto-other/env/lib/python3.12/site-packages/pandas/core/nanops.pyset_use_bottleneckr-?scomputeuse_bottleneckc0eZdZdfd ZddZddZxZS)disallowcPt|td|D|_y)Nc3FK|]}t|jywr()rtype).0dtypes r, z$disallow.__init__..LsIL/44Is!)super__init__tupledtypes)selfr< __class__s r,r:zdisallow.__init__Js  I&II r.crt|dxr*t|jj|jS)Nr7)hasattr issubclassr7r5r<)r=objs r,checkzdisallow.checkNs'sG$PCIINNDKK)PPr.cZtjfd}td|S)Nc4tj||j}tfd|Dr+jj dd}t d|d |i|S#t$r }t|dr t ||d}~wwxYw)Nc3@K|]}j|ywr()rC)r6rBr=s r,r8z0disallow.__call__.._f..Us7s4::c?7snanzreduction operation 'z' not allowed for this dtyper) itertoolschainvaluesany__name__replace TypeError ValueErrorr)argskwargsobj_iterf_nameefr=s r,_fzdisallow.__call__.._fRs tV]]_=H7h77++E26+F83OP $)&))  #47+#A,A- s&A.. B7BBr  functoolswrapsr)r=rVrWs`` r,__call__zdisallow.__call__Qs,     $C}r.)r<rreturnNoner\bool)rVr r\r )rM __module__ __qualname__r:rCr[ __classcell__)r>s@r,r2r2IsJQr.r2ceZdZdddZddZy)bottleneck_switchNc  ||_||_yr()namerR)r=rfrRs r,r:zbottleneck_switch.__init__is  r.cjxs j ttt jddd dfd}td|S#tt f$rdYIwxYw)NTaxisskipnact jdkDr, jjD]\}}||vs |||<tr}|r{|jdkDrlt |j rV|jdd6|jdd|fd|i|}t|r|f||d|}|S|f||d|}|S|f||d|}|S)Nrmaskrirh) lenrRitemsr*size _bn_ok_dtyper7getpop _has_infs) rKrirjkwdskr+resultaltbn_funcbn_namer=s r,rVz%bottleneck_switch.__call__..fus4;;!# KK--/$DAq}"#Q$ KK!O w788FD)1HHVT*$V?$?$?F!(!$V!N$v!N!N M !Jd6JTJFMVF$vFFMr.r )rK np.ndarrayriAxisInt | Nonerjr_) rfrMgetattrbnAttributeError NameErrorrYrZr)r=rwrVrxrys`` @@r,r[zbottleneck_switch.__call__ms))+s|| b'*G  $( # # !#  #  # JC|S * G sA&&A:9A:r()r\r])rwr r\r )rMr`rar:r[r.r,rdrdhs .r.rdc4|tk7rt|s|dvSy)N)nansumnanprodnanmeanF)objectr)r7rfs r,rprps" 259;;; r.c t|tjr2|jdvr$t j |j dS tj|jS#ttf$rYywxYw)N)f8f4KF) isinstancenpndarrayr7r has_infsravelisinfrLrONotImplementedError)rvs r,rsrssk&"**% <<< '<< S 12 2xx##%% * +s"A11BBc||St|r8|tjS|dk(rtjStj S|jdk(r=|dk(r#tj t jStj dS|dk(r#tjt jStjtS)z9return the correct fill value for the dtype of the values+infur) _na_ok_dtyperrGinfkinduint64r u8maxint64i8maxr )r7 fill_valuefill_value_typs r,_get_fill_valuersE  !66M v %66MFF7N s  V #99SYY' 'yy| 6 ! xx ""xx~r.c|>|jjdvry|s|jjdvr t|}|S)a/ Compute a mask if and only if necessary. An explicit `mask` is returned unchanged; the values it marks need not be NaN (a masked array stores fill values there). Otherwise one is computed with isna(), but only where it is needed: never for boolean or integer values, which cannot store NaN, and under skipna=False only for datetime64/timedelta64, whose NaT stops being detectable once `_get_values` views it as i8 (GH#37392). A caller that already holds that i8 view must pass its own mask. 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)r7rr)rKrjrls r,_maybe_get_maskrs@8 | <<   % 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)r7rrrndimshaperfull)rKrir result_shapes r,_na_for_min_countrs"||G#y)#FLL1J {{a ||ET*V\\$(*-EE ww|Zv||DDr.c^tjdddfd}td|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. Nrc |dk(r|jdk(r|jdr|jddz |jdkDr|jtt fvrt |}|jdB|jd}tt|Dcgc]}||fd||i|}}n|Dcgc] }|fi| }}tj|S|fd|i|Scc}wcc}w)Nr C_CONTIGUOUSirrlri) rflagsrr7rr_listrqrrrangermrarray) rKrirRarrsrliresultsxrs r,newfuncz&maybe_operate_rowwise..newfuncs AI q  ^,a4'6<<?: VTN2?Da9tAw9&97;;4,V,;;88G$ $F0000B11, W r.c "|jjdvrtd|jd|jtk7r|St j |\}}|td|d|rt j|jDcgc],}t|t jt jf.c}}|j}d||j|j< tj 5tj"dt j$j&|j)t j*cdddScc}w#1swYnxYwn.#tt,t j$j&f$rYnwxYwt/|}|}|j1r|j}t j2||< tj 5tj"dt j$j&|j)t j*cdddS#1swYnxYwn.#tt,t j$j&f$rYnwxYw|j1r%||Dcgc] }t5|ncc}wc}||< |j)t j6S#tt,f$r}tdt9|d|d}~wwxYw)a  Convert an object-dtype ndarray to the numeric dtype it represents. Object-dtype input is normalized once, up front, so that every statistic below can treat it exactly as it treats the equivalent float64/complex128 array. Whatever a reduction does for ``np.float64`` input it now also does for an object array of floats, and any object array that does not hold numbers raises ``TypeError`` from here instead of from whichever ufunc happened to touch it first. Parameters ---------- values : np.ndarray Returns ------- np.ndarray `values` unchanged if it is not object-dtype, else the equivalent float64 or complex128 array. Raises ------ TypeError If the values are not numbers. SUTzCould not convert z values to numericNz to numericerror)r7rrOrr first_non_numericrrrrrrrreshaperwarningscatch_warnings simplefilter exceptionsComplexWarningrrrPrrLrG _to_complex complex128_first_unconvertible)rK non_numerichas_natvalnat_maskrlfillederrs r,_ensure_numericrs4||E!,V\\N:LMNN ||v 008K,[O;GHH 88IO X#ZbmmR^^< = X 15x -.   $ $ & -  ! !'2==+G+G H==,  - - Y  - - - z2==#?#? @    complex128 cast can handle `val` on its own. FT)rrOrPrs r,_complex_castablerfs,   z "s   cN|jD]}t|r|cS|S)zS Return the element responsible for a failed `_ensure_numeric` conversion. )rr)rKrs r,rrqs-||~ %J Mr.cXtjdfd }td|S)zO Normalize object-dtype values before the wrapped reduction sees them. c(t|fi|Sr()r)rKrRrs r,rz'_ensure_numeric_input..new_funcsOF+6v66r.r )rKrzrXrs` r,_ensure_numeric_inputr|s/ __T77 X r.cd|d|dS)z Message for the GH#34479 removal of any/all on datetime64 data. Shared so that the reduction, groupby and sparse paths cannot drift apart. 'zH' with datetime64 dtypes is not supported. Use (obj != pd.Timestamp(0)).z () instead.r)hows r,dt64_any_all_msgrs! C5((+uK 9r.rcH|jjdvr||j|S|jjdk(rtt dt ||d|\}}|jt k(r|jt}|j|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) np.True_ >>> from pandas.core import nanops >>> s = pd.Series([np.nan]) >>> nanops.nanany(s.values) np.False_ iubrrLFrrl) r7rrLrOrrrrr_rKrirjrl_s r,nananyr sD||E!dlzz$ ||C(/00FFu4HIFA||vt$ ::d r.cH|jjdvr||j|S|jjdk(rtt dt ||d|\}}|jt k(r|jt}|j|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) np.True_ >>> from pandas.core import nanops >>> s = pd.Series([1, 0]) >>> nanops.nanall(s.values) np.False_ rrallTr ) r7rrrOrrrrr_r s r,nanallrsD||E!dlzz$ ||C(/00FFt$GIFA||vt$ ::d r.M8)rirj min_countrlc|j}|tk(rV|sT| t|}|jrI |j |t |}t ||||j|St||d|\}}t |}|jdk(r9|tj k(r#tjtj"n|}n9|jdk(r*t%|||||}t ||||j|d S|j ||}t ||||j|}|S#t$rYnwxYw|jdk(s| t||St|||d}t|||}) 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) np.float64(3.0) rrrrr rVrTrr)r7rrrLsumr_maybe_null_outrrOrr_blank_object_na_slices _na_min_countrrrfloat16r_sum_timedelta_i8)rKrirjrrlr7the_sum dtype_sums r,rrstD LLE v <IsD99 EEc tj}|s||j|}|dkDrY|=|jdkDr.|j||dn|j |z }|||kz}n|t |j||z}|s)|'|jrtj|d|}|jdk(r!|j |tjSd}||j}n|}|j|}ttt|jtt|j} | rtj | zn|} | |k\r!|j |tjStj"d|| } tj$j'|| |} | j |t(} | t*k| tj kDz}tj||zr t-dt/| tj0r4tj|d| j3tjStj|rdS| S)a Sum i8-viewed timedelta64 values exactly, raising on a result that does not fit in int64. int64 addition is modular, so an intermediate that leaves the range does not corrupt the total; only the total itself has to be checked. Values are summed in blocks short enough that each block sum provably stays in range, and the block sums are then combined in Python ints. Parameters ---------- values : ndarray[int64] axis : int, optional mask : ndarray[bool], optional skipna : bool min_count : int Returns ------- int64 scalar or ndarray[int64] Raises ------ OutOfBoundsTimedelta If the exact sum is not representable as a timedelta64, i.e. it lands outside (iNaT, i8max]. rrrrr)rFalse_rLrrrcheck_below_min_countrrorrmaxrintminr rarangeaddreduceatrr r rrr)rKrirlrjrexemptcounts reduce_axislengthlargestblockstarts block_sumstotal out_of_ranges r,rrQs J%'IIF d&t$1}   a\\$' 1$((4.QFv 12F3FLL$ RRF d&488:$6* {{azz$bhhz//K | \\+ &F#c&**,'(#c&**,.?*@AG$+CII E zz+RXXz66 YYq&% (FkBJ NN;fN 5ETMecii&78L vvlfW$%"#DEE%$xx a/66rxx@@ 88A 115 11r.cLt|tjrG|jdj |j }|j |}t||<|S|j r2tjtj |j S|S)Nrr) rrrrrr7rLr r)rvrirlr axis_masks r,rrs &"**%t$))+*;*;<HH$H'  y M xx~"";#4#455 Mr.c|jdk(rtdt||S|j}t ||d|\}}t |}t jt j}|jdvr$t jt j}n{|jdvr$t jt j}nI|jdk(r:|t jk(r#t jt jn|}|}t|j|||}|j||}|gt|d d rZtd |}t jd 5||z } ddd|dk(} | jrt j  | < S|dkDr||z nt j } | S#1swYOxYw)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) np.float64(1.5) rfloatr riurVrNrFrzignore)r)rorrr7rrrrrr _get_countsrrr|errstaterLrG) rKrirjrlr7r dtype_countcountrthe_meanct_masks r,rrsD{{aG.vt<== LLEvv!$GLFDu%I((2::&K zzTHHRZZ( t HHRZZ( s ,1RZZ,?BHHRZZ(U   dD DEjjYj/G GGVU;\5) [[X & 'H '1* ;;= "HW  O',ai7U?RVV O ' 's <GGc|jjdk(xr|du}ddfd }|j}t||d\}}|jjdvr|jd}|s;|9|jj s|j }tj||<|j}|jdkDr||r։stj|||}ntj5tjdd t|j ddk(r|d k(s|j d dk(rC|dk(r>tj"tj$tj&|d }ntj"|| }dddn2t)|j |}n|r |||ntj}t+|S#1swYxYw)aI Parameters ---------- values : ndarray axis : int, optional skipna : bool, default True mask : ndarray[bool], optional nan-mask if known Returns ------- result : float | ndarray Unless input is a float or complex 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 >>> s = pd.Series([np.nan, np.nan, np.nan]) >>> nanops.nanmedian(s.values) nan rVNc| t|}n|}s9|js)|jjtj St j5t jddtt jddtt j||}ddd|S#1swYSxYw)Nr5All-NaN slice encounteredzMean of empty slice) rrr7r5rrGrrfilterwarningsRuntimeWarning nanmedian)r_maskresrjs r, get_medianznanmedian..get_medians =!HEFEeiik77<<' '  $ $ & )  # #5~   # #H.C^ T,,qx(C  )  ) s "AB;;C)rlrfcrrr5r>rT)keepdimsrr()rrz)r7rrrr writeablerrrGrorapply_along_axisrrr?r@rrA atleast_1dsqueeze_get_empty_reduction_resultr) rKrirjrlusing_nan_sentinelrDr7notemptyrCs ` r,rArAsD **c1Bddl& LLEvvDTJLFD ||$t$ $"2||%%[[]Fvvt {{H {{Q4+ ))*dFC,,.>++ "=~ Q1, Q1,!llMM"**V*<=!ll6=>>*.fllDAC+3j& e $$5>>s 9BGG(ctj|}tjt|}tj|||k7tj }|j tj|S)z The result from a reduction on an empty ndarray. Parameters ---------- shape : Tuple[int, ...] axis : int Returns ------- np.ndarray r)rrr#rmemptyrfillrG)rrishpdimsrets r,rKrKgsU ((5/C 99SZ D ((3tt|$BJJ 7CHHRVV Jr.ct||||}||j|z }t|r*||kr!|jtjx}}||fSt d|}||k}|j rJtj||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 : np.floating or np.ndarray d : np.floating or np.ndarray rrz)r6r5rrrGrrLr) values_shaperlriddofr7r9ds r,_get_counts_nanvarrX~s:  dD >E  4  A D= 266* *EA !8O \5)} 88: JJq$ ' JJudBFF + !8Or.rrVrirjrVrlc |jjdk(r7tj|jd}|j d|d}|j dk(rt dt||S|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 NA-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 rrzm8[]r3)rlrZ) r7rrrrrorrrsqrtnanvarr)rKrirjrVrlr orig_dtypervs r,nanstdr`sJ||C -a0s4&]+ {{aG.vt<==JvvD9LFD WWVFf4dS TF  ,,r.m8c|jdk(rtdt||S|j}t |||}|j dvr|j d}nD|j dk(r5t|j||||t|j||||zS|jj dk(r't|j||||j\}}nt|j|||\}}|9|j}tj|||rdntj|j!|tj"|z }|tj$||}||z d z} |tj| |dtd | j!|tj"|z } |j dk(r| j |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 NA-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 rr3rrcrZrV)rir7rznp.ndarray | np.float64Fr)rorrr7rrrr^realimagrXrrrrrGrr expand_dims) rKrirjrVrlr7r9rWavgsqrrvs r,r^r^sL{{aG.vt<== LLE 664 0D zzUt$ s  KKd64 6;;T&t$ OP P||C%fllD$fllSq%fllD$Eq  64f"&&9 **$bjj* 1E 9C nnS$' >> from pandas.core import nanops >>> s = pd.Series([1, np.nan, 2, 3]) >>> nanops.nansem(s.values) np.float64(0.5773502691896258) rZrErrV) r^rr7rrrrrXrr]) rKrirjrVrlr8r9r vars r,nansemrk=sN 6V$TB 664 0D ||$t$((2::&K ||Cll !&,,dD+NHE1 d64 HC 773<"''%. ((r.c|tj|j||}tj|||S)a2 Replace every reduction slice of an object-dtype array that holds an NA with ``fill_value``. For ``skipna=False`` those slices are nulled out afterwards, so their values never reach the result and need not even support the operation being applied (GH#4147). A float NaN propagates through arithmetic and comparison on its own; an object NA does not, and raises instead. Only for reductions over an axis of a 2-D array. When the reduction covers the whole array the result is simply NA, and callers short-circuit instead. r)rrfrLr)rKrlrirany_nas r,rrts2$^^DHH$H/ 6F 88FJ //r.c4t||j|S)z ``min_count`` that nulls out any slice holding an NA, without weakening an explicit larger ``min_count`` from the caller (GH#4147). )r r)rKrirs r,rrs y&,,t, --r.c2|jr&tj|j|tS|j dk(s|>tj dt}||d|d<tj|||Stj|j||}tj|||}tj|j||}tj|||}tj|||S)a! Replace NA entries in an object-dtype array with a valid value taken from the same reduction slice. GH#65500: the +/-inf fill used for other dtypes is not comparable with arbitrary objects (Timestamps, strings, tuples) and raises. Substituting a value already present in the slice cannot change a min/max, and for argmin/argmax a result landing on a filled position is corrected by ``_maybe_fix_arg_at_na``. Entirely-NA slices get ``fill_value``, since their result is discarded by the caller either way. rrrr) rrrrrrrOrrfargmaxtake_along_axis)rKrlrirrPindexerall_nas r,_fill_object_narts" xxzwwv||Zv>> {{a4<xx($-"QxxdF++nnte^^^6=G  fgD 9D^^DHH$H/ 6F 88FJ -D 88D$ ''r.rc |jtk(rc| t|}|s|jr t d|jr%t |j|}t ||||}||fSt|d||S)a Prepare values for nanargmin/nanargmax by filling NA entries so that the comparison does not see them, and raise for ``skipna=False``. Mirrors ``_get_values(values, True, ...)`` except for object dtype, where the +/-inf fill is not comparable with arbitrary objects (GH#4147). The object fill is a same-slice value, which *can* win the comparison; a result landing on it is corrected by ``_maybe_fix_arg_at_na``. )Encountered an NA value with skipna=FalserTrrl)r7rrrLrPrrtr)rKrrlrjrirs r,_get_arg_valuesrys{"||v <.reductions ;;! $VT2 2  F?|F|xxz,U>R ,VT4LF[[A%-VT::4VT4TF -fdI FI&~DLFD'&t,    LLt+   r.r)rdr)r|rr}s`` r, _nanminmaxr~sbc$L) $-1 *** * + ***X r.r"rrwr -infct|d|||\}}|j|}t|||}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) np.int64(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]) rrrlrjri)ryrp_maybe_fix_arg_at_na_maybe_arg_null_outrKrirjrlrvs r, nanargmaxr SL#vDdLFD]]4 F"&$ 5F tV >> from pandas.core import nanops >>> arr = np.array([1, 2, 3, np.nan, 4]) >>> nanops.nanargmin(arr) np.int64(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]) rr)ryargminrrrs r, nanargminr;rr.c|j}t|}||jdk(rn|dk(ri|jjrdnd}t j |j||||j|nd}tj|}n(|dvrt j||||}n td|jdk(r|j|d }|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]) >>> round(nanops.nanskew(s.values), 6) np.float64(1.732051) Nrrr Crraxis must be 0, 1 or NonerVFr)r7rrr f_contiguouslibalgos scalar_skewrrr axis_skewrPrrrKrirjrlr7order result_floatrvs r,nanskewrlL LLE F #F | q(TQY*0,,*C*C3++ LL d>NE):TX L) ##FD&$?455 zzSu51 Mr.c|j}t|}||jdk(rn|dk(ri|jjrdnd}t j |j||||j|nd}tj|}n(|dvrt j||||}n td|jdk(r|j|d }|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]) >>> round(nanops.nankurt(s.values), 6) np.float64(-1.289256) Nrrr rrrrVFr)r7rrrrr scalar_kurtrrr axis_kurtrPrrrs r,nankurtrrr.ct|||}|jtk(rK|sI| t|}|j rE |j |}t ||||j|S|r||j}d||<|j |}t ||||j|S#t$rYnwxYw|jdk(s| t||St|||d}t|||}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) np.float64(6.0) rr)rr7rrrLprodrrrOrrrrr)rKrirjrrlrvs r,rrs@ 664 0D ||vf <IsB00 B<;B<c||js|S||jdk(rD|j|r/|js|jj S|St j ||}t j|||j|}|jr't j||j ||}|S)Nr) rLrrrrprrfrqrJr)rvrlrirr arg_is_nas r,rr"s |488:  |tyyA~ ::<  E==?))+ + M ...&&tWd;CCDI ==?XXi4%)=vFF Mr.cT||S| t|dds<|r|jr td|s|jr td|S|r*|j|jr td|s*|j|jr td|S)NrFzEncountered all NA valuesrv)r|rrPrL)rvrirlrjs r,rr;s |  |76659 dhhj89 9DHHJHI I M DHHTN&&(455 **,DEE Mr.cB|F||j|jz }ntj|}|j |S|"|j ||j|z }n||}t |r|j |S|j|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 Fr)rorrrr5rrr)rUrlrir7nr9s r,r6r6Qs0 |   DHHJ&A %Azz!}  4 488D>1T"%zz%  <<E< **r.c|dkr|S|t|tjr|(|j||j |z |z dk}n/|||z dk}|d|||dzdz}tj ||}tj |rw|r t||<|St|rZtj|r|jd}nt|s|jdd}tj||<|Sd||<|S|turHt|||r;t|dd} t| r| j!d }|Stj}|S) zu Returns ------- Dtype The product of all elements on a given axis. ( NaNs are treated as 1) rNrc16rFrr7rG)rrrrr broadcast_torLr r iscomplexobjrrrGr rr|r5) rvrirlrrr null_mask below_count new_shape result_dtypes r,rrzsgA~  Jvrzz:  D)DHHTN:YF!KI + 1A5Ket uTAXZ'88I Y?I 66) $(y!& M%"&)??6*#]]51F'/#]]4e].funcsa#A& &r.spearman) spearmanrc||dSrr)rrrs r,rzget_corr_func..funcsQ?1% %r.rct||Sr() _pearson_corr)rrs r,rzget_corr_func..funcs A& &r.zUnknown method 'z@', expected one of 'kendall', 'spearman', 'pearson', or callable) scipy.statsrrcallablerP)rrrrs @@r,rrsr* ' : ) & 9  ' &   6(#8 8 r.cD|jdk7s9|jdk7s*tj|stj|rtj||dSt |dkrtj S|j tjd}|j tjd}||jz }||jz }tjtj|}tjtj|}|dk(s|dk(rtj S||z }||z }t |dz }tjtj|||z }|dk(rtj Stj|||z |z }tjtj|||z }|dk(rtj Stj||z ddS) NrrrrFrrg?)rrrcorrcoefrmrGrrmeanr rr]dotclip)rra_scaleb_scalefactdivisorrvs r,rr svv{affkR__Q%72??1;M{{1a && 1vzvv  %(A %(A AFFH A AFFH AffRVVAYGffRVVAYG!|w!|vv  G A G A q6A:DggbffQlT)*G!|vv VVAq\D 7 *FggbffQlT)*G!|vv 776G#T3 //r.)rrVcNt|t|k7r td|d}t|t|z}|js ||}||}t||krtj St |}t |}t j|||dS)Nz&Operands to nancov must have same sizerrYr)rmrrrrrGrcov)rrrrVrs r,nancovr0s 1vQEFF !HuQx E 99; eH eH 1v vv AA 66!QT "4 ((r.c tjdtjftjjtj tjftj dtjftjjtj tjfi|\}}|jjdvsJ|rot|jjtjtjfs1|j}t|}|||<||d}|||<|S||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 rgrrr)rcumprodrGmaximum accumulatercumsumminimumr7rrAr5rbool_rr)rK accum_funcrjmask_amask_bvalsrlrvs r, na_accum_funcrLs S"&&M 0 C= /   NFF <<  D (( (j!2!2RZZ4JK{{}DzT Dq)t  MF+ Mr.)T)r+r_r\r])r7rrfstrr\r_r^)NN)r7rrz Scalar | None)rKrzrjr_rlrr\r)NNN) rKrzrjr_rrrz str | Nonerlrr\/tuple[np.ndarray, npt.NDArray[np.bool_] | None])r7np.dtyper\r)r7rr\r_)r7r)rr r\r )rKrzrir{r\zScalar | np.ndarray)rKrzr\rz)rrr\r)rrr\r_)rKrzr\r)rrr\r) rKrzrir{rjr_rlrr\r_) rKrzrir{rjr_rr!rlrr\'np.ndarray | np.int64 | float | NaTType) rKrzrir{rlrrjr_rr!r\znp.ndarray | np.int64) rvz+np.ndarray | np.datetime64 | np.timedelta64rir{rlnpt.NDArray[np.bool_]rrzr\z5np.ndarray | np.datetime64 | np.timedelta64 | NaTType) rKrzrir{rjr_rlrr\r3)rKrzrir{rjr_r\zfloat | np.ndarray)rr"rirr\rz) rUr"rlrrir{rVr!r7rr\z-tuple[float | np.ndarray, float | np.ndarray])rir{rjr_rVr!)rKrzrir{rjr_rVr!) rKrzrir{rjr_rVr!rlrr\r3) rKrzrlrrirrrr\rz)rKrzrirrr!r\r!) rKrzrlrrir{rrr\rz) rKrzrrrlrrjr_rir{r\r) rKrzrir{rjr_rlrr\zint | np.ndarray) rKrzrir{rjr_rlrr\znp.ndarray | float) rKrzrir{rjr_rr!rlrr\r3)rvrzrlrrir{r\rz) rvrzrir{rlrrjr_r\znp.ndarray | int) rUr"rlrrir{r7znp.dtype[np.floating]r\z&np.floating | npt.NDArray[np.floating])rF)rvrrir{rlrrtuple[int, ...]rr!rr_r\r)rrrlrrr!r\r_) rrzrrzrrr int | Noner\r3)rrr\z)Callable[[np.ndarray, np.ndarray], float])rrzrrzr\r3) rrzrrzrrrVrr\r3)rKrrjr_r\r)p __future__rrYrItypingrrrrrnumpyrpandas._config.configrconfig pandas._libsr r r r pandas._libs.algos_libsalgosrpandas._libs.tslibsr pandas.compat._optionalrpandas.core.dtypes.commonrrrrrrrrpandas.core.dtypes.missingrrrcollections.abcrpandas._typingrrrrrr r!r"r#r}r)r*r-r2rdrprsrrrrrrrrrrrrrrrr rrrrrrArKr7rrXr`r^rkrrrtryr~nanminnanmaxrrrrrrrr6rrrrrrrrr.r,rs " : &%4>    (    V<$6)$%567>33l( GK !.@$ $ $$,H$!$T!%)- D D DD D ' D 5 DN 2 0f0fE>BTn'   )- 5 5 5  5 ' 5  5v )- 5 5 5  5 ' 5  5p $ )- G G G  G  G ' G-GGTQ2 Q2 Q2 'Q2  Q2  Q2  Q2h  7       ;   )- @ @ @  @ ' @  @@F26tRVg% g%!/g%@Dg%g%g%T  8bhhrzz* -- &- -  -  - 3 -`  /- /-  /-  /-/-d $  U U U  U  UUp $ )- 2) 2) 2)  2)  2) ' 2) 2)2)j0 0 0 0 0  0,.( ( ( ( (  (P O OO ' O  O  O5O@/d E& 1 E& 1  )- . . .  . ' .  .h )- . . .  . ' .  .b $ )- 5 5 5  5 ' 5  55p $ )- 5 5 5  5 ' 5  55p $ )- ; ; ;  ;  ; ' ; ;;|  &  2   '    4$,288BJJ#7 &+&+ &&+ &+ ! &+ , &+\ 1 31 1 '1  1  1  1-1h ">KN > $ !*"       > .@ 0F $ # ))) )  )  ))6"r.