Ë
|
nñúh(Ç ã óÊ d dl mZ d dlZd dlZd dlmZmZmZ d dlZd dl Z
|
d dl m Z d dl mZmZmZmZ d dlmZmZmZmZmZmZmZmZmZ d dl m Z d dl m Z d d l m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z( d d
|
l)m*Z*m+Z+m,Z, e d d ¬ « Z-e-duZ.da/dKdLdZ0 e0 e d« « G d d« Z1 G d d« Z2dMdZ3dNdZ4 dO dPdZ5 dQdZ6 dR dSdZ7dTdZ8dUd Z9dVdWd Z:dXd Z;dYd Z<dXd Z=dddd! dZd"Z>dddd! dZd#Z? e1d$« e;e=ddd dd% d[d&« « « Z@ d\d'ZA e2« e;dddd! d]d(« « ZB e2« dddd!d^d)« ZC d_d*ZD e
|
j e
|
j « f d`d+ZG e2d,¬-« ddd,dd. dad/« ZH e1d$d0« e2d,¬-« ddd,dd. dbd1« « ZI e1d$d0« ddd,dd. dcd2« ZJd3 ZK eKd4d5¬6« ZL eKd7d8¬6« ZMdddd! ddd9ZNdddd! ddd:ZO e1d$d0« e=dddd! d]d;« « ZP e1d$d0« e=dddd! d]d<« « ZQ e1d$d0« e=ddd dd% d[d=« « ZR ded>ZS e
|
j e
|
j « f dfd?ZT dg dhd@ZU didAZVdB ZW e1d$d0« dCddD djdE« ZX dkdFZY e1d$d0« dd,dG dldH« ZZdI Z[dmdJZ\y)né )Ú annotationsN)ÚAnyÚCallableÚcast)Ú
|
get_option)ÚNaTÚNaTTypeÚiNaTÚlib) Ú ArrayLikeÚAxisIntÚCorrelationMethodÚDtypeÚDtypeObjÚFÚScalarÚShapeÚnpt)Úimport_optional_dependency)Úfind_stack_level)Ú
|
is_complexÚis_floatÚis_float_dtypeÚ
|
is_integerÚis_numeric_dtypeÚis_object_dtypeÚneeds_i8_conversionÚ pandas_dtype)ÚisnaÚna_value_for_dtypeÚnotnaÚ
|
bottleneckÚwarn)ÚerrorsFTc ó t r| ay y ©N)Ú_BOTTLENECK_INSTALLEDÚ_USE_BOTTLENECK)Úvs úEH:\Change_password\venv_build\Lib\site-packages\pandas/core/nanops.pyÚset_use_bottleneckr+ 9 s õ Øð ó zcompute.use_bottleneckc ó0 e Zd Zd fd ZddZddZ xZS )Údisallowc óP t | « t d |D « « | _ y )Nc 3 óF K | ] }t |« j y wr& )r Útype)Ú.0Údtypes r* ú <genexpr>z$disallow.__init__.<locals>.<genexpr>F s è ø ÒI¸L¨Ó /× 4Õ 4ÑIùs !)ÚsuperÚ__init__ÚtupleÚdtypes)Úselfr8 Ú __class__s r* r6 zdisallow.__init__D s ø Ü ÑÔÜÑIÀ&ÔIÓI r, c ór t |d« xr* t |j j | j « S )Nr3 )ÚhasattrÚ
|
issubclassr3 r1 r8 )r9 Úobjs r* Úcheckzdisallow.checkH s' ÜsGÓ$ÒP¬°C·I±I·N±NÀDÇKÁKÓ)PÐPr, c ób t j « fd« }t t |« S )Nc ó4 t j | |j « « }t fd|D « « r+j j dd« }t d| d« | i |¤S # t $ r }t | d « r t |« | d }~ww xY w)Nc 3 ó@ K | ] }j |« y wr& )r? )r2 r> r9 s r* r4 z0disallow.__call__.<locals>._f.<locals>.<genexpr>O s øè ø Ò7 s4::c?Ñ7ùs ÚnanÚ zreduction operation 'z ' not allowed for this dtyper ) Ú itertoolsÚchainÚvaluesÚanyÚ__name__ÚreplaceÚ TypeErrorÚ
|
ValueErrorr )ÚargsÚkwargsÚobj_iterÚf_nameÚeÚfr9 s r* Ú_fz disallow.__call__.<locals>._fL s ø ä t¨V¯]©]«_Ó=HÜÓ7¨hÔ7Ô7Ø×+Ñ+¨E°2Ó6Ü Ø+¨F¨8Ð3OÐPóð ð Ù$Ð) &Ñ)Ð)øÜ ò ô
|
# 4¨¡7Ô+Ü# A,¨AÐ-Øûð ús Á&A. Á. BÁ7BÂB©Ú functoolsÚwrapsr r )r9 rR rS s `` r* Ú__call__zdisallow.__call__K s, ù Ü Ó ô ó
|
ð ô$ Ar{Ðr, )r8 r ÚreturnÚNone©rX Úbool)rR r rX r )rI Ú
|
__module__Ú __qualname__r6 r? rW Ú __classcell__)r: s @r* r. r. C s ø õJóQ÷r, r. c ó e Zd ZdddZddZy)Úbottleneck_switchNc ó || _ || _ y r& )ÚnamerN )r9 rb rN s r* r6 zbottleneck_switch.__init__c s Ø Ø r, c ó j xs j t t « t j « d dd d fd« }t t |« S # t t
|
f$ r d Y Mw xY w)NT©ÚaxisÚskipnac óè t
|
j « dkD r,
|
j j « D ] \ }}||vs |||< | j dk( r |j d« t | |« S t rn|rlt | j « rV|j dd « 6|j dd « | fd|i|¤}t |« r | f||d|¤}|S | f||d|¤}|S | f||d|¤}|S )Nr Ú min_countÚmaskre rd ) ÚlenrN ÚitemsÚsizeÚgetÚ_na_for_min_countr( Ú _bn_ok_dtyper3 ÚpopÚ _has_infs) rG re rf ÚkwdsÚkr) ÚresultÚaltÚbn_funcÚbn_namer9 s r* rR z%bottleneck_switch.__call__.<locals>.fo s ø ô 4;;Ó !Ò#Ø KK× -Ñ -Ó /ò $DAqØ }Ø"#Qð$ð {{aÒ D§H¡H¨[Ó$9Ð$Aô )¨°Ó6Ð6å ¡6¬l¸6¿<¹<ÈÔ.QØ88F DÓ)Ð1ð HHV TÔ*Ù $ VÑ ?°$Ð ?¸$Ñ ?Fô ! Ô(Ù!$ VÐ!N°$¸vÑ!NÈÑ!Nð Mñ ! Ð J¨d¸6Ñ JÀTÑ JFð Mñ VÐF¨$°vÑFÀÑFàMr, )rG ú
|
np.ndarrayre úAxisInt | Nonerf r[ )
|
rb rI ÚgetattrÚbnÚAttributeErrorÚ NameErrorrU rV r r )r9 ru rR rv rw s `` @@r* rW zbottleneck_switch.__call__g s û Ø))Ò+s||ð Ü b 'Ó*Gô
|
Ó ð $(Ø ñ % Ø ð% ð !ð% ð ÷ % ó
|
ð% ôN AqzÐøôW ¤ Ð*ò ØGð ús A* Á*A>Á=A>r& )rX rY )ru r rX r )rI r\ r] r6 rW © r, r* r` r` b s ô ô0r, r` c ó4 | t k7 rt | « s|dvS y)N)ÚnansumÚnanprodÚnanmeanF)Úobjectr )r3 rb s r* ro ro s" à Ô 2°5Ô 9ð Ð;Ð;Ð;Ø r, c ó t | t j « r2| j dv r$t j
|
| j d« « S t j | « j « S # t t f$ r Y yw xY w)N)Úf8Úf4ÚKF) Ú
|
isinstanceÚnpÚndarrayr3 r Úhas_infsÚravelÚisinfrH rK ÚNotImplementedError)rt s r* rq rq ® sk Ü&"**Ô%Ø <<<Ñ 'ô << § ¡ ¨SÓ 1Ó2Ð 2ðÜxxÓ ×#Ñ#Ó%Ð%øÜ Ô*Ð +ò áðús Á"A1 Á1BÂBc óÆ ||S t | « r8|t j S |dk( rt j S t j S |dk( rt j
|
S t S )z9return the correct fill value for the dtype of the valuesú+inf)Ú _na_ok_dtyper rC Úinfr Úi8maxr
|
)r3 Ú
|
fill_valueÚfill_value_typs r* Ú_get_fill_valuer » sZ ð Ð ØÐÜEÔØ Ð !Ü66Mà Ò'Üvv äwà VÒ #ä99Ð äKr, c ó |>| j j dv ry|s| j j dv r t | « }|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ÚbiuÚmM)r3 Úkindr )rG rf ri s r* Ú_maybe_get_maskr Ñ sA ðB |Ø <<× Ñ Ñ %àá V\\×&Ñ&¨$Ñ.Ü<Dà Kr, c ó¤ t | ||« }| j }d}| j j dv r&t j | j d« « } d}|rr|pt |||¬« }|`|j « rP|s t |« r+| j « } t j | ||« | |fS t j | | |« } | |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
|
Fr Úi8T)r r ) r r3 r r ÚasarrayÚviewr rH r ÚcopyÚputmaskÚwhere)rG rf r r ri r3 Ú datetimelikes r* Ú _get_valuesr¤ ý sÎ ôR 6 6¨4Ó 0Dà LLEàLØ ||×ÑDÑ ô FKK¨Ó -Ó.Ø á 4Ð#ô %Ø j¸ ô
|
|
ð Ð !ØxxzÙ ¤<°Ô#6Ø #[[]FÜJJv t¨ZÔ8ð
|
4<Ðô XX t e¨V°ZÓ @Fà 4<Ðr, c ó< | }| j dv r%t j t j « }|S | j dk( r%t j t j « }|S | j dk( r#t j t j
|
« }|S )NÚbiÚurR )r r r3 Úint64Úuint64Úfloat64)r3 Ú dtype_maxs r* Ú_get_dtype_maxr¬ D s{ àIØ zzTÑÜHHRXXÓ& ð
|
Ðð
|
sÒ ÜHHRYYÓ' ð Ðð
|
sÒ ÜHHRZZÓ( Ø Ðr, c ód t | « ryt | j t j « S )NF)r r= r1 r Úinteger©r3 s r* r r P s% Ü5Ô!ØÜ%**¤b§j¡jÓ1Ð 1Ð1r, c ó | t u r | S |j dk( rÆ|t }t | t j
|
« st |« rJ d« | |k( rt j } t | « r&t j dd« j |« } n$t j | « j |« } | j |d¬« } | S | j |« } | S |j dk( rÓt | t j
|
« s| |k( st j | « r&t j d« j |« } | S t j | « t j kD r t# d« t j | « j |d¬« } | S | j d « j |« } | S )
|
zwrap our results if neededÚMz Expected non-null fill_valuer ÚnsF©r Úmz overflow in timedelta operationúm8[ns])r r r
|
r r r r rC Ú
|
datetime64Úastyper¨ r ÚisnanÚ timedelta64Úfabsr r rL )rt r3 r s r* Ú _wrap_resultsr» V s à }Ø ðF MðC
|
sÒ Ø Ð ä JÜ&¤"§*¡*Ô-ÜJÔ'Ð GÐ)GÓ GÐ'ØÒ#ÜäF|Ü u¨dÓ3×:Ñ:¸5ÓAä &Ó)×.Ñ.¨uÓ5à]] 5¨u]Ó5Fð& Mð! ]] 5Ó)Fð Mð
|
sÒ Ü&¤"§*¡*Ô-ØÒ#¤r§x¡x°Ô'7Ü ¨Ó.×5Ñ5°eÓ<ð Mô ¤3§9¡9Ò,ä Ð!BÓCÐCô &Ó)×0Ñ0°¸UÐ0ÓCð
|
Mð ]] 8Ó,×1Ñ1°%Ó8Fà Mr, c óx t j « dddd d fd« }t t |« S )z
|
If we have datetime64 or timedelta64 values, ensure we have a correct
|
mask before calling the wrapped function, then cast back afterwards.
|
NT©re rf ri c óØ | }| j j dv }|r | t | « } | f|||d|¤}|r0t ||j t ¬« }|s|J t ||||« }|S )Nr r½ )r )r3 r r r» r
|
Ú_mask_datetimelike_result) rG re rf ri rN Ú orig_valuesr£ rt Úfuncs r* Únew_funcz&_datetimelike_compat.<locals>.new_func
s ø ð à ||×(Ñ(¨DÐ0 Ù DLÜ<DáfÐL 4°¸TÑLÀVÑLá Ü" 6¨;×+<Ñ+<ÌÔNFÙØÐ'Ð'Ð'Ü2°6¸4ÀÀ{ÓSà r, ©rG rx re ry rf r[ ri ú npt.NDArray[np.bool_] | NonerT )rÁ r s ` r* Ú_datetimelike_compatrÅ s` ø ô __TÓð $ØØ-1ñ Øðð ðð ð ð
|
+ô ó ðô0 8Ó Ð r, c ó0 | j j dv r| j d« } t | j « }| j dk( r|S ||S | j
|
d| | j
|
|dz d z }t j ||| j ¬« S )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.
|
Úiufcbrª é Nr¯ )r3 r r· r ÚndimÚshaper Úfull)rG re r Ú result_shapes r* rn rn ¡ s ð" ||×ÑGÑ#Ø yÓ)Ü# F§L¡LÓ1Jà {{aÒØÐØ ØÐà || E TÐ*¨V¯\©\¸$À¹(¸*Ð-EÑE äww| Z°v·|±|ÔDÐDr, c óf t j « ddd fd« }t t |« 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.
|
N©re c ó |dk( rï| j dk( rà| j d rÑ| j d dz | j d kD r¯| j t k7 r| j t
|
k7 rt | « }|j d« B|j d« }t t |« « D cg c] } || fd|| i|¤ }}n|D cg c] } |fi |¤ }}t j |« S | fd|i|¤S c c}w c c}w )NrÈ é Ú C_CONTIGUOUSiè r ri re ) rÉ ÚflagsrÊ r3 r r[ Úlistrm rp Úrangerj r Úarray) rG re rN Úarrsri ÚiÚresultsÚxrÁ s r* Únewfuncz&maybe_operate_rowwise.<locals>.newfuncÇ s ø ð AIØ qÒ Ø ^Ò,ð a 4Ñ'¨6¯<©<¸©?Ò:Ø ¤Ò&Ø ¤Ò$ä<DØzz&Ó!Ð-Ø zz &Ó)äCHÌÈTËÓCSöØ>?DaÑ9 t¨A¡wÐ9°&Ó9ðñ ð 7;Ö;°4 Ñ, VÓ,Ð;Ð;Ü88GÓ$Ð $áFÑ0 Ð0¨Ñ0Ð0ùòùò <s Â0DÃD)rG rx re ry rT )rÁ rÚ s ` r* Úmaybe_operate_rowwiserÛ À s2 ø ô __TÓØ>Bö 1ó ð1ô. 7Ó Ðr, r½ c óh | j j dv r|| j |« S | j j dk( r$t j dt
|
t « ¬« t | |d|¬« \ } }| j t k( r| j t « } | 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)
|
True
|
|
>>> from pandas.core import nanops
|
>>> s = pd.Series([np.nan])
|
>>> nanops.nanany(s.values)
|
False
|
Úiubr± zz'any' with datetime64 dtypes is deprecated and will raise in a future version. Use (obj != pd.Timestamp(0)).any() instead.©Ú
|
stacklevelF©r ri ) r3 r rH Úwarningsr# Ú FutureWarningr r¤ r r· r[ ©rG re rf ri Ú_s r* Únananyrå â s ðD ||×ÑEÑ! d lð zz$Ó Ð à ||×ÑCÒ ä ð Jä Ü'Ó)õ
|
ô F F°uÀ4ÔHIFAð ||vÒ Ø tÓ$ð ::dÓ Ðr, c óh | j j dv r|| j |« S | j j dk( r$t j dt
|
t « ¬« t | |d|¬« \ } }| j t k( r| j t « } | 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)
|
True
|
|
>>> from pandas.core import nanops
|
>>> s = pd.Series([1, 0])
|
>>> nanops.nanall(s.values)
|
False
|
rÝ r± zz'all' with datetime64 dtypes is deprecated and will raise in a future version. Use (obj != pd.Timestamp(0)).all() instead.rÞ Trà ) r3 r Úallrá r# râ r r¤ r r· r[ rã s r* Únanallrè s ðD ||×ÑEÑ! d lð zz$Ó Ð à ||×ÑCÒ ä ð Jä Ü'Ó)õ
|
ô F F°tÀ$ÔGIFAð ||vÒ Ø tÓ$ð ::dÓ Ðr, ÚM8)re rf rh ri c ó: | j }t | |d|¬« \ } }t |« }|j dk( r|}n2|j dk( r#t j t j
|
« }| j ||¬« }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
|
r rà rR r´ r¯ ©rh ) r3 r¤ r¬ r r rª ÚsumÚ_maybe_null_outrÊ )rG re rf rh ri r3 Ú dtype_sumÚthe_sums r* r r \ s ðD LLEÜ v v¸!À$ÔGLFDÜ uÓ%IØ zzSÒØ Ø sÒ ÜHHRZZÓ( àjj YjÓ/GÜ g t¨T°6·<±<È9ÔUGà Nr, c óL t | t j « rG| j d« j |j
|
« } |j |¬« }t | |< | S |j « r2t j t « j |j
|
« S | S )Nr rÎ ) r r r r· r r3 rH r
|
r¨ )rt re ri rÀ Ú axis_masks r* r¿ r¿ s ô &"**Ô%à tÓ$×)Ñ)¨+×*;Ñ*;Ó<ØHH $HÓ' ô !yÑð Mð 88:Ü88D>×&Ñ& {×'8Ñ'8Ó9Ð 9Ø Mr, c ó4 | j }t | |d|¬« \ } }t |« }t j t j « }|j
|
dv r$t j t j « }nE|j
|
dv r$t j t j « }n|j
|
dk( r|}|}t | j |||¬« }| j ||¬« }t |« }|ut |dd « rht t j |« }t j d
|
¬ « 5 ||z } ddd« |dk( }
|
|
|
j « rt j |
|
< S |dkD r||z nt j } | S # 1 sw Y OxY w) 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
|
r rà r ÚiurR r¯ NrÉ FÚignore)rç )r3 r¤ r¬ r rª r Ú _get_countsrÊ rì Ú_ensure_numericrz r r ÚerrstaterH rC ) rG re rf ri r3 rî Ú dtype_countÚcountrï Úthe_meanÚct_masks r* r r sR ðB LLEÜ v v¸!À$ÔGLFDÜ uÓ%IÜ((2::Ó&Kð zzTÑÜHHRZZÓ( Ø tÑ ÜHHRZZÓ( Ø sÒ Ø Ø ä d¨D¸ Ô DEØjj YjÓ/GÜ gÓ&Gà ÐG G¨V°UÔ ;ÜRZZ Ó'Ü [[XÔ &ñ 'à H÷ 'ð 1*Ø ;;=Ü "§¡HWÑ ð Oð ',¨a¢i7U?´R·V±Và O÷ 'ð 'ús Ä:FÆFc ót | j j dk( xr |du }dfd }| j }t | |d¬« \ } }| j j dk7 rM| j t k( r(t j
|
| « }|dv rt d| d« | j d« } |s;|9| j j s| j « } t j | |< | j } | j d kD rÞ|Ü| rÃst j" ||| « }
|
nÛt% j& « 5 t% j( d
|
d t* « | j, d d k( r|d k( s| j, d d k( r0|d k( r+t j. t j0 | « d ¬« }
|
nt j. | |¬« }
|
ddd« n2t3 | j, |« }
|
n| r || |« nt j }
|
t5
|
|« S # t $ r}t t |« « |d}~ww xY w# 1 sw Y ;xY w)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
|
rR Nc ó( | t | « }n| }s |j « st j S t j
|
« 5 t j ddt « t j | | « }d d d « |S # 1 sw Y S xY w)Nrô úAll-NaN slice encountered) r! rç r rC rá Úcatch_warningsÚfilterwarningsÚRuntimeWarningÚ nanmedian)rÙ Ú_maskÚresrf s r* Ú
|
get_medianz nanmedian.<locals>.get_medianý s ø Ø =Ü!HEàFEÙeiikÜ66MÜ × $Ñ $Ó &ñ )ä × #Ñ #ØÐ5´~ô ô ,,q xÓ(C÷ )ð
|
÷ )ð
|
ús Á 4BÂB)ri r ©ÚstringÚmixedzCannot convert ú to numericr
rÈ rô rþ r T)ÚkeepdimsrÎ r& )r3 r r¤ r r Ú infer_dtyperK r· rL ÚstrrÒ Ú writeabler r rC rl rÉ Úapply_along_axisrá rÿ r r rÊ r ÚsqueezeÚ_get_empty_reduction_resultr» ) rG re rf ri Úusing_nan_sentinelr r3 ÚinferredÚerrÚnotemptyr s ` r* r r à s÷ ø ð6 ×*Ñ*¨cÑ1ÒB°d¸d°lÐõ ð LLEÜ v v°DÀTÔJLFDØ ||×ÑCÒ Ø <<6Ò !ä vÓ.HØÐ.Ñ.Ü /°&°¸Ð EÓFÐFð /Ø]] 4Ó(Fñ $Ð"2Ø||×%Ò%Ø[[]FÜvvt à{{Hð {{Q4Ð+á ÙÜ×)Ñ)¨*°d¸FÓCô ×,Ñ,Ó.ñ >ä ×+Ñ+Ø Ð"=¼~ôð Q¨1Ò,°¸²Ø Q¨1Ò,°¸²ô !ll¬2¯:©:°fÓ+=ÈÔ Mä ll¨6¸Ô =÷ >ð >ô$ .¨f¯l©l¸DÓACñ +3j Ô&¼¿¹Ü eÓ $Ð$øôU ò /äC HÓ%¨3Ð .ûð /ú÷& >ð >ús% ÂH Ä5B H.È H+ÈH&È&H+È.H7c ó t j | « }t j t | « « }t j |||k7 t j
|
¬« }|j t j « |S )z¬
|
The result from a reduction on an empty ndarray.
|
|
Parameters
|
----------
|
shape : Tuple[int, ...]
|
axis : int
|
|
Returns
|
-------
|
np.ndarray
|
r¯ )r rÕ Úarangerj Úemptyrª ÚfillrC )rÊ re ÚshpÚdimsÚrets r* r r C sU ô ((5/CÜ 99SZÓ DÜ
|
((3tt|Ñ$¬B¯J©JÔ
|
7CØHHRVVÔØ Jr, c óª t | |||¬« }||j |« z
|
}t |« r)||k r t j }t j }||fS t t j |« }||k }|j « rJt j ||t j « t j ||t j « ||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¯ ) rõ r1 r r rC r r rH r¡ )Ú values_shaperi re Úddofr3 rù Úds r* Ú_get_counts_nanvarr Z s« ô: d¨D¸Ô >EØ
|
|
4Ó Ñ Aô Ø D=ô FFEÜAð !8Oô RZZ Ó'Ø}Ø 88:Ü JJq$¤§¡Ô 'Ü JJud¤B§F¡FÔ +Ø !8Or, rÈ ©r ©re rf r ri c óÚ | j dk( r| j d« } | j }t | ||¬« \ } }t j t | ||||¬« « }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]rµ )ri r" )r3 r r¤ r ÚsqrtÚnanvarr» )rG re rf r ri Ú
|
orig_dtypert s r* Únanstdr' sb ðH ||xÒ ØXÓ&à JÜ v v°DÔ9LFDä WWVF¨°fÀ4ÈdÔSÓ TFÜ Ó ,Ð,r, Úm8c ó | j }t | ||« }|j dv r&| j d« } |t j
|
| |< | j j dk( r't | j |||| j « \ }}nt | j |||« \ }}|r)|'| j « } t j | |d« t | j |t j ¬« « |z }|t j ||« }t || z
|
dz « } |t j | |d« | j |t j ¬« |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
|
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
|
ró r
rR r )re r3 rÐ Fr³ )r3 r r r· r rC r rÊ r r¡ rö rì rª Ú expand_dims) rG re rf r ri r3 rù r ÚavgÚsqrrt s r* r% r% º sU ðJ LLEÜ 6 6¨4Ó 0DØ zzTÑØ tÓ$Ø Ð Ü 66F4Là ||×ÑCÒ Ü% f§l¡l°D¸$ÀÀfÇlÁlÓSqä% f§l¡l°D¸$ÀÓEqá $Ð"Ø Ü
|
|
|
64 Ô#ô &**¨$´b·j±j*ÓAÓ
|
BÀUÑ
|
JCØ ÐÜnnS $Ó'Ü
|
3 <¨AÑ-Ó
|
.CØ ÐÜ
|
|
|
3aÔ Ø WW$¤b§j¡jWÓ 1°AÑ 5Fð
|
zzSÒØ u¨5 Ó1Ø Mr, c ó t | ||||¬« t | ||« }| j j dk7 r| j d« } |s"| |j « rt j S t | j |||| j « \ }}t | ||||¬« }t j |« t j |« z 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
|
r" rR r
) r% r r3 r r· rH r rC r rÊ r$ )rG re rf r ri rù rä Úvars r* Únansemr/ s§ ôL 6 V°$¸TÕBä 6 6¨4Ó 0DØ ||×ÑCÒ Ø tÓ$á dÐ&¨4¯8©8¬:Üvv ä! &§,¡,°°d¸DÀ&Ç,Á,ÓOHE1Ü
|
d¨6¸À4Ô
|
HCä 773<"'' %.Ñ (Ð(r, c óf t d ¬« t d dd d d fd« « }|S )NrC )rb Tr½ c ó¶ | j dk( r t | |« S t | ||¬« \ } } t | « |« }t |||| j
|
« }|S )Nr ©r ri )rl rn r¤ rz rí rÊ )rG re rf ri rt r Úmeths r* Ú reductionz _nanminmax.<locals>.reduction; sc ø ð ;;!Ò Ü$ V¨TÓ2Ð 2ä"Ø F¨>Àô
|
ð ' Ó& tÓ,Ü ¨¨t°V·\±\ÓBØ r, rà )r` rÅ )r3 r r4 s `` r* Ú
|
_nanminmaxr5 : sa ù Üc $ LÔ)Üð $ØØ-1ñ Øðð ðð ð ð
|
+õ ó ó *ðð" Ðr, Úminr )r Úmaxú-infc óh t | dd|¬« \ } }| j |« }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])
|
Tr8 r2 )r¤ ÚargmaxÚ_maybe_arg_null_out©rG re rf ri rt s r* Ú nanargmaxr= U ó> ôL v t¸FÈÔNLFDØ ]]4Ó Fô ! ¨¨t°VÓ <FØ Mr, c óh t | dd|¬« \ } }| j |« }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 r2 )r¤ Úargminr; r< s r* Ú nanargminrA r> r, c ó: t | ||« }| j j dk7 r)| j d« } t | j
|
||« }n#t | j
|
||| j ¬« }|r*|(| j « } t j | |d« n$|s"| |j « rt j S t j dd¬« 5 | j |t j ¬« |z }ddd« |t j |« }| z
|
}|r|t j ||d« |dz }||z }|j |t j ¬« } |j |t j ¬« }
|
t | « } t |
|
« }
|
t j dd¬« 5 ||d z
|
d
|
z z |dz
|
z |
|
| d z z z } ddd« | j } | j dk( r j | d ¬ « } t! t j" « r2t j$ | dk( d| « } t j | |dk < | S | dk( r| j' d« n| } |dk rt j S | S # 1 sw Y xY w# 1 sw Y ¿xY w)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
|
rR r
r¯ Nr rô ©ÚinvalidÚdividerÐ rÈ g à?g ø?Fr³ é )r r3 r r· rõ rÊ r r r¡ rH rC r÷ rì rª r* Ú_zero_out_fperrr r r¢ r1 ) rG re rf ri rù ÚmeanÚadjustedÚ adjusted2Ú adjusted3Úm2Úm3rt r3 s r* ÚnanskewrN ± sF ôJ 6 6¨4Ó 0DØ ||×ÑCÒ Ø tÓ$ÜFLL¨$°Ó5äFLL¨$°¸F¿L¹LÔIá $Ð"Ø Ü
|
|
|
64 Õ#Ù Ð(¨T¯X©X¬ZÜvv ä X¨hÔ 7ñ :Øzz$¤b§j¡jzÓ1°EÑ9÷:à ÐÜ~~d DÓ)à}HÙ $Ð"Ü
|
|
|
8T 1Ô%Ø! IØHÑ$IØ t¤2§:¡: Ó .BØ t¤2§:¡: Ó .Bô
|
Ó BÜ Ó Bä X¨hÔ 7ñ MØ5 19¨Ñ,Ñ,°¸± Ñ:¸rÀBÈÁG¹|ÑL÷Mð LLEØ zzSÒØ u¨5 Ó1ä&"**Ô%Ü" ' 1 fÓ-Ü FFuqyÑð Mð #%¨¢'A ¨vØ 19Ü66Mà M÷G:ñ :ú÷(Mð Mús Ã%JÆ8JÊJÊJc ó" t | ||« }| j j dk7 r)| j d« } t | j
|
||« }n#t | j
|
||| j ¬« }|r*|(| j « } t j | |d« n$|s"| |j « rt j S t j dd¬« 5 | j |t j ¬« |z }ddd« |t j |« }| z
|
}|r|t j ||d« |dz }|dz }|j |t j ¬« } |j |t j ¬« }
|
t j dd¬« 5 d |d
|
z
|
dz z |dz
|
|d z
|
z z } ||d
|
z z |d
|
z
|
z |
|
z } |dz
|
|d z
|
z | dz z } ddd« t « } t « } t! | t j" « s5|d k rt j S | dk( r| j j% d« S t j dd¬« 5 | | z z
|
}ddd« | j }|j dk( rj |d ¬ « }t! t j" « r0t j& | dk( d|« }t j ||d k < |S # 1 sw Y îxY w# 1 sw Y xY w# 1 sw Y xY w)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
|
rR r
r¯ Nr rô rC rÐ rF rÈ é Fr³ )r r3 r r· rõ rÊ r r r¡ rH rC r÷ rì rª r* rG r r r1 r¢ )rG re rf ri rù rH rI rJ Ú adjusted4rL Úm4ÚadjÚ numeratorÚ denominatorrt r3 s r* ÚnankurtrV s¶ ôJ 6 6¨4Ó 0DØ ||×ÑCÒ Ø tÓ$ÜFLL¨$°Ó5äFLL¨$°¸F¿L¹LÔIá $Ð"Ø Ü
|
|
|
64 Õ#Ù Ð(¨T¯X©X¬ZÜvv ä X¨hÔ 7ñ :Øzz$¤b§j¡jzÓ1°EÑ9÷:à ÐÜ~~d DÓ)à}HÙ $Ð"Ü
|
|
|
8T 1Ô%Ø! IØ1 IØ t¤2§:¡: Ó .BØ t¤2§:¡: Ó .Bä X¨hÔ 7ñ 8Ø519 Ñ"Ñ" u¨q¡y°U¸Q±YÑ&?Ñ@ØU QYÑ'¨5°1©9Ñ5¸Ñ: Ø qy U¨Q¡YÑ/°"°a±%Ñ7 ÷8ô Ó*IÜ! +Ó.Kä k¤2§:¡:Ô .ð 19Ü66MØ !Ò Ø<<×$Ñ$ QÓ'Ð 'ä X¨hÔ 7ñ /Ø[Ñ(¨3Ñ.÷/ð LLEØ zzSÒØ u¨5 Ó1ä&"**Ô%Ü+¨Ñ*¨A¨vÓ6Ü FFuqyÑà M÷Y:ñ :ú÷8ñ 8ú÷(/ð /ús$ Ã%K+Æ":K8É LË+K5Ë8LÌLc ó¤ t | ||« }|r|| j « } d| |< | j |« }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
|
rÈ rë )r r Úprodrí rÊ )rG re rf rh ri rt s r* r r j s[ ô@ 6 6¨4Ó 0Dá $Ð"Ø Øt Ø [[Ó Fô ØdFLL°Iô ð r, c óì || S | t | dd« s&|r|j « ry|j « ry| S |r|j |« }n|j |« }|j « rd| |< | S )NrÉ Féÿÿÿÿ)rz rç rH )rt re ri rf Úna_masks r* r; r; sv ð |Ø à |7 6¨6°5Ô9Ù ØxxzØàxxzØð Mñ ØhhtnGàhhtnGØ ;;=Ø F7OØ Mr, c óB |F| |j |j « z
|
}nt j | « }|j |« S |"|j
|
| |j |« z
|
}n| | }t |« r|j |« S |j |d¬« S )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³ )rl rì r rX r1 rÊ r r· )r ri re r3 Únrù s r* rõ rõ ² s ð0 |Ø Ð Ø DHHJÑ&Aä Ó%AØzz!}Ð à ÐØ
|
|
4Ñ 4§8¡8¨D£>Ñ1à TÑ"ä%ÔØzz%Ó Ð Ø << E<Ó *Ð*r, c ó¤ ||dk( r| S |ôt | t j « rÚ|(|j | |j |« z
|
|z
|
dk }n/|| |z
|
dk }|d| ||dz d z }t j
|
||« }t j |« rjt | « rZt j | « r| j d« } n t | « s| j dd¬« } t j | |< | S d| |< | S | t urHt |||« r;t | dd« }t |« r|j d « } | S t j } | S )
|
zu
|
Returns
|
-------
|
Dtype
|
The product of all elements on a given axis. ( NaNs are treated as 1)
|
Nr rÈ Úc16r
Fr³ r3 rC )r r r rÊ rì Ú broadcast_torH r Ú iscomplexobjr· r rC r Úcheck_below_min_countrz r1 ) rt re ri rÊ rh Ú null_maskÚ below_countÚ new_shapeÚ result_dtypes r* rí rí Û sU ð | Qà à ÐJ v¬r¯z©zÔ :Ø Ð Ø DÑ)¨D¯H©H°T«NÑ:¸YÑFÈ!ÑKIð +¨ Ñ1°AÑ5KØ et u¨T°A©X¨ZÐ'8Ñ8Iܨ °YÓ?Iä 66)Ô Ü Ô'Ü?? 6Ô*Ø #]]¨5Ó 1FÜ'¨Ô/Ø #]]¨4°e]Ó <FÜ$&§F¡FyÑ!ð Mð %)yÑ!ð Mð
|
sÑ Ü ¨¨iÔ 8Ü" 6¨7°DÓ9LÜ lÔ+à%×*Ñ*¨5Ó1ð Mô à Mr, c ó |dkD r;|t j | « }n |j |j « z
|
}||k ryy)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
|
r TF)r rX rl rì )rÊ ri rh Ú non_nullss r* rb rb s? ð( 1}Ø <ä Ià D§H¡H£JÑ.IØ yÒ ØØ r, c óú t | t j « r-t j t j | « dk d| « S t j | « dk r| j
|
j d« S | S )Ng+¡=r )r r r r¢ Úabsr3 r1 )Úargs r* rG rG * sW ä#rzzÔ"Üxxs eÑ+¨Q°Ó4Ð4ä$&§F¡F¨3£K°%Ò$7syy~~aÓ Ð@¸SÐ@r, Úpearson)ÚmethodÚ min_periodsc ó@ t | « t |« k7 r t d« |d}t | « t |« z }|j « s
|
| | } || }t | « |k rt j
|
S t | « } t |« }t |« } || |« S )z
|
a, b: ndarrays
|
z'Operands to nancorr must have same sizerÈ )rj ÚAssertionErrorr! rç r rC rö Ú get_corr_func)ÚaÚbrm rn ÚvalidrR s r* Únancorrru 2 s ô 1vQÒÜ Ð FÓGÐGàÐØ ä !HuQxÑ EØ 99;Ø eHØ eHä
|
1v ÒÜvv äÓAÜÓAäfÓ AÙ Q7Nr, c ó | dk( r ddl m fd}|S | dk( r ddl m fd}|S | dk( rd }|S t | « r| S t d
|
| d « ) NÚkendallr )Ú
|
kendalltauc ó | |« d S ©Nr r~ )rr rs rx s r* rÁ zget_corr_func.<locals>.funcX s ø Ù a Ó# AÑ&Ð &r, Úspearman)Ú spearmanrc ó | |« d S rz r~ )rr rs r| s r* rÁ zget_corr_func.<locals>.func_ s ø Ù Q ? 1Ñ%Ð %r, rl c ó4 t j | |« d S )N©r rÈ )r Úcorrcoef)rr rs s r* rÁ zget_corr_func.<locals>.funce s Ü;;q !Ó$ TÑ*Ð *r, zUnknown method 'z@', expected one of 'kendall', 'spearman', 'pearson', or callable)Ú scipy.statsrx r| ÚcallablerL )rm rÁ rx r| s @@r* rq rq R sr ù ð ÒÝ*ô 'ð Ø :Ò Ý)ô &ð Ø 9Ò ò +ð Ü &Ô Ø ä
|
Ø
|
6(ð #8ð 8ó ð r, )rn r c óN t | « t |« k7 r t d« |d}t | « t |« z }|j « s
|
| | } || }t | « |k rt j
|
S t | « } t |« }t j | ||¬« d S )Nz&Operands to nancov must have same sizerÈ r! r )rj rp r! rç r rC rö Úcov)rr rs rn r rt s r* Únancovr
r s ô 1vQÒÜ Ð EÓFÐFàÐØ ä !HuQxÑ EØ 99;Ø eHØ eHä
|
1v ÒÜvv äÓAÜÓAä 66!QTÔ " 4Ñ (Ð(r, c ó¤ t | t j « rÌ| j j dv r!| j t j « } | S | j t k( r~t j | « }|dv rt d| d« | j t j « } t j t j | « « s| j } | S | S t! | « sCt# | « s8t% | « s-t | t& « rt d| d« t) | « } | S | S # t t f$ rF | j t j « } n!# t $ r}t d| d« |d }~ww xY wY | S w xY w# t t f$ r1 t+ | « } Y | S # t $ r}t d| d« |d }~ww xY ww xY w)Nr r zCould not convert r zCould not convert string 'z ' to numeric)r r r r3 r r· rª r r r rK Ú
|
complex128rH ÚimagÚrealrL r r r r ÚfloatÚcomplex)rÙ r r s r* rö rö s¿ Ü!RZZÔ Ø 77<<5Ñ ØÓ$Að< Hð; WWÒ Ü qÓ)HØÐ.Ñ.ä Ð"4°Q°C°{Ð CÓDÐDð
|
ØHHR]]Ó+ô vvbgg ajÔ)ØAð H1Hô qkZ¨]¬j¸¬mÜ aÔ äÐ 8¸¸¸<Ð HÓIÐ Ið NÜaAð H1Høô- zÐ*ò RðRؤ§¡Ó,AøÜ!ò Rä#Ð&8¸¸¸;Ð$GÓHÈcÐQûðRúð ð( Hð- Rûô :Ð&ò Nð NÜAJð Høô ò Nä Ð"4°Q°C°{Ð CÓDÈ#ÐMûð Núð Nús`  D7 Ä( F Ä7F Å E'Å&F Å' FÅ0F Æ FÆF Æ F ÆGÆ F-Æ- G Æ6GÇG Ç Gc ó¢ t j dt j ft j j t j
|
t j ft j dt j ft j j t j
|
t j fi| \ }}| j j dvsJ |rot | j j t j t j f« s1| 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
|
g ð?g r r rÎ )r ÚcumprodrC ÚmaximumÚ
|
accumulater ÚcumsumÚminimumr3 r r= r1 r® Úbool_r r )rG Ú
|
accum_funcrf Úmask_aÚmask_bÚvalsri rt s r* Ú na_accum_funcr ² s ô
|
|
S"&&MÜ
|
|
|
× Ñ ¤§¡ ¬¯©Ð 0Ü
|
C=Ü
|
|
|
× Ñ ¤§¡¬¯©Ð /ð ð
|
ñ NFFð <<× Ñ DÑ (Ð(Ð (ñ j § ¡ ×!2Ñ!2´R·Z±ZÄÇÁÐ4JÔKØ{{}ÜDzØT
|
ÙD qÔ)Ø t ð Mñ F¨Ô+à Mr, )T)r) r[ rX rY )r3 r rb r rX r[ rZ )NN)r3 r r z Scalar | None)rG rx rf r[ ri rÄ rX rÄ )NNN) rG rx rf r[ r r r z
|
str | Noneri rÄ rX z/tuple[np.ndarray, npt.NDArray[np.bool_] | None])r3 únp.dtyperX r )r3 r rX r[ r& )r3 r )rÁ r rX r )rG rx re ry rX zScalar | np.ndarray)
|
rG rx re ry rf r[ ri rÄ rX r[ ) rG rx re ry rf r[ rh Úintri rÄ rX r )
|
rt z+np.ndarray | np.datetime64 | np.timedelta64re ry ri znpt.NDArray[np.bool_]rÀ rx rX z5np.ndarray | np.datetime64 | np.timedelta64 | NaTType)
|
rG rx re ry rf r[ ri rÄ rX r )re ry rf r[ )rÊ r re r rX rx ) r r ri rÄ re ry r r r3 r rX z-tuple[float | np.ndarray, float | np.ndarray])re ry rf r[ r r )rG rx re ry rf r[ r r ) rG rx re ry rf r[ r r ri rÄ rX r )
|
rG rx re ry rf r[ ri rÄ rX zint | np.ndarray)
|
rt rx re ry ri rÄ rf r[ rX znp.ndarray | int)
|
r r ri rÄ re ry r3 znp.dtype[np.floating]rX z&np.floating | npt.NDArray[np.floating])rÈ ) rt ú np.ndarray | float | NaTTypere ry ri rÄ rÊ útuple[int, ...]rh r rX r )rÊ r ri rÄ rh r rX r[ )
|
rr rx rs rx rm r rn ú
|
int | NonerX r )rm r rX z)Callable[[np.ndarray, np.ndarray], float])
|
rr rx rs rx rn r r r rX r )rG r rf r[ rX r )]Ú
|
__future__r rU rE Útypingr r r rá Únumpyr Úpandas._configr Ú pandas._libsr r r
|
r Úpandas._typingr r r r r r r r r Úpandas.compat._optionalr Úpandas.util._exceptionsr Úpandas.core.dtypes.commonr r r r r r r r Úpandas.core.dtypes.missingr r r! r{ r' r( r+ r. r` ro rq r r r¤ r¬ r r» rÅ rn rÛ rå rè r r¿ r r r r3 rª r r' r% r/ r5 ÚnanminÚnanmaxr= rA rN rV r r; rõ rí rb rG ru rq r
rö r r~ r, r* ú<module>r© s ðÝ "ã Û ÷ñ ó
|
ã å %÷ó ÷
|
÷
|
õ
|
õ ?Ý 4÷ ÷ ó ÷ñ ñ °VÔ<Ø $Ð Øô ñ :Ð 6Ó7Ô 8÷ ñ ÷>5ñ 5ópó(
|
ð GKðØ ðØ!.óð,)Ø ð)Ø $ð)Ø,Hð)à!ó)ð^ Ø!%Ø)-ð DØ ðDà ðDð ðDð ð Dð
|
'ð Dð 5ó DóN ó2ô &óR óD Eó> ðJ ØØ)-ñ : Ø ð: ð ð: ð ð : ð
|
'ð : ð
|
ó : ð@ ØØ)-ñ : Ø ð: ð ð: ð ð : ð
|
'ð : ð
|
ó : ñz
|
$ ØØð ØØØ)-ñ *Ø ð*ð ð*ð ð *ð
|
ð *ð 'ð *ð ò*ó ó ó ð*ðZØ 7ðà
|
ðð ðð ð ð
|
;ó ñ& ÓØð ØØ)-ñ <Ø ð<ð ð<ð ð <ð
|
'ð <ð ò <ó ó ð<ñ~ ÓØ04ÀTÐPTô _%ó ð_%ðDØ ðà
|
ðð óð8 bhhrzzÓ*ð /Øð/à
|
&ð/ð ð/ð ð /ð
|
ð /ð 3ó /ñd Ôð ØØØ ñ *-ð ð*-ð ð *-ð
|
ò *-ó ð*-ñZ
|
$ÓÙÔð ØØØ ñ FØ ðFð ðFð ð Fð
|
ò Fó ó ðFñR
|
$Óð ØØØ)-ñ 1)Ø ð1)ð ð1)ð ð 1)ð
|
ð 1)ð 'ð 1)ð ò1)ó ð1)òhñ.
|
E¨&Ô 1Ù E¨&Ô 1ð ØØ)-ñ +Ø ð+ð ð+ð ð +ð
|
'ð +ð ó +ðb ØØ)-ñ +Ø ð+ð ð+ð ð +ð
|
'ð +ð ó +ñ\
|
$ÓØð ØØ)-ñ SØ ðSð ðSð ð Sð
|
'ð Sð ò Só ó ðSñl
|
$ÓØð ØØ)-ñ \Ø ð\ð ð\ð ð \ð
|
'ð \ð ò \ó ó ð\ñ~
|
$ÓØð ØØØ)-ñ (Ø ð(ð ð(ð ð (ð
|
ð (ð 'ð (ð ò(ó ó ð(ðVØ ðà
|
ðð 'ðð ð ð
|
ó ð> $, 2§8¡8¨B¯J©JÓ#7ð &+Øð&+à
|
&ð&+ð ð&+ð !ð &+ð
|
,ó &+ð\ ð -Ø (ð-à
|
ð-ð 'ð-ð ð -ð
|
ð -ð "ó -ð` Ø ð Ø">ð ØKNð à ó ò>Añ
|
$Óð
|
!*Ø "ñ Øð àð ð ð ð
|
ð ð ò ó ð ð> Ø ð à.ó ñ@
|
$Óð
|
#Øñ )Øð)àð)ð ð )ð
|
ð )ð ò )ó ð)ò6! ôH"r,
|
