Файловый менеджер - Редактировать - /home/digitalm/venv/lib/python3.7/site-packages/pandas/core/__pycache__/nanops.cpython-37.pyc
Назад
B �5�gi� � @ s� d dl mZ d dlZd dlZd dlZd dlmZmZ d dlZd dl Z d dl m Z d dl mZmZmZmZmZ d dlmZmZmZmZmZmZ d dlmZ 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,m-Z- d d l.m/Z/ d d l0m1Z1m2Z2m3Z3 d d l4m5Z5 ed dd�Z6e6dk Z7da8d�ddd�dd�Z9e9e d�� G dd� d�Z:G dd� d�Z;d d dd �d d �Z<dd!�d"d#�Z=d�d d$d%�d&d'�Z>d(dd)d)d*�d+d,�Z?d�d(dd-d.d)d/d0�d1d2�Z@d dd3�d4d5�ZAd�d6d7�d8d9�ZBd:d:d;�d<d=�ZCd(d>d?d@�dAdB�ZDddddC�d(d>dd)ddD�dEdF�ZEddddC�d(d>dd)ddD�dGdH�ZFe:dI�eCddd ddJ�d(d>ddKd)dLdM�dNdO���ZGdPd>d(d(dQdR�dSdT�ZHe:e/�e;� eCddddC�d(d>dd)dLdD�dUdV����ZIe;� ddddC�dWdX��ZJdYdKdZd-d(d[�d\d]�ZKeLfd^d)d>dKd_d`da�dbdc�ZMe;ddde�ddddddf�dgdh��ZNe:dIdi�e;ddde�ddddddf�djdk���ZOe:dIdi�ddddddf�d(d>ddKd)dLdl�dmdn��ZPdodp� ZQeQdqdrds�ZReQdtduds�ZSe:dv�ddddC�d(d>dd)dwdD�dxdy��ZTe:dv�ddddC�d(d>dd)dwdD�dzd{��ZUe:dIdi�ddddC�d(d>dd)dLdD�d|d}��ZVe:dIdi�ddddC�d(d>dd)dLdD�d~d��ZWe:dIdi�ddd ddJ�d(d>ddKd)dLdM�d�d���ZXd(d>d)dd�d��d�d��ZYeLfdYd)d>d_d�d��d�d��ZZd�d�d>d)dYdKd�d��d�d��Z[dYd)dKdd��d�d��Z\d�d�� Z]e:dIdi�d�dd��d(d(d>d��d�d���Z^d�d�� Z_e:dIdi�dddd��d(d(d>d>d��d�d���Z`d�d�� Zad�d�� Zbebejc�Zdebeje�Zfebejg�Zhebeji�Zjebejk�Zlebejm�Znd(d(d(d�d?d��d�d��Zod(d(d(d��d�d��Zpd�dd�d��d�d��ZqdS )�� )� annotationsN)�Any�cast)� get_option)�NaT�NaTType� Timedelta�iNaT�lib)� ArrayLike�Dtype�DtypeObj�F�Scalar�Shape)�import_optional_dependency)�np_percentile_argname)� get_dtype�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+ � r/ �H/home/digitalm-up/venv/lib/python3.7/site-packages/pandas/core/nanops.py�set_use_bottleneckA s r1 zcompute.use_bottleneckc s: e Zd Z� fdd�Zdd�dd�Zddd�d d �Z� ZS ) �disallowc s" t � �� tdd� |D ��| _d S )Nc s s | ]}t |�jV qd S )N)r! �type)�.0�dtyper/ r/ r0 � <genexpr>N s z$disallow.__init__.<locals>.<genexpr>)�super�__init__�tuple�dtypes)�selfr: )� __class__r/ r0 r8 L s zdisallow.__init__r) )r, c C s t |d�ot|jj| j�S )Nr5 )�hasattr� issubclassr5 r3 r: )r; �objr/ r/ r0 �checkP s zdisallow.checkr )�fr, c s" t �� �� �fdd��}tt|�S )Nc s� t �| |�� �}t�fdd�|D ��rD� j�dd�}td|� d���y"tjdd�� � | |�S Q R X W n: t k r� } z t | d �r�t|�|�� W d d }~X Y nX d S ) Nc 3 s | ]}� � |�V qd S )N)r@ )r4 r? )r; r/ r0 r6 W 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)rA r; r/ r0 �_fT s z disallow.__call__.<locals>._f)� functools�wrapsr r )r; rA rT r/ )rA r; r0 �__call__S s zdisallow.__call__)rJ � __module__� __qualname__r8 r@ rW � __classcell__r/ r/ )r< r0 r2 K s r2 c @ s& e Zd Zddd�Zddd�dd�ZdS ) �bottleneck_switchNc K s || _ || _d S )N)�namerQ )r; r\ rQ r/ r/ r0 r8 l s zbottleneck_switch.__init__r )�altr, c sp �j p � j�ytt���W n ttfk r6 d �Y nX t�� �d dd�dddd�� ���fdd��}tt |�S ) NT)�axis�skipnaz np.ndarrayz int | Noner) )rH r^ r_ c s� t �j�dkr6x&�j�� D ]\}}||kr|||< qW | jdkrX|�d�d krXt| |�S tr�|r�t| j��r�|�dd �d kr�|� dd � �| fd|i|��}t |�r҈ | f||d�|��}q� | f||d�|��}n� | f||d�|��}|S )Nr � min_count�maskr^ )r^ r_ ) �lenrQ �items�size�get�_na_for_min_countr. � _bn_ok_dtyper5 �pop� _has_infs)rH r^ r_ �kwds�kr+ �result)r] �bn_func�bn_namer; r/ r0 rA x s z%bottleneck_switch.__call__.<locals>.f) r\ rJ �getattr�bn�AttributeError� NameErrorrU rV r r )r; r] rA r/ )r] rm rn r; r0 rW p s $#zbottleneck_switch.__call__)N)rJ rX rY r8 rW r/ r/ r/ r0 r[ k s r[ r �str)r5 r\ r, c C s t | �st| �s|dkS dS )N)�nansum�nanprodF)r r )r5 r\ r/ r/ r0 rg � s rg )r, c C sl t | tj�r@| jdkr&t�| �d��S | jdkr@t�| �d��S yt�| �� � S t t fk rf dS X d S )N�f8�KZf4F) � isinstancerM �ndarrayr5 r Z has_infs_f8�ravelZ has_infs_f4�isinfrI rL �NotImplementedError)rl r/ r/ r0 ri � s ri z Scalar | None)r5 � 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 valuesNz+inf)� _na_ok_dtyperM rB �infr �i8maxr )r5 r} �fill_value_typr/ r/ r0 �_get_fill_value� s r� z np.ndarrayznp.ndarray | None)rH r_ ra r, c C s: |dkr6t | j�s t| j�r dS |s.t| j�r6t| �}|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] N)r r5 r r r# )rH r_ ra r/ r/ r0 �_maybe_get_mask� s !r� r z str | Nonez=tuple[np.ndarray, np.ndarray | None, np.dtype, np.dtype, Any])rH r_ r} r� ra r, c C s� t |�s t�t| dd�} t| ||�}| j}d}t| j�rLt�| �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 )a1 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] nan-mask if known Returns ------- values : ndarray Potential copy of input value array mask : Optional[ndarray[bool]] Mask for values, if deemed necessary to compute dtype : np.dtype dtype for values dtype_max : np.dtype platform independent dtype fill_value : Any fill value used T)� extract_numpyF�i8)r} r� N)r �AssertionErrorr& r� r5 r rM �asarray�viewr~ r� rI �copy�putmask�wherer r �int64r �float64) rH r_ r} r� ra r5 � datetimelikeZdtype_ok� dtype_maxr/ r/ r0 � _get_values s. . r� )r5 r, c C s t | �r dS t| jtj� S )NF)r r> r3 rM �integer)r5 r/ r/ r0 r~ [ s r~ znp.dtype)r5 c C s� | t kr n�t|�r||dkr t}t| tj�spt|�r:td��| |krHtj} t| �r^t� dd�} qzt� | �� d�} q�| � |�} nXt |�r�t| tj�s�| |kr�tj} t�| �tjkr�td��t| dd�} n| � d�� |�} | S ) zwrap our results if neededNz Expected non-null fill_valuer �nszdatetime64[ns]z overflow in timedelta operation)�unitzm8[ns])r r r rx rM ry r# r� rB Z datetime64r� r� �astyper �fabsr r� rO r )rl r5 r} r/ r/ r0 � _wrap_resultsa s, r� r )�funcr, c s6 t �� �dddd�ddddd�� 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)r^ r_ ra z np.ndarrayz int | Noner) znp.ndarray | None)rH r^ r_ ra c sr | }| j jdk}|r$|d kr$t| �}� | f|||d�|��}|rnt||j td�}|sn|d k s`t�t||||�}|S )N)�m�M)r^ r_ ra )r} )r5 �kindr# r� r r� �_mask_datetimelike_result)rH r^ r_ ra rQ � orig_valuesr� rl )r� r/ r0 �new_func� s z&_datetimelike_compat.<locals>.new_func)rU rV r r )r� r� r/ )r� r0 �_datetimelike_compat� s r� z int | NonezScalar | np.ndarray)rH r^ r, c C sl t | �r| �d�} t| j�}| jdkr*|S |dkr6|S | jd|� | j|d d� }tj||| jd�S 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� � N)r5 )r r� r$ r5 �ndim�shaperM �full)rH r^ r} Z result_shaper/ r/ r0 rf � s rf )r^ r_ ra )rH r^ r_ ra r, c C s6 t | |d|d�\} }}}}t| �r,| �t�} | �|�S )a Check if any elements along an axis evaluate to True. Parameters ---------- values : ndarray axis : int, optional skipna : bool, default True mask : ndarray[bool], optional nan-mask if known Returns ------- result : bool Examples -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, 2]) >>> nanops.nanany(s) True >>> import pandas.core.nanops as nanops >>> s = pd.Series([np.nan]) >>> nanops.nanany(s) False F)r} ra )r� r r� r) rI )rH r^ r_ ra �_r/ r/ r0 �nanany� s " r� c C s6 t | |d|d�\} }}}}t| �r,| �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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, 2, np.nan]) >>> nanops.nanall(s) True >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, 0]) >>> nanops.nanall(s) False T)r} ra )r� r r� r) �all)rH r^ r_ ra r� r/ r/ r0 �nanall� s " r� ZM8)r^ r_ r` ra �int�float)rH r^ r_ r` ra r, c C s` t | |d|d�\} }}}}|}t|�r,|}nt|�r: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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, 2, np.nan]) >>> nanops.nansum(s) 3.0 r )r} ra )r5 )r` )r� r r rM r� �sum�_maybe_null_outr� ) rH r^ r_ r` ra r5 r� r� � dtype_sum�the_sumr/ r/ r0 rt # s !rt z+np.ndarray | np.datetime64 | np.timedelta64z5np.ndarray | np.datetime64 | np.timedelta64 | NaTType)rl r^ ra r� r, c C sD t | tj�r4| �d��|j�} |j|d�}t| |< n |�� r@tS | S )Nr� )r^ ) rx rM ry r� r� r5 rI r r )rl r^ ra r� Z axis_maskr/ r/ r0 r� U 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 | dd�r�t tj | �} tjdd �� | | } W dQ 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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, 2, np.nan]) >>> nanops.nanmean(s) 1.5 r )r} ra )r� r� )r5 Nr� FrD )r� )r� rM r5 r� r� r r � _get_countsr� �_ensure_numericr� ro r ry rN rI rB ) rH r^ r_ ra r5 r� r� r� Z dtype_count�countr� Zthe_meanZct_maskr/ r/ r0 �nanmeanh s, " r� c s � fdd�}t | � |d�\} }}}}t| j�s�y| �d�} W n0 tk rl } ztt|��|�W dd}~X Y nX |dk r�tj| |< |dkr�| � d�} | j }| j dkr�|r� s�t� ||| �} q�t �� � t �dd � t�| |�} W dQ 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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, np.nan, 2, 2]) >>> nanops.nanmedian(s) 2.0 c sL t | �}� s|�� stjS t�� � t�dd� t�| | �}W d Q R X |S )NrD zAll-NaN slice encountered)r% r� rM rB �warnings�catch_warnings�filterwarnings� nanmedian)�xra �res)r_ r/ r0 � get_median� s z nanmedian.<locals>.get_median)ra rv Nrw r� rD zAll-NaN slice encountered)r� r r5 r� rO rL rs rM rB rz rd r� Zapply_along_axisr� r� r� r� �get_empty_reduction_resultr� Zfloat_r� ) rH r^ r_ ra r� r5 r� �errZnotemptyr� r/ )r_ r0 r� � s, r� ztuple[int, ...]z np.dtype | type[np.floating])r� r^ r5 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 )r5 )rM �arrayZarangerb �empty�fill)r� r^ r5 r} ZshpZdims�retr/ r/ r0 r� � s r� r r z)tuple[int | np.ndarray, int | np.ndarray])� values_shapera r^ �ddofr5 r, c C s| t |�}t| |||d�}||�|� }t|�rD||krttj}tj}n0||k}|�� rtt�||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 : scalar or array d : scalar or array )r5 )r r� r3 r rM rB rI r� )r� ra r^ r� r5 r� �dZmask2r/ r/ r0 �_get_counts_nanvar s r� r� )r� )r^ r_ r� ra 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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, np.nan, 2, 3]) >>> nanops.nanstd(s) 1.0 zM8[ns]zm8[ns])ra )r^ r_ r� ra )r5 r� r� rM �sqrt�nanvarr� )rH r^ r_ r� ra � orig_dtyper� rl r/ r/ r0 �nanstdF s r� Zm8c C s t | dd�} | j}t| ||�}t|�rB| �d�} |dk rBtj| |< t| j�rft| 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| �|�} | 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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, np.nan, 2, 3]) >>> nanops.nanvar(s) 1.0 T)r� rv Nr )r^ r5 � )r& r5 r� r r� rM rB r r� r� r� r� r� r� r� � expand_dims) rH r^ r_ r� ra r5 r� r� �avgZsqrrl r/ r/ r0 r� m s. r� )rH r^ r_ r� ra r, c C sn t | ||||d� t| ||�}t| j�s2| �d�} 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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, np.nan, 2, 3]) >>> nanops.nansem(s) 0.5773502691896258 )r^ r_ r� ra rv )r^ r_ r� ) r� r� r r5 r� r� r� rM r� )rH r^ r_ r� ra r� r� �varr/ r/ r0 �nansem� s & r� c s< t d� d�td dd d�ddddd d �� �fd d ���}|S ) NrB )r\ T)r^ r_ ra z np.ndarrayz int | Noner) znp.ndarray | Noner )rH r^ r_ ra r, c s� t | |� |d�\} }}}}|d k r0| j| dks:| jdkr�y"t| ��||d�}|�tj� W q� ttt fk r| tj}Y q�X nt| ��|�}t |||| j�}|S )N)r� ra r )r5 ) r� r� rd ro r� rM rB rq rL rO r� )rH r^ r_ ra r5 r� r} rl )r� �methr/ r0 � reduction� s z _nanminmax.<locals>.reduction)r[ r� )r� r� r� r/ )r� r� r0 � _nanminmax� s &r� �minz+inf)r� �maxz-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 -------- >>> import pandas.core.nanops as 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]) Tz-inf)r� ra )r� Zargmax�_maybe_arg_null_out)rH r^ r_ ra r� rl r/ r/ r0 � nanargmax 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 -------- >>> import pandas.core.nanops as 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]) Tz+inf)r� ra )r� Zargminr� )rH r^ r_ ra r� rl r/ r/ r0 � nanargmin4 s ' r� c C s� t | dd�} t| ||�}t| j�s<| �d�} t| j||�}nt| j||| jd�}|rr|dk rr| �� } t� | |d� | 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 dQ R X | j} t| ��rT| �| �} t| tj��r�t�| dkd| �} tj| |d k < n"| dk�r�dn| } |d k �r�tjS | 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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, np.nan, 1, 2]) >>> nanops.nanskew(s) 1.7320508075688787 T)r� rv )r5 Nr r� rD )rE �divider� g �?g �?� )r& r� r r5 r� r� r� r� rM r� r� r� r� �_zero_out_fperrrN rx ry r� rB ) rH r^ r_ ra r� �mean�adjusted� adjusted2Z adjusted3�m2Zm3rl r5 r/ r/ r0 �nanskewb sB & . r� c C s t | dd�} t| ||�}t| j�s<| �d�} t| j||�}nt| j||| jd�}|rr|dk rr| �� } t� | |d� | j |tj d�| }|dk r�t� ||�}| | }|r�|dk r�t� ||d� |d }|d }|j |tj d�} |j |tj d�} tj ddd ��V d |d d |d |d } ||d |d | } |d |d | d } W dQ R X t| �} t| �} t| tj��s�|d k �r�tjS | dk�r�dS tj ddd �� | | | }W dQ R X | j}t|��r�|�|�}t|tj��r 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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, np.nan, 1, 3, 2]) >>> nanops.nankurt(s) -1.2892561983471076 T)r� rv )r5 Nr r� rD )rE r� r� r� � )r& r� r r5 r� r� r� r� rM r� r� r� r� rN r� rx ry rB r� )rH r^ r_ ra r� r� r� r� Z adjusted4r� Zm4Zadj� numerator� denominatorrl r5 r/ r/ r0 �nankurt� sN & " r� c C sF t | ||�}|r(|dk r(| �� } d| |< | �|�}t|||| j|d�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 -------- >>> import pandas.core.nanops as nanops >>> s = pd.Series([1, 2, 3, np.nan]) >>> nanops.nanprod(s) 6.0 Nr� )r` )r� r� �prodr� r� )rH r^ r_ r` ra rl r/ r/ r0 ru s ru znp.ndarray | int)rl r^ ra r_ r, c C sn |d kr | S |d ks t | dd�s@|r2|�� r>d} qj|�� rjd} n*|rP|�|�}n |�|�}|�� rjd| |< | S )Nr� F���)ro r� rI )rl r^ ra r_ Zna_maskr/ r/ r0 r� E s r� zint | float | np.ndarray)r� ra r^ r5 r, c C s� t |�}|dkr<|dk r(|j|�� }n t�| �}|�|�S |dk rZ|j| |�|� }n| | }t|�rt|�|�S y |�|�S t k r� tj ||d�S X 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 N)r5 ) r rd r� rM r� r3 r� r r� rq r� )r� ra r^ r5 �nr� r/ r/ r0 r� a s r� z np.ndarray | float | NaTType)rl r^ ra r� r` r, c C s� |dk r�t | tj�r�|dk r:|j| |�|� | dk }n8|| | dk }|d|� ||d d� }t�||�}t�|�r�t| �r�t�| �r�| � d�} n | � d�} tj | |< q�d| |< n| t k r�t |||�r�tj } | S )zu Returns ------- Dtype The product of all elements on a given axis. ( NaNs are treated as 1) Nr r� Zc16rv ) rx rM ry r� r� Z broadcast_torI r Z iscomplexobjr� rB r �check_below_min_count)rl r^ ra r� r` Z null_maskZ below_countZ new_shaper/ r/ r0 r� � s" r� )r� ra r` 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 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)rM r� rd r� )r� ra r` Z non_nullsr/ r/ r0 r� � s r� c C s\ t | tj�r:tjdd�� t�t�| �dk d| �S Q R X n t�| �dk rT| j�d�S | S d S )NrD )rE g�+����=r )rx rM ry rN r� �absr5 r3 )�argr/ r/ r0 r� � s r� �pearson)�method� min_periods)�a�br� 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� )rb r� r% r� rM rB � get_corr_func)r� r� r� r� �validrA r/ r/ r0 �nancorr� s 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 r/ )r� r� )r� r/ r0 r� � s zget_corr_func.<locals>.funcZspearman)� spearmanrc s � | |�d S )Nr r/ )r� r� )r� r/ r0 r� s r� c S s t �| |�d S )N)r r� )rM Zcorrcoef)r� r� r/ r/ r0 r� s zUnknown method 'z@', expected one of 'kendall', 'spearman', 'pearson', or callable)Z scipy.statsr� r� �callablerO )r� r� r/ )r� r� r0 r� � s r� )r� r� )r� r� r� r� c C sr t | �t |�krtd��|d kr$d}t| �t|�@ }|�� sL| | } || }t | �|k r^tjS tj| ||d�d S )Nz&Operands to nancov must have same sizer� )r� )r r� )rb r� r% r� rM rB Zcov)r� r� r� r� r� r/ r/ r0 �nancov s r� c C sH t | tj�r�t| �s t| �r*| �tj�} n�t| �r�y| �tj�} W n^ t t fk r� y| �tj�} W n4 t k r� } zt d| � d��|�W d d }~X Y nX Y nX t� t� | ��s�| j } n�t| ��sDt| ��sDt| ��sDy t| �} W n^ t t fk �rB y t| �} W n6 t k �r< } zt d| � d��|�W d d }~X Y nX Y nX | S )NzCould not convert z to numeric)rx rM ry r r r� r� r Z complex128rL rO rI �imag�realr r r r� �complex)r� r� r/ r/ r0 r� 1 s, * *r� c s � fdd�}|S )Nc sh t | �}t |�}||B }tjdd�� � | |�}W d Q R X |�� rdt|�rT|�d�}t�||tj� |S )NrD )r� r� )r# rM rN rI r r� r� rB )r� �yZxmaskZymaskra rl )�opr/ r0 rA R s zmake_nancomp.<locals>.fr/ )r� rA r/ )r� r0 � make_nancompQ s r� r )rH ra �q�na_valuer, c C sD | | } t | �dkr0tj|gt |� | jd�S tj| |ft|i�S )a� Wrapper for np.percentile that skips missing values, specialized to 1-dimensional case. Parameters ---------- values : array over which to find quantiles mask : ndarray[bool] locations in values that should be considered missing q : np.ndarray[float64] of quantile indices to find na_value : scalar value to return for empty or all-null values interpolation : str Returns ------- quantiles : scalar or array r )r5 )rb rM r� r5 � percentiler )rH ra r� r� � interpolationr/ r/ r0 �_nanpercentile_1dl s r� )rH r� ra c s� | j jdkr6t| �d����d�|� d�}|�| j �S t�|�s�|�� r�|j| jksXt �� ��fdd�t t | �t |��D �}t j || j dd�j}|S t j| �fdd it� i��S d S ) a� Wrapper for np.percentile that skips missing values. Parameters ---------- values : np.ndarray[ndim=2] over which to find quantiles q : np.ndarray[float64] of quantile indices to find na_value : scalar value to return for empty or all-null values mask : ndarray[bool] locations in values that should be considered missing interpolation : str Returns ------- quantiles : scalar or array )r� r� r� )r� r� ra r� c s" g | ]\}}t ||��� d ��qS ))r� )r� )r4 �valr� )r� r� r� r/ r0 � <listcomp>� s z!nanpercentile.<locals>.<listcomp>F)r5 r� r^ r� N)r5 r� � nanpercentiler� r� r r rI r� r� �zip�listrM r� �Tr� r )rH r� r� ra r� rl r/ )r� r� r� r0 r� � s r� r )rH r_ r, c C s� t jdt jft jjt j t jft jdt jft jjt jt jfi| \}}| jj dk�r@| j}t | �}|t jjkr�| � d�}t j ||< d}n| }d}||� d�dd�} |r�t| |< n8|t jjkr�t �|� �� d } t| �r�t| d | d �< |r�t||< t| jt j��r| � |�} n.t|t j��r"|nd } t| �j| � | �|d �} nX|�r�t| jjt jt jf��s�| �� } 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� TFr )r^ NzM8[ns])r5 )rM ZcumprodrB �maximum� accumulater Zcumsum�minimumr5 r� r# r� r r� r r� Znonzerorb rx r3 Z _simple_newr> r� Zbool_r� ) rH Z accum_funcr_ Zmask_aZmask_br� ra r� �changedrl ZnzZnpdtype�valsr/ r/ r0 � na_accum_func� sH r )T)NN)NNN)N)r� )r� __future__r rU rF �operator�typingr r r� �numpyrM Zpandas._configr Z pandas._libsr r r r r Zpandas._typingr r r r r r Zpandas.compat._optionalr Zpandas.compat.numpyr Zpandas.core.dtypes.commonr r 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& rp r- r. r1 r2 r[ rg ri r� r� r� r~ r� r� rf r� r� rt r� r� r� r� r� r� r� r� r� r� ZnanminZnanmaxr� r� r� r� ru r� r� r� r� r� r� r� r� r� r� �gtZnangt�geZnange�ltZnanlt�leZnanle�eqZnaneq�neZnanner� r� r r/ r/ r/ r0 �<module> s� D 8/ T%"" , )"*":M .&C + ( ( Q Z % 2" 7
| ver. 1.4 |
Github
|
.
| PHP 8.3.23 | Генерация страницы: 0.06 |
proxy
|
phpinfo
|
Настройка