U
|
¬ý°dÍ ã @ sì d dl mZ d dlZd dlZd dlZd dlmZmZmZ d dl Z d dl
|
Z d dl m Z d dlmZmZmZmZ d dlmZmZmZmZmZmZmZmZm Z 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)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/ d d
|
l0m1Z1 d d l2m3Z3m4Z4m5Z5 d d l6m7Z7 e d ddZ8e8dk Z9da:d¯dddddZ;e;e d G dd dZ<G dd dZ=d d dd d d Z>dd!d"d#Z?d°d d$d%d&d'Z@d(dd)d)d*d+d,ZAd±d(dd-d.d)d/d0d1d2ZBd dd3d4d5ZCd²d6d7d8d9ZDd:d:d;d<d=ZEd(d>d?d@dAdBZFd:d:d;dCdDZGddddEd(d>dd)ddFdGdHZHddddEd(d>dd)ddFdIdJZIe<dKeEeGddd ddLd(d>ddMd)dNdOdPdQZJdRd>dSd(dTdUdVdWZKe<e1e= eEddddEd(d>dd)dNdFdXdYZLe= ddddEd>ddZd[d\ZMd]d^d_d-d(d`dadbZNe Oe jP¡fdcd)d>dMd6dddedfdgZQe=dhdidddhddjd>ddMdkdldmZRe<dKdne=dhdidddhddjd>ddMdkdodpZSe<dKdndddhddjd(d>ddMd)dNdqdrdsZTdtdu ZUeUdvdwdxZVeUdydzdxZWe<d{ddddEd(d>dd)d|dFd}d~ZXe<d{ddddEd(d>dd)d|dFddZYe<dKdneGddddEd(d>dd)dNdFddZZe<dKdneGddddEd(d>dd)dNdFddZ[e<dKdneGddd ddLd(d>ddMd)dNdOd
dZ\d(d>d)dddddZ]e Oe jP¡fdcd)d>d6ddddZ^d³dd>d)d]dMddddZ_d]d)dMddddZ`dd Zae<dKdndddd(d(dddNdddZbddd d¡d¢Zce<dKdnddhd£d(d(dddNd¤d¥d¦Zdd§d¨ Zed©dª ZfefejgZhefejiZjefejkZlefejmZnefejoZpefejqZrd«dd«d¬dd®ZsdS )´é )Ú 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_any_int_dtypeÚ is_bool_dtypeÚ
|
is_complexÚis_datetime64_any_dtypeÚis_floatÚis_float_dtypeÚ
|
is_integerÚis_integer_dtypeÚis_numeric_dtypeÚis_object_dtypeÚ is_scalarÚis_timedelta64_dtypeÚneeds_i8_conversionÚ pandas_dtype)Ú PeriodDtype)ÚisnaÚna_value_for_dtypeÚnotna)Ú extract_arrayZ
|
bottleneckÚwarn)ÚerrorsFTÚboolÚNone)ÚvÚreturnc C s t r| ad S ©N)Ú_BOTTLENECK_INSTALLEDÚ_USE_BOTTLENECK)r- © r2 úId:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/nanops.pyÚset_use_bottleneckC s r4 zcompute.use_bottleneckc sB e Zd Zddd fdd Zdddd Zd
|
d
|
d d d Z ZS )Údisallowr r, )Údtypesr. c s" t ¡ tdd |D | _d S )Nc s s | ]}t |jV qd S r/ )r# Útype)Ú.0Údtyper2 r2 r3 Ú <genexpr>P s z$disallow.__init__.<locals>.<genexpr>)ÚsuperÚ__init__Útupler6 )Úselfr6 ©Ú __class__r2 r3 r< N s
|
zdisallow.__init__r+ ©r. c C s t |dot|jj| jS )Nr9 )ÚhasattrÚ
|
issubclassr9 r7 r6 )r> Úobjr2 r2 r3 ÚcheckR s zdisallow.checkr )Úfr. c s" t ¡ fdd}tt|S )Nc
|
s´ t | | ¡ ¡}tfdd|D rD j dd¡}td| dz0tjdd | |W 5 Q R £ W S Q R X W n: t k
|
r® } z t
|
| d rt|| W 5 d }~X Y nX d S )
|
Nc 3 s | ]} |¡V qd S r/ )rE )r8 rD )r> r2 r3 r: Y s z0disallow.__call__.<locals>._f.<locals>.<genexpr>ÚnanÚ zreduction operation 'z ' not allowed for this dtypeÚignore©Úinvalidr ) Ú itertoolsÚchainÚvaluesÚanyÚ__name__ÚreplaceÚ TypeErrorÚnpÚerrstateÚ
|
ValueErrorr )ÚargsÚkwargsZobj_iterÚf_nameÚe©rF r> r2 r3 Ú_fV s
|
ÿ"
|
z disallow.__call__.<locals>._f©Ú functoolsÚwrapsr r )r> rF r[ r2 rZ r3 Ú__call__U s zdisallow.__call__)rP Ú
|
__module__Ú __qualname__r< rE r_ Ú __classcell__r2 r2 r? r3 r5 M s r5 c @ s, e Zd Zd
|
ddddZddddd ZdS ) Úbottleneck_switchNr, rA c K s || _ || _d S r/ )ÚnamerW )r> rd rW r2 r2 r3 r< n s zbottleneck_switch.__init__r )Úaltr. c sp j p
|
jzttW n ttfk
|
r6 d Y nX t ¡d dddddd fdd}tt |S ) NT©ÚaxisÚskipnaú
|
np.ndarrayúAxisInt | Noner+ )rN rg rh c sê t jdkr2j ¡ D ]\}}||kr|||< q| jdkrT| d¡d krTt| |S trÐ|rÐt| jrÐ| dd ¡d kr¸| dd ¡ | fd|i|}t
|
|rÎ | f||d|}qæ | f||d|}n | f||d|}|S )Nr Ú min_countÚmaskrg rf ) ÚlenrW ÚitemsÚsizeÚgetÚ_na_for_min_countr1 Ú _bn_ok_dtyper9 ÚpopÚ _has_infs)rN rg rh ÚkwdsÚkr- Úresult©re Zbn_funcZbn_namer> r2 r3 rF z s
|
|
z%bottleneck_switch.__call__.<locals>.f)
|
rd rP ÚgetattrÚbnÚAttributeErrorÚ NameErrorr] r^ r r )r> re rF r2 rx r3 r_ r s
|
ü"'zbottleneck_switch.__call__)N)rP r` ra r< r_ r2 r2 r2 r3 rc m s rc r Ústr)r9 rd r. c C s t | st| s|dkS dS )N)ÚnansumÚnanprodÚnanmeanF)r r" )r9 rd r2 r2 r3 rr ¥ s rr rA c C sV t | tjr&| jdkr&t | d¡¡S zt | ¡ ¡ W S t t
|
fk
|
rP Y dS X d S )N)Úf8Zf4ÚKF) Ú
|
isinstancerS Úndarrayr9 r
|
Zhas_infsZravelÚisinfrO rR ÚNotImplementedError)rw r2 r2 r3 rt ¹ s
|
rt z Scalar | None)r9 Ú
|
fill_valuec C sP |dk r |S t | r:|dkr"tjS |dkr0tjS tj S n|dkrHtjS tS dS )z9return the correct fill value for the dtype of the valuesNú+inf)Ú _na_ok_dtyperS rG Úinfr
|
Úi8maxr )r9 r Úfill_value_typr2 r2 r3 Ú_get_fill_valueÆ s
|
r ri ú npt.NDArray[np.bool_] | None)rN rh rl r. c C s: |dkr6t | js t| jr dS |s.t| jr6t| }|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)r r9 r r" r% )rN rh rl r2 r2 r3 Ú_maybe_get_maskÜ s !r r z
|
str | NonezHtuple[np.ndarray, npt.NDArray[np.bool_] | None, np.dtype, np.dtype, Any])rN rh r r rl r. c C sò t |s tt| dd} t| ||}| j}d}t| jrLt | d¡¡} d}t |}t
|
|||d}|r®|dk r®|dk r®| ¡ r®|s|r| ¡ } t | ||¡ nt | | |¡} |}t|sÂt|rÐt tj¡}nt|rät tj¡}| ||||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©Z extract_numpyFÚi8)r r N)r ÚAssertionErrorr( r r9 r" rS ZasarrayÚviewr r rO ÚcopyÚputmaskÚwherer r Úint64r Úfloat64) rN rh r r rl r9 Ú datetimelikeZdtype_okÚ dtype_maxr2 r2 r3 Ú _get_values s4 .
|
ÿ r )r9 r. c C s t | r dS t| jtj S )NF)r" rC r7 rS Úinteger©r9 r2 r2 r3 r a s r znp.dtyper c C s | t kr n t|r|dkr t}t| tjst|r<td| |krJtj} t| rft dd¡
|
|¡} nt | ¡ |¡} | j
|
|dd} n
|
|
|
|¡} nzt |r t| tjsü| |ksºt | ¡rÌt d¡
|
|¡} n.t | ¡tjkrætdnt | ¡j
|
|dd} n|
|
d¡ |¡} | S ) zwrap our results if neededNz Expected non-null fill_valuer ÚnsF©r z overflow in timedelta operationúm8[ns])r r r r rS r r% r rG Z
|
datetime64Úastyper r r! ÚisnanZ timedelta64Úfabsr
|
r rU )rw r9 r r2 r2 r3 Ú _wrap_resultsg s.
|
|
r¤ r )Úfuncr. c s6 t ¡ddddddddd fd 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.
|
NT©rg rh rl ri rj r+ r )rN rg rh rl c sr | }| j jdk}|r$|d kr$t| } | f|||d|}|rnt||j td}|sn|d k s`tt||||}|S )N©ÚmÚMr¦ )r )r9 Úkindr% r¤ r r Ú_mask_datetimelike_result)rN rg rh rl rW Ú orig_valuesr rw ©r¥ r2 r3 Únew_func s z&_datetimelike_compat.<locals>.new_funcr\ )r¥ r® r2 r r3 Ú_datetimelike_compat s û r¯ rj zScalar | np.ndarray)rN rg r. c C sl t | r| d¡} t| j}| jdkr*|S |dkr6|S | jd|
| j|d d
}tj||| jdS dS )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.
|
r é Nr )r r¡ r& r9 ÚndimÚshaperS Úfull)rN rg r Z result_shaper2 r2 r3 rq ² s
|
|
|
rq c s. t ¡ddddd 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.
|
N©rg ri rj )rN rg c s¼ |dkr¨| j dkr¨| jd r¨| jd d | jd kr¨| jtkr¨| jtkr¨t| d¡d k r d¡ fddt t
|
D }nfd d D }t |¡S | fd
|
|iS ) Nr° é Z C_CONTIGUOUSiè r rl c s( g | ] } | fd | iqS ©rl r2 )r8 Úi)Úarrsr¥ rW rl r2 r3 Ú
|
<listcomp>ç s z:maybe_operate_rowwise.<locals>.newfunc.<locals>.<listcomp>c s g | ]} |fqS r2 r2 )r8 Úx)r¥ rW r2 r3 r¹ ë s rg ) r± Úflagsr² r9 Úobjectr+ Úlistrp rs Úrangerm rS Úarray)rN rg rW Úresultsr )r¸ rW rl r3 ÚnewfuncØ s* ÿþýúùø
|
|
|
ÿ
|
z&maybe_operate_rowwise.<locals>.newfuncr\ )r¥ rÁ r2 r r3 Úmaybe_operate_rowwiseÑ s r r¦ ©rN rg rh rl r. c C s^ t | jr(| jjdkr(tjdtt d t| |d|d\} }}}}t| rT| 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
|
r¨ zz'any' with datetime64 dtypes is deprecated and will raise in a future version. Use (obj != pd.Timestamp(0)).any() instead.©Ú
|
stacklevelF©r rl ) r" r9 rª Úwarningsr) Ú FutureWarningr r r r¡ r+ rO ©rN rg rh rl Ú_r2 r2 r3 Únananyó s "ü
|
rË c C s^ t | jr(| jjdkr(tjdtt d t| |d|d\} }}}}t| rT| 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)
|
True
|
|
>>> from pandas.core import nanops
|
>>> s = pd.Series([1, 0])
|
>>> nanops.nanall(s)
|
False
|
r¨ zz'all' with datetime64 dtypes is deprecated and will raise in a future version. Use (obj != pd.Timestamp(0)).all() instead.rÄ TrÆ ) r" r9 rª rÇ r) rÈ r r r r¡ r+ ÚallrÉ r2 r2 r3 Únanall* s "ü
|
rÍ ZM8)rg rh rk rl ÚintÚfloat)rN rg rh rk rl r. c
|
C sf t | |d|d\} }}}}|}t|r,|}nt|r@t tj¡}| 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
|
r rÆ r ©rk ) r r r! rS r9 r ÚsumÚ_maybe_null_outr² )
|
rN rg rh rk rl r9 r rÊ Ú dtype_sumÚthe_sumr2 r2 r3 r~ a s " ÿ r~ z+np.ndarray | np.datetime64 | np.timedelta64znpt.NDArray[np.bool_]z5np.ndarray | np.datetime64 | np.timedelta64 | NaTType)rw rg rl r¬ r. c C sR t | tjr4| d¡ |j¡} |j|d}t| |< n| ¡ rNt t¡ |j¡S | S )Nr r´ ) r rS r r¡ r r9 rO r r )rw rg rl r¬ Z axis_maskr2 r2 r3 r« s
|
r« c C s t | |d|d\} }}}}|}t tj¡}|jdkrBt tj¡}n&t|rXt tj¡}nt|rh|}|}t| j|||d} t | j
|
||d}
|
|dk rèt |
|
ddrèt tj | } tjdd |
|
| } W 5 Q R X | dk} | ¡ rþtj| | < n| 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
|
r rÆ r§ r Nr± FrI ©rÌ )r rS r9 r rª r r Ú _get_countsr² Ú_ensure_numericrÑ ry r r rT rO rG ) rN rg rh rl r9 r rÊ rÓ Z dtype_countÚcountrÔ Zthe_meanZct_maskr2 r2 r3 r ¥ s4 " ÿ
|
r rf c
|
|
s d
|
fdd }t | |dd\} }}}}t| jsrz| d¡} W n0 tk
|
rp } ztt||W 5 d}~X Y nX |dk rtj| |< | j }| j
|
dkrú|dk rú|rä s´t ||| ¡} qøt ¡ t dd t¡ t | |¡} W 5 Q R X nt| 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
|
Nc s^ |d krt | }n| } s*| ¡ s*tjS t ¡ " t ddt¡ t | | ¡}W 5 Q R X |S )NrI úAll-NaN slice encountered) r' rÌ rS rG rÇ Úcatch_warningsÚfilterwarningsÚRuntimeWarningÚ nanmedian)rº Z_maskÚres©rh r2 r3 Ú
|
get_median s
|
|
ÿz nanmedian.<locals>.get_medianr )rl r r r° rI rÙ )N)r r r9 r¡ rU rR r} rS rG ro r± Zapply_along_axisrÇ rÚ rÛ rÜ rÝ Úget_empty_reduction_resultr² Zfloat_r¤ )
|
rN rg rh rl rà r9 rÊ ÚerrZnotemptyrÞ r2 rß r3 rÝ ç s0
|
|
|
ÿrÝ ztuple[int, ...]r z np.dtype | type[np.floating])r² rg r9 r r. c C s< t | ¡}t t| ¡}t j|||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 )rS r¿ Zarangerm ÚemptyÚfill)r² rg r9 r ZshpZdimsÚretr2 r2 r3 rá 8 s
|
|
|
rá r z-tuple[float | np.ndarray, float | np.ndarray])Ú values_shaperl rg Úddofr9 r. c C s t | |||d}|| |¡ }t|r<||krxtj}tj}n<ttj|}||k}| ¡ rxt ||tj¡ t ||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 ) rÖ r7 r rS rG r r rO r )ræ rl rg rç r9 rØ Údr2 r2 r3 Ú_get_counts_nanvarS s ré r° ©rç ©rg rh rç rl )rg rh rç c C sT | j dkr| d¡} | j }t| ||d\} }}}}t t| ||||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]r r¶ rë )r9 r r rS ÚsqrtÚnanvarr¤ )rN rg rh rç rl Z
|
orig_dtyperÊ rw r2 r2 r3 Únanstd s $
|
|
rî Zm8c C s t | dd} | j}t| ||}t|rB| d¡} |dk rBtj| |< t| jrft| j |||| j\}}nt| j |||\}}|r|dk r|
|
¡ } t | |d¡ t | j |tjd| }|dk rÈt ||¡}t || d } |dk rît | |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
|
Tr r Nr )rg r9 rµ Fr )r( r9 r r r¡ rS rG r ré r² r r r× rÑ r Ú expand_dims) rN rg rh rç rl r9 rØ rè ÚavgZsqrrw r2 r2 r3 rí ° s. %
|
|
|
|
rí )rN rg rh rç rl r. c C s t | ||||d t| ||}t| js2| d¡} |sL|dk rL| ¡ rLtjS t| 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
|
rë r N) rí r r r9 r¡ rO rS rG ré r² rì )rN rg rh rç rl rØ rÊ Úvarr2 r2 r3 Únansemü s &
|
|
rò c s> t d dtd dd dddddd d
|
fd d }|S ) NrG )rd Tr¦ ri rj r+ r r rà c
|
s¢ t | | |d\} }}}}|d k r0| j| dks:| jdkrz"t| ||d}| tj¡ W q ttt fk
|
r| tj}Y qX nt| |}t
|
|||| j}|S )N©r rl r r ) r r² ro ry rä rS rG r{ rR rU rÒ )rN rg rh rl r9 r r rw ©r Úmethr2 r3 Ú reduction2 s ÿ z _nanminmax.<locals>.reduction)rc r¯ )rõ r rö r2 rô r3 Ú
|
_nanminmax1 s û$r÷ Úminr )r Úmaxú-infÚOzint | np.ndarrayc C s6 t | 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ó )r ZargmaxÚ_maybe_arg_null_out©rN rg rh rl rÊ rw r2 r2 r3 Ú nanargmaxR s '
|
rþ c C s6 t | 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 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 ró )r Zargminrü rý r2 r2 r3 Ú nanargmin s '
|
rÿ c C sÊ t | dd} t| ||}t| js<| d¡} t| j||}nt| j||| jd}|rt|dk rt| ¡ } t | |d¡ n|s|dk r|
|
¡ rtj S | j |tj d| }|dk r¶t ||¡}| | }|rØ|dk rØt ||d¡ |d }|| }|j |tj d} |j |tj d}
|
t| } t|
|
}
|
tjddd * ||d
|
d |d |
|
| d } W 5 Q R X | j} t| rt| j| d d} t| tjr¤t | dkd| ¡} tj | |dk < n"| dkr²dn| } |dk rÆ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)
|
1.7320508075688787
|
Tr r r Nr rµ rI ©rK Údivider° g à?g ø?Fr é )r( r r r9 r¡ rÖ r² r rS r rO rG rÑ r rï Ú_zero_out_fperrrT r r r ) rN rg rh rl rØ ÚmeanÚadjustedÚ adjusted2Z adjusted3Úm2Zm3rw r9 r2 r2 r3 Únanskew® sF '
|
|
.
|
|
r c C s$ t | dd} t| ||}t| js<| d¡} t| j||}nt| j||| jd}|rt|dk rt| ¡ } t | |d¡ n|s|dk r|
|
¡ rtj S | j |tj d| }|dk r¶t ||¡}| | }|rØ|dk rØt ||d¡ |d }|d }|j |tj d} |j |tj d}
|
tjddd V d
|
|d d |d |d
|
} ||d |d |
|
} |d |d
|
| d } W 5 Q R X t| } t| } t| tjs®|d k r tj S | dkr®dS tjddd | | | }W 5 Q R X | 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
|
Tr r r Nr rµ rI r r r° é Fr )r( r r r9 r¡ rÖ r² r rS r rO rG rÑ r rï rT r r r r )rN rg rh rl rØ r r r Z adjusted4r Zm4ZadjÚ numeratorÚ denominatorrw r9 r2 r2 r3 Únankurt sR '
|
|
"
|
|
|
r c C sF t | ||}|r(|dk r(| ¡ } 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
|
Nr° rÐ )r r ÚprodrÒ r² )rN rg rh rk rl rw r2 r2 r3 r k s
|
ÿr znp.ndarray | int)rw rg rl rh r. c C sn |d kr | S |d ks t | dds@|r2| ¡ r>dS qj| ¡ rjdS n*|rP| |¡}n
|
| |¡}| ¡ rjd| |< | S )Nr± Féÿÿÿÿ)ry rÌ rO )rw rg rl rh Zna_maskr2 r2 r3 rü s
|
rü zfloat | np.ndarray)ræ rl rg r9 r. c C sz |dkr4|dk r |j | ¡ }n
|
t | ¡}| |¡S |dk rR|j| | |¡ }n| | }t|rl| |¡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 )ro rÑ rS r r7 r² r r¡ )ræ rl rg r9 ÚnrØ r2 r2 r3 rÖ ³ s
|
|
|
rÖ z np.ndarray | float | NaTType)rw rg rl r² rk r. c C s |dkr|dkr| S |dk rÚt | tjrÚ|dk rN|j| | |¡ | dk }n8|| | dk }|d|
||d d
}t ||¡}t |¡rØt| rÐt | ¡r®| d¡} nt
|
| sÄ| j ddd} tj | |< nd| |< n@| t k rt |||rt| dd}t
|
|r| d ¡} ntj } | S )
|
zu
|
Returns
|
-------
|
Dtype
|
The product of all elements on a given axis. ( NaNs are treated as 1)
|
Nr r° Zc16r Fr r9 rG )r rS r r² rÑ Z broadcast_torO r Z iscomplexobjr¡ r rG r Úcheck_below_min_country r7 ) rw rg rl r² rk Z null_maskZ below_countZ new_shapeZ result_dtyper2 r2 r3 rÒ Ü s.
|
|
|
|
|
rÒ )r² rl rk r. c C s: |dkr6|dkr t | ¡}n|j| ¡ }||k r6dS dS )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 NTF)rS r ro rÑ )r² rl rk Z non_nullsr2 r2 r3 r s r c
|
C sh t | tjrFtjdd& t t | ¡dk d| ¡W 5 Q R £ S Q R X n t | ¡dk r`| j d¡S | S d S )NrI rJ g+¡=r )r rS r rT r Úabsr9 r7 )Úargr2 r2 r3 r + s ,r Úpearson)ÚmethodÚ min_periodsr z
|
int | None)ÚaÚbr r r. c C sp t | t |krtd|dkr$d}t| t|@ }| ¡ sL| | } || }t | |k r^tjS t|}|| |S )z
|
a, b: ndarrays
|
z'Operands to nancorr must have same sizeNr° )rm r r' rÌ rS rG Ú get_corr_func)r r r r ÚvalidrF r2 r2 r3 Únancorr4 s r z)Callable[[np.ndarray, np.ndarray], float])r r. c s| | dkr$ddl m fdd}|S | dkrHddl m fdd}|S | d kr\d
|
d }|S t| rh| S td | d d S ) NZkendallr ©Ú
|
kendalltauc s | |d S ©Nr r2 ©r r r r2 r3 r¥ W s zget_corr_func.<locals>.funcZspearman©Ú spearmanrc s | |d S r r2 r r r2 r3 r¥ ^ s r c S s t | |¡d S )N©r r° )rS Zcorrcoefr r2 r2 r3 r¥ d s zUnknown method 'z@', expected one of 'kendall', 'spearman', 'pearson', or callable)Z scipy.statsr r ÚcallablerU )r r¥ r2 )r r r3 r Q s
|
ÿr )r rç )r r r rç r. c C sr t | t |krtd|d kr$d}t| t|@ }| ¡ sL| | } || }t | |k r^tjS tj| ||dd S )Nz&Operands to nancov must have same sizer° rê r! )rm r r' rÌ rS rG Zcov)r r r rç r r2 r2 r3 Únancovq s r# c C sH t | tjrºt| s t| r*| tj¡} nt| r¸z| tj¡} W n^ t t
|
fk
|
r z| tj¡} W n4 t
|
k
|
r } zt d| d|W 5 d }~X Y nX Y nX t t | ¡¡s¸| j } nt| sDt| sDt| sDz t| } W n^ t t
|
fk
|
rB z t| } W n6 t
|
k
|
r< } zt d| d|W 5 d }~X Y nX Y nX | S )NzCould not convert z to numeric)r rS r r r r¡ r r Z
|
complex128rR rU rO ÚimagÚrealr r r rÏ Úcomplex)rº râ r2 r2 r3 r× s, * *r× c s fdd}|S )Nc sh t | }t |}||B }tjdd | |}W 5 Q R X | ¡ rdt|rT| d¡}t ||tj¡ |S )NrI rÕ rû )r% rS rT rO r r¡ r rG )rº ÚyZxmaskZymaskrl rw ©Úopr2 r3 rF « s
|
zmake_nancomp.<locals>.fr2 )r) rF r2 r( r3 Ú make_nancompª s r* r )rN rh r. c C s® t jdt jft jjt j t jft jdt jft jjt jt jfi| \}}| jj dksVt
|
|rt | jj t j t jfs| ¡ }t|}|||< ||dd}|||< n || 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 ð?g r§ r r´ )rS ZcumprodrG ÚmaximumÚ
|
accumulater ZcumsumZminimumr9 rª r rC r7 r Zbool_r r% )rN Z
|
accum_funcrh Zmask_aZmask_bÚvalsrl rw r2 r2 r3 Ú na_accum_funcÅ s(
|
üû
|
r. )T)NN)NNN)N)r° )tÚ
|
__future__r r] rL ÚoperatorÚtypingr r r rÇ ÚnumpyrS Zpandas._configr Z pandas._libsr r r r
|
Zpandas._typingr r r r r r r r r Zpandas.compat._optionalr Zpandas.util._exceptionsr Zpandas.core.dtypes.commonr r r r r r r r r r r r! r" r# Zpandas.core.dtypes.dtypesr$ Zpandas.core.dtypes.missingr% r& r' Zpandas.core.constructionr( rz r0 r1 r4 r5 rc rr rt r r r r r¤ r¯ rq r rË rÍ r~ r« r rÝ rá r9 r ré rî rí rò r÷ ZnanminZnanmaxrþ rÿ r r r rü rÖ rÒ r r r r r# r× r* ÚgtZnangtÚgeZnangeÚltZnanltÚleZnanleÚeqZnaneqÚneZnanner. r2 r2 r2 r3 Ú<module> s , @ 8 ÿ/ ûY)" %û:û7ú".û ? P
|
û/ú-úJú 4 û -û -û Xû aú +
|
ü. û0 û û
|
|
|
|
|
|
|
