Ë
|
nñúhv ã óð d dl mZ d dlZd dlmZ d dlmZ d dlmZ d dl Z
|
d dl m Z d dl mc mc mZ d dlmZ d dlmZmZ d d lmZ d d
|
lmZ d d lm Z d d l m Z d d l m Z d dl!m"Z"m#Z#m$Z$ d dl%m&Z&m'Z' d dl(m)Z) d dl*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2 d dl3m4Z4m5Z5 d dl6m7Z7m8Z8 d dl9m:Z:m;Z; erd dl<m=Z=m>Z>m?Z? d dl@mAZAmBZB d dlCmDZD d dZE d!dZF G d de:« ZG G d d e;eG« ZH G d d eG« ZIy)"é )Ú annotationsN)Úpartial)Údedent)Ú TYPE_CHECKING)Ú Timedelta)Údoc)Úis_datetime64_dtypeÚis_numeric_dtype)ÚDatetimeTZDtype)Ú ABCSeries)Úisna)Úcommon)Ú dtype_to_unit)Ú BaseIndexerÚ ExponentialMovingWindowIndexerÚGroupbyIndexer)Úget_jit_argumentsÚmaybe_use_numba)Úzsqrt)Ú _shared_docsÚcreate_section_headerÚkwargs_numeric_onlyÚ numba_notesÚtemplate_headerÚtemplate_returnsÚtemplate_see_alsoÚwindow_agg_numba_parameters)Úgenerate_numba_ewm_funcÚ generate_numba_ewm_table_func)Ú EWMMeanStateÚ generate_online_numba_ewma_func)Ú
|
BaseWindowÚBaseWindowGroupby)ÚAxisÚTimedeltaConvertibleTypesÚnpt)Ú DataFrameÚSeries)ÚNDFramec óæ t j | |||« }|dkD r t d« | | dk r¸t d« |#|dk r t d« |dz
|
dz } t | « S |Q|dk r t d« dt j t j
|
d« |z « z
|
}d|z dz
|
} t | « S |(|dk s|dkD r t d « d|z
|
|z } t | « S t d
|
« t | « S ) Né z8comass, span, halflife, and alpha are mutually exclusiver z comass must satisfy: comass >= 0z span must satisfy: span >= 1é z#halflife must satisfy: halflife > 0g à?z"alpha must satisfy: 0 < alpha <= 1z1Must pass one of comass, span, halflife, or alpha)r Úcount_not_noneÚ
|
ValueErrorÚnpÚexpÚlogÚfloat)ÚcomassÚspanÚhalflifeÚalphaÚ valid_countÚdecays úIH:\Change_password\venv_build\Lib\site-packages\pandas/core/window/ewm.pyÚget_center_of_massr: G s! ô ×'Ñ'¨°°hÀÓFKØQÜÐSÓTÐTð ÐØ A:Ü Ð ?Ó@Ð @Ø Ð Ø !8Ü Ð ;Ó<Ð <Ø(a ô =Ðð
|
Ð Ø q=Ü Ð BÓCÐ CØBFF266 #;¨Ñ1Ó2Ñ2ØUQ ô =Ðð
|
Ð Ø A: Ü Ð AÓBÐ BØe)uÑ$ô =Ðô ÐLÓMÐMä =Ðó c ór t | j « }t | t « r | j } t j | j t
|
j « t
|
j ¬« }t t |« j |« j « }t j |« |z S )aå
|
Return the diff of the times divided by the half-life. These values are used in
|
the calculation of the ewm mean.
|
|
Parameters
|
----------
|
times : np.ndarray, Series
|
Times corresponding to the observations. Must be monotonically increasing
|
and ``datetime64[ns]`` dtype.
|
halflife : float, str, timedelta, optional
|
Half-life specifying the decay
|
|
Returns
|
-------
|
np.ndarray
|
Diff of the times divided by the half-life
|
©Údtype)r r> Ú
|
isinstancer Ú_valuesr/ ÚasarrayÚviewÚint64Úfloat64r2 r Úas_unitÚ_valueÚdiff)Útimesr5 ÚunitÚ_timesÚ _halflifes r9 Ú_calculate_deltasrL h sy ô* Ó %DÜ%Ô#Ø Ü ZZ
|
|
¤2§8¡8Ó,´B·J±JÔ ?FÜi Ó)×1Ñ1°$Ó7×>Ñ>Ó?IÜ 776?YÑ &Ð&r; c óR e Zd ZdZg d¢Z d2dd d3 fdZ d4dZd5dZ d6 d7dZ e e
|
d e d
|
« e d « d d ¬« fd« Z e Z e e ed« e e« ed« e ed« e ed« e ed« e d« ddd¬« d8 d9d« Z e e ed« e e« ed« e ed« e ed« e ed« e d« dd d ¬« d8 d9d « Z e e ed« e d « e ed« e ed« e ed« e d « dd!d"¬« d:d;d#« Z e e ed« e d « e ed« e ed« e ed« e d$« dd%d&¬« d:d;d'« Z e e ed« e d(« e ed« e ed« e ed« e d)« dd*d+¬« d< d=d,« Z e e ed« e d-« e ed« e ed« e ed« e d.« dd/d0¬« d> d?d1« Z xZS )@ÚExponentialMovingWindowaé
|
Provide exponentially weighted (EW) calculations.
|
|
Exactly one of ``com``, ``span``, ``halflife``, or ``alpha`` must be
|
provided if ``times`` is not provided. If ``times`` is provided,
|
``halflife`` and one of ``com``, ``span`` or ``alpha`` may be provided.
|
|
Parameters
|
----------
|
com : float, optional
|
Specify decay in terms of center of mass
|
|
:math:`\alpha = 1 / (1 + com)`, for :math:`com \geq 0`.
|
|
span : float, optional
|
Specify decay in terms of span
|
|
:math:`\alpha = 2 / (span + 1)`, for :math:`span \geq 1`.
|
|
halflife : float, str, timedelta, optional
|
Specify decay in terms of half-life
|
|
:math:`\alpha = 1 - \exp\left(-\ln(2) / halflife\right)`, for
|
:math:`halflife > 0`.
|
|
If ``times`` is specified, a timedelta convertible unit over which an
|
observation decays to half its value. Only applicable to ``mean()``,
|
and halflife value will not apply to the other functions.
|
|
alpha : float, optional
|
Specify smoothing factor :math:`\alpha` directly
|
|
:math:`0 < \alpha \leq 1`.
|
|
min_periods : int, default 0
|
Minimum number of observations in window required to have a value;
|
otherwise, result is ``np.nan``.
|
|
adjust : bool, default True
|
Divide by decaying adjustment factor in beginning periods to account
|
for imbalance in relative weightings (viewing EWMA as a moving average).
|
|
- When ``adjust=True`` (default), the EW function is calculated using weights
|
:math:`w_i = (1 - \alpha)^i`. For example, the EW moving average of the series
|
[:math:`x_0, x_1, ..., x_t`] would be:
|
|
.. math::
|
y_t = \frac{x_t + (1 - \alpha)x_{t-1} + (1 - \alpha)^2 x_{t-2} + ... + (1 -
|
\alpha)^t x_0}{1 + (1 - \alpha) + (1 - \alpha)^2 + ... + (1 - \alpha)^t}
|
|
- When ``adjust=False``, the exponentially weighted function is calculated
|
recursively:
|
|
.. math::
|
\begin{split}
|
y_0 &= x_0\\
|
y_t &= (1 - \alpha) y_{t-1} + \alpha x_t,
|
\end{split}
|
ignore_na : bool, default False
|
Ignore missing values when calculating weights.
|
|
- When ``ignore_na=False`` (default), weights are based on absolute positions.
|
For example, the weights of :math:`x_0` and :math:`x_2` used in calculating
|
the final weighted average of [:math:`x_0`, None, :math:`x_2`] are
|
:math:`(1-\alpha)^2` and :math:`1` if ``adjust=True``, and
|
:math:`(1-\alpha)^2` and :math:`\alpha` if ``adjust=False``.
|
|
- When ``ignore_na=True``, weights are based
|
on relative positions. For example, the weights of :math:`x_0` and :math:`x_2`
|
used in calculating the final weighted average of
|
[:math:`x_0`, None, :math:`x_2`] are :math:`1-\alpha` and :math:`1` if
|
``adjust=True``, and :math:`1-\alpha` and :math:`\alpha` if ``adjust=False``.
|
|
axis : {0, 1}, default 0
|
If ``0`` or ``'index'``, calculate across the rows.
|
|
If ``1`` or ``'columns'``, calculate across the columns.
|
|
For `Series` this parameter is unused and defaults to 0.
|
|
times : np.ndarray, Series, default None
|
|
Only applicable to ``mean()``.
|
|
Times corresponding to the observations. Must be monotonically increasing and
|
``datetime64[ns]`` dtype.
|
|
If 1-D array like, a sequence with the same shape as the observations.
|
|
method : str {'single', 'table'}, default 'single'
|
.. versionadded:: 1.4.0
|
|
Execute the rolling operation per single column or row (``'single'``)
|
or over the entire object (``'table'``).
|
|
This argument is only implemented when specifying ``engine='numba'``
|
in the method call.
|
|
Only applicable to ``mean()``
|
|
Returns
|
-------
|
pandas.api.typing.ExponentialMovingWindow
|
|
See Also
|
--------
|
rolling : Provides rolling window calculations.
|
expanding : Provides expanding transformations.
|
|
Notes
|
-----
|
See :ref:`Windowing Operations <window.exponentially_weighted>`
|
for further usage details and examples.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]})
|
>>> df
|
B
|
0 0.0
|
1 1.0
|
2 2.0
|
3 NaN
|
4 4.0
|
|
>>> df.ewm(com=0.5).mean()
|
B
|
0 0.000000
|
1 0.750000
|
2 1.615385
|
3 1.615385
|
4 3.670213
|
>>> df.ewm(alpha=2 / 3).mean()
|
B
|
0 0.000000
|
1 0.750000
|
2 1.615385
|
3 1.615385
|
4 3.670213
|
|
**adjust**
|
|
>>> df.ewm(com=0.5, adjust=True).mean()
|
B
|
0 0.000000
|
1 0.750000
|
2 1.615385
|
3 1.615385
|
4 3.670213
|
>>> df.ewm(com=0.5, adjust=False).mean()
|
B
|
0 0.000000
|
1 0.666667
|
2 1.555556
|
3 1.555556
|
4 3.650794
|
|
**ignore_na**
|
|
>>> df.ewm(com=0.5, ignore_na=True).mean()
|
B
|
0 0.000000
|
1 0.750000
|
2 1.615385
|
3 1.615385
|
4 3.225000
|
>>> df.ewm(com=0.5, ignore_na=False).mean()
|
B
|
0 0.000000
|
1 0.750000
|
2 1.615385
|
3 1.615385
|
4 3.670213
|
|
**times**
|
|
Exponentially weighted mean with weights calculated with a timedelta ``halflife``
|
relative to ``times``.
|
|
>>> times = ['2020-01-01', '2020-01-03', '2020-01-10', '2020-01-15', '2020-01-17']
|
>>> df.ewm(halflife='4 days', times=pd.DatetimeIndex(times)).mean()
|
B
|
0 0.000000
|
1 0.585786
|
2 1.523889
|
3 1.523889
|
4 3.233686
|
)
|
Úcomr4 r5 r6 Ú min_periodsÚadjustÚ ignore_naÚaxisrH ÚmethodN©Ú selectionc
|
ó¶ t | ||dnt t |« d« d dd | | | ¬« || _ || _ || _ || _ || _ || _ |
|
| _
|
| j | j s t d« t | j dd « } t | « st | t « s t! d« t# | j « t# |« k7 r t! d« t | j t$ t& j( t* j, f« s t! d« t/ | j « j1 « r t! d « t3 | j | j « | _ t7 j8 | j | j
|
| j « d
|
kD r2t; | j | j
|
d | j « | _ y d | _ y | j Dt | j t$ t& j( t* j, f« r t! d « t+ j> t | j@ jB | jD dz
|
d
|
« t* jF ¬ « | _ t; | j | j
|
| j | j « | _ y )Nr+ F)ÚobjrP ÚonÚcenterÚclosedrT rS rV z)times is not supported with adjust=False.r> z times must be datetime64 dtype.z,times must be the same length as the object.z/halflife must be a timedelta convertible objectz$Cannot convert NaT values to integerr g ð?zKhalflife can only be a timedelta convertible argument if times is not None.r= )$ÚsuperÚ__init__ÚmaxÚintrO r4 r5 r6 rQ rR rH ÚNotImplementedErrorÚgetattrr r? r r. ÚlenÚstrÚdatetimeÚ timedeltar/ Ú timedelta64r ÚanyrL Ú_deltasr r- r: Ú_comÚonesrX ÚshaperS rD )ÚselfrX rO r4 r5 r6 rP rQ rR rS rH rT rV Ú times_dtypeÚ __class__s r9 r] z ExponentialMovingWindow.__init__P s1 ø ô ÑØØ (Ð 0´c¼#¸kÓ:JÈAÓ6NØØØØØØ ð ô
|
ð Ø Ø Ø
|
Ø Ø"Ø
|
Ø ::Ñ !Ø;;Ü)Ð*UÓVÐVÜ! $§*¡*¨g°tÓ<Kä# KÔ0Ü k¬?Ô;ä Ð!BÓCÐCÜ4::¤# c£(Ò*Ü Ð!OÓPÐPÜ dmm¬c´8×3EÑ3EÄrÇ~Á~Ð-VÔWÜ Ð!RÓSÐSÜDJJÓ ×#Ñ#Ô%Ü Ð!GÓHÐHÜ,¨T¯Z©Z¸¿ ¹ ÓGDLô ×$Ñ$ T§X¡X¨t¯y©y¸$¿*¹*ÓEÈÒIÜ .¨t¯x©x¸¿¹ÀDÈ$Ï*É*Ó U à à}}Ð(¬ZØ ¤¤X×%7Ñ%7¼¿ ¹ Ð Hô.ô !ð)óð ô
|
77ÜDHHNN 4§9¡9Ñ-°Ñ1°1Ó5¼R¿Z¹Zô DLô +ð Ø Ø Ø
|
|
óDIr; c ó y ©N© )rl ÚstartÚendÚnum_valss r9 Ú_check_window_boundsz,ExponentialMovingWindow._check_window_bounds s ð
|
r; c ó t « S )z[
|
Return an indexer class that will compute the window start and end bounds
|
)r ©rl s r9 Ú_get_window_indexerz+ExponentialMovingWindow._get_window_indexer¤ s ô .Ó/Ð/r; c ó t | j | j | j | j | j
|
| j | j | j | j | j ||| j ¬« S )aª
|
Return an ``OnlineExponentialMovingWindow`` object to calculate
|
exponentially moving window aggregations in an online method.
|
|
.. versionadded:: 1.3.0
|
|
Parameters
|
----------
|
engine: str, default ``'numba'``
|
Execution engine to calculate online aggregations.
|
Applies to all supported aggregation methods.
|
|
engine_kwargs : dict, default None
|
Applies to all supported aggregation methods.
|
|
* For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil``
|
and ``parallel`` dictionary keys. The values must either be ``True`` or
|
``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is
|
``{{'nopython': True, 'nogil': False, 'parallel': False}}`` and will be
|
applied to the function
|
|
Returns
|
-------
|
OnlineExponentialMovingWindow
|
) rX rO r4 r5 r6 rP rQ rR rS rH ÚengineÚ engine_kwargsrV ) Ú OnlineExponentialMovingWindowrX rO r4 r5 r6 rP rQ rR rS rH Ú
|
_selection)rl rz r{ s r9 Úonlinez ExponentialMovingWindow.onlineª sf ô8 -ØØØØ]]Ø**Ø ×(Ñ(Ø;;ØnnØØ**ØØ'Øooô
|
ð
|
r; Ú aggregatezV
|
See Also
|
--------
|
pandas.DataFrame.rolling.aggregate
|
a
|
Examples
|
--------
|
>>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6], "C": [7, 8, 9]})
|
>>> df
|
A B C
|
0 1 4 7
|
1 2 5 8
|
2 3 6 9
|
|
>>> df.ewm(alpha=0.5).mean()
|
A B C
|
0 1.000000 4.000000 7.000000
|
1 1.666667 4.666667 7.666667
|
2 2.428571 5.428571 8.428571
|
zSeries/DataframeÚ )Úsee_alsoÚexamplesÚklassrS c ó* t | |g|¢i |¤S rp )r\ r )rl ÚfuncÚargsÚkwargsrn s r9 r z!ExponentialMovingWindow.aggregateÖ s ø ô> wÑ Ð7¨Ò7°Ñ7Ð7r; Ú
|
ParametersÚReturnszSee AlsoÚNotesÚExampleszÆ >>> ser = pd.Series([1, 2, 3, 4])
|
>>> ser.ewm(alpha=.2).mean()
|
0 1.000000
|
1 1.555556
|
2 2.147541
|
3 2.775068
|
dtype: float64
|
Úewmz"(exponential weighted moment) meanÚmean)Ú window_methodÚaggregation_descriptionÚ
|
agg_methodc
|
ó t |« ry| j dk( rt }nt } |d
|
i t |« ¤| j
|
| j | j t | j « dd¤}| j |d¬« S |dv rx| t d« | j d n | j }t t j | j
|
| j | j |d¬« }| j |d|¬« S t d « ) NÚsingleT©rO rQ rR ÚdeltasÚ normalizer ©Úname©ÚcythonNú+cython engine does not accept engine_kwargs©r Ú numeric_onlyú)engine must be either 'numba' or 'cython'rq )r rT r r r ri rQ rR Útuplerh Ú_applyr. rH r Úwindow_aggregationsr ©rl r rz r{ r
Úewm_funcr Ú window_funcs r9 r z ExponentialMovingWindow.meanù sø ôB 6Ô "Ø{{hÒ&Ü.ä4Ùñ Ü# MÓ2ðàIIØ{{Ø ..Ü T\\Ó*Ø ó Hð ;;x¨f;Ó5Ð 5Ø Ð'Ñ 'Ø Ð(Ü Ð!NÓOÐOà !ZZÐ /T°T·\±\FÜ!Ü#×'Ñ'ØIIØ{{Ø ..Ø Ø ô Kð ;;{°Àl;ÓSÐ Sä Ð HÓIÐ Ir; z¹ >>> ser = pd.Series([1, 2, 3, 4])
|
>>> ser.ewm(alpha=.2).sum()
|
0 1.000
|
1 2.800
|
2 5.240
|
3 8.192
|
dtype: float64
|
z!(exponential weighted moment) sumÚsumc
|
óF | j s t d« t |« ry| j dk( rt }nt
|
} |d i t |« ¤| j | j | j t | j « dd¤}| j |d¬« S |dv rx| t d« | j d n | j }t t j | j | j | j |d¬« }| j |d|¬ « S t d
|
« ) Nz(sum is not implemented with adjust=Falser Fr r¤ r r r r r rq )rQ r` r rT r r r ri rR r rh r r. rH r r r r¡ s r9 r¤ zExponentialMovingWindow.sum9 s ðB {{Ü%Ð&PÓQÐ QÜ 6Ô "Ø{{hÒ&Ü.ä4Ùñ Ü# MÓ2ðàIIØ{{Ø ..Ü T\\Ó*Ø ó Hð ;;x¨e;Ó4Ð 4Ø Ð'Ñ 'Ø Ð(Ü Ð!NÓOÐOà !ZZÐ /T°T·\±\FÜ!Ü#×'Ñ'ØIIØ{{Ø ..Ø Ø ô Kð ;;{°À\;ÓRÐ Rä Ð HÓIÐ Ir; zb bias : bool, default False
|
Use a standard estimation bias correction.
|
zÅ >>> ser = pd.Series([1, 2, 3, 4])
|
>>> ser.ewm(alpha=.2).std()
|
0 NaN
|
1 0.707107
|
2 0.995893
|
3 1.277320
|
dtype: float64
|
z0(exponential weighted moment) standard deviationÚstdc óð |rY| j j dk( r@t | j j « s!t t | « j d« t | j ||¬« « S )Nr+ z$.std does not implement numeric_only)Úbiasr ) Ú _selected_objÚndimr
|
r> r` ÚtypeÚ__name__r Úvar©rl r¨ r s r9 r¦ zExponentialMovingWindow.std{ so ñ@ Ø×"Ñ"×'Ñ'¨1Ò,Ü$ T×%7Ñ%7×%=Ñ%=Ô>ô &Ü:×&Ñ&Ð'Ð'KÐLóð ô TXX 4°lXÓCÓDÐDr; zÅ >>> ser = pd.Series([1, 2, 3, 4])
|
>>> ser.ewm(alpha=.2).var()
|
0 NaN
|
1 0.500000
|
2 0.991803
|
3 1.631547
|
dtype: float64
|
z&(exponential weighted moment) variancer c ó² t j }t || j | j | j
|
|¬« fd}| j |d|¬« S )N)rO rQ rR r¨ c ó | |||| « S rp rq )ÚvaluesÚbeginrs rP Úwfuncs r9 Úvar_funcz-ExponentialMovingWindow.var.<locals>.var_funcÍ s ø Ù ¨¨[¸&ÓAÐ Ar; r r )r Úewmcovr ri rQ rR r )rl r¨ r r£ r´ r³ s @r9 r zExponentialMovingWindow.var¥ sR ø ô> *×0Ñ0 ÜØ Ø Ø;;ØnnØô
|
ô Bð {{8¨%¸l{ÓKÐKr; a¦ other : Series or DataFrame , optional
|
If not supplied then will default to self and produce pairwise
|
output.
|
pairwise : bool, default None
|
If False then only matching columns between self and other will be
|
used and the output will be a DataFrame.
|
If True then all pairwise combinations will be calculated and the
|
output will be a MultiIndex DataFrame in the case of DataFrame
|
inputs. In the case of missing elements, only complete pairwise
|
observations will be used.
|
bias : bool, default False
|
Use a standard estimation bias correction.
|
zú >>> ser1 = pd.Series([1, 2, 3, 4])
|
>>> ser2 = pd.Series([10, 11, 13, 16])
|
>>> ser1.ewm(alpha=.2).cov(ser2)
|
0 NaN
|
1 0.500000
|
2 1.524590
|
3 3.408836
|
dtype: float64
|
z/(exponential weighted moment) sample covarianceÚcovc ó ddl m j d|« fd} j j ||||« S )Nr ©r( r¶ c óú j | « } j |« } j « } j j n |j }|j t |« | j j j ¬« \ }}t j ||| j | j j j
|
« } || j | j d¬« S )N©Ú
|
num_valuesrP rZ r[ ÚstepF©Úindexr Úcopy)Ú _prep_valuesrx rP Ú window_sizeÚget_window_boundsrb rZ r[ r¼ r rµ ri rQ rR r¾ r ) ÚxÚyÚx_arrayÚy_arrayÚwindow_indexerrP rr rs Úresultr( r¨ rl s r9 Úcov_funcz-ExponentialMovingWindow.cov.<locals>.cov_func sî ø Ø×'Ñ'¨Ó*GØ×'Ñ'¨Ó*GØ !× 5Ñ 5Ó 7Nð ×#Ñ#Ð/ð × Ò à#×/Ñ/ð ð
|
(×9Ñ9Ü w<Ø 'Ø{{Ø{{ØYYð :ó JE3ô )×/Ñ/ØØØð × Ñ ØØ Ø ØØó Fñ &¨¯©°a·f±fÀ5ÔIÐ Ir; ©Úpandasr( Ú_validate_numeric_onlyÚ_apply_pairwiser© )rl ÚotherÚpairwiser¨ r rÉ r( s ` ` @r9 r¶ zExponentialMovingWindow.covÒ sE ú õ` "à ×#Ñ# E¨<Ô8ö Jð> ×#Ñ#Ø × Ñ x°¸<ó
|
ð
|
r; aK other : Series or DataFrame, optional
|
If not supplied then will default to self and produce pairwise
|
output.
|
pairwise : bool, default None
|
If False then only matching columns between self and other will be
|
used and the output will be a DataFrame.
|
If True then all pairwise combinations will be calculated and the
|
output will be a MultiIndex DataFrame in the case of DataFrame
|
inputs. In the case of missing elements, only complete pairwise
|
observations will be used.
|
zû >>> ser1 = pd.Series([1, 2, 3, 4])
|
>>> ser2 = pd.Series([10, 11, 13, 16])
|
>>> ser1.ewm(alpha=.2).corr(ser2)
|
0 NaN
|
1 1.000000
|
2 0.982821
|
3 0.977802
|
dtype: float64
|
z0(exponential weighted moment) sample correlationÚcorrc ó ddl m j d|« fd} j j ||||« S )Nr r¸ rÐ c ó4
|
j | « }j |« }j « }j j n |j |j t |« j j j ¬« \
|
|
fd}t j d¬« 5 |||« } |||« } |||« }|t ||z « z } d d d « | j | j d¬« S # 1 sw Y )xY w)Nrº c óz t j | |j j j d« S )NT)r rµ ri rQ rR )ÚXÚYrs rP rl rr s r9 Ú_covz<ExponentialMovingWindow.corr.<locals>.cov_func.<locals>._covk s= ø Ü*×1Ñ1ØØØØ ØØIIØKKØNNØó
|
ð
|
r; Úignore)ÚallFr½ )rÀ rx rP rÁ r rb rZ r[ r¼ r/ Úerrstater r¾ r )rà rÄ rÅ rÆ rÇ rÖ r¶ Úx_varÚy_varrÈ rs rP rr r( rl s @@@r9 rÉ z.ExponentialMovingWindow.corr.<locals>.cov_funcZ s û Ø×'Ñ'¨Ó*GØ×'Ñ'¨Ó*GØ !× 5Ñ 5Ó 7Nð ×#Ñ#Ð/ð × Ò à#×/Ñ/ð ð
|
(×9Ñ9Ü w<Ø 'Ø{{Ø{{ØYYð :ó JE3÷ ô Ô*ñ 4Ù7 GÓ,Ù W gÓ.Ù W gÓ.Ø u U¨U¡]Ó 3Ñ3÷ 4ñ
|
&¨¯©°a·f±fÀ5ÔIÐ I÷ 4ð 4ús Â9-DÄDrÊ )rl rÎ rÏ r rÉ r( s ` @r9 rÐ z ExponentialMovingWindow.corr) sF ù õZ "à ×#Ñ# F¨LÔ9õ# JðJ ×#Ñ#Ø × Ñ x°¸<ó
|
ð
|
r; )
|
NNNNr TFr Nr )rX r) rO ú float | Noner4 rÜ r5 ú(float | TimedeltaConvertibleTypes | Noner6 rÜ rP ú
|
int | NonerQ ÚboolrR rß rS r$ rH únp.ndarray | NDFrame | NonerT rc ÚreturnÚNone)rr ú
|
np.ndarrayrs rã rt r_ rá râ )rá r )ÚnumbaN)rz rc rá r| )FNN)r rß ©FF©r¨ rß r rß ©NNFF©rÎ úDataFrame | Series | NonerÏ ú bool | Noner¨ rß r rß ©NNF©rÎ ré rÏ rê r rß ) r¬ Ú
|
__module__Ú __qualname__Ú__doc__Ú _attributesr] ru rx r~ r r r r Úaggr r r r r r r r r¤ r¦ r r¶ rÐ Ú __classcell__©rn s @r9 rN rN
sv ø ñ{òz Kð !Ø !Ø=AØ "Ø"#ØØ ØØ-1Ø ðKð ñ Kà ðKð ðKð ð Kð
|
;ð Kð ð Kð ðKð ðKð ðKð ðKð +ðKð ðKð
|
õ KðZ Ø ð Ø&0ð Ø<?ð à ó ó0ð 48ð*
|
Øð*
|
à &ó*
|
ñX Ø[Ñ!Ùð ó
|
ñ ð ó
|
ð$ !Ø ô9 ó<8ó= ð<8ð CáØÙ lÓ+ØÙ#Ó%Ù iÓ(ØÙ jÓ)ØÙ gÓ&ØÙ jÓ)Ùð ó
|
|
ð Ø DØô3ð: #ØØð #Jàò#Jó7ð6#JñJ ØÙ lÓ+ØÙ#Ó%Ù iÓ(ØÙ jÓ)ØÙ gÓ&ØÙ jÓ)Ùð ó
|
|
ð Ø CØô3ð: #ØØð %Jàò%Jó7ð6%JñN ØÙ lÓ+Ùð ó
|
ð Ù iÓ(ØÙ jÓ)ØÙ jÓ)Ùð ó
|
|
ð Ø RØô9 ó<
|
Eó= ð<
|
Eñ ØÙ lÓ+Ùð ó
|
ð Ù iÓ(ØÙ jÓ)ØÙ jÓ)Ùð ó
|
|
ð Ø HØô9 ó< Ló= ð< Lñ ØÙ lÓ+Ùð ó
|
ð Ù iÓ(ØÙ jÓ)ØÙ jÓ)Ùð ó
|
ð Ø QØôO(ðV ,0Ø $ØØ "ð ,
|
à(ð,
|
ð ð,
|
ð ð ,
|
ð
|
ò ,
|
óS(ðR,
|
ñ\ ØÙ lÓ+Ùð ó
|
ð Ù iÓ(ØÙ jÓ)ØÙ jÓ)Ùð ó
|
ð Ø RØôK&ðR ,0Ø $Ø "ð 1
|
à(ð1
|
ð ð1
|
ð ò 1
|
óO&ôN1
|
r; rN c ód e Zd ZdZej
|
ej
|
z Zddd fdZddZ xZ S )Ú ExponentialMovingWindowGroupbyzF
|
Provide an exponential moving window groupby implementation.
|
N)Ú_grouperc óL t | |g|¢d|i|¤ |j s| j ut j
|
t | j j j « « « }t | j j |« | j « | _ y y y )Nrö )r\ r] ÚemptyrH r/ Ú concatenateÚliströ Úindicesr± rL Útaker5 rh )rl rX rö r r Ú groupby_orderrn s r9 r] z'ExponentialMovingWindowGroupby.__init__ s ø Ü ÑÐAtÒA¨hÐA¸&ÒAàyyTZZÐ 3ä NN¬4°· ± ×0EÑ0E×0LÑ0LÓ0NÓ+OÓ PMÜ,Ø
|
|
Ó.Ø ó DLð 4yr; c óP t | j j t ¬« }|S )z
|
Return an indexer class that will compute the window start and end bounds
|
|
Returns
|
-------
|
GroupbyIndexer
|
)Úgroupby_indicesrÇ )r rö rû r )rl rÇ s r9 rx z2ExponentialMovingWindowGroupby._get_window_indexer s& ô (Ø MM× 1Ñ 1Ü9ô
|
ð Ð r; ©rá râ )rá r )
|
r¬ rí rî rï rN rð r# r] rx rò ró s @r9 rõ rõ s. ø ñð *×5Ñ5Ð8I×8UÑ8UÑUKà,0÷ ÷ r; rõ c óÚ e Zd Z d dd d fdZddZd ZdddZ d ddZ d ddZddd Z ddd
|
d Z
|
xZ S )r| NrU c ó( |
|
t d« t | ||||||||| |
|
| ¬« t | j | j
|
| j | j |j « | _ t | « r| | _ | | _ y t d« )Nz0times is not implemented with online operations.) rX rO r4 r5 r6 rP rQ rR rS rH rV z$'numba' is the only supported engine)r` r\ r] r ri rQ rR rS rk Ú_meanr rz r{ r. )rl rX rO r4 r5 r6 rP rQ rR rS rH rz r{ rV rn s r9 r] z&OnlineExponentialMovingWindow.__init__¦ s¢ ø ð" Ð Ü%ØBóð ô ÑØØØØ ØØ#ØØ ØØØ ð ô
|
ô "Ø IIt{{ D§N¡N°D·I±I¸s¿y¹yó
|
|
ô 6Ô "Ø DKØ!.DÕ ä Ð CÓDÐ Dr; c ó8 | j j « y)z=
|
Reset the state captured by `update` calls.
|
N)r Úresetrw s r9 r z#OnlineExponentialMovingWindow.resetÑ s ð
|
|
×ÑÕr; c ó t d« )Nz aggregate is not implemented.©r` )rl r
r r s r9 r z'OnlineExponentialMovingWindow.aggregate× s Ü!Ð"AÓBÐBr; c ó t d« )Nzstd is not implemented.r )rl r¨ r r s r9 r¦ z!OnlineExponentialMovingWindow.stdÚ ó Ü!Ð";Ó<Ð<r; c ó t d« )Nzcorr is not implemented.r )rl rÎ rÏ r s r9 rÐ z"OnlineExponentialMovingWindow.corrÝ s ô "Ð"<Ó=Ð=r; c ó t d« )Nzcov is not implemented.r )rl rÎ rÏ r¨ r s r9 r¶ z!OnlineExponentialMovingWindow.covå s ô "Ð";Ó<Ð<r; c ó t d« )Nzvar is not implemented.r r® s r9 r z!OnlineExponentialMovingWindow.varî r r; )ÚupdateÚ update_timesc ó² i }| j j dk( }| t d« t j t | j j | j dz
|
dz
|
d« t j ¬« }|º| j j t d« d}|j |d< |r;| j j t j dd
f } |j |d < n%| j j } |j |d
|
< t j | |j# « f« }
|
nd}| j j |d< |r| j j |d < n| j j |d
|
< | j j% t j d ¬ « j# « }
|
t' d i t) | j* « ¤} | j j- |r|
|
n|
|
dd
t j f || j. | « } |s| j1 « } | |d } | j j2 | fi |¤} | S )a[
|
Calculate an online exponentially weighted mean.
|
|
Parameters
|
----------
|
update: DataFrame or Series, default None
|
New values to continue calculating the
|
exponentially weighted mean from the last values and weights.
|
Values should be float64 dtype.
|
|
``update`` needs to be ``None`` the first time the
|
exponentially weighted mean is calculated.
|
|
update_times: Series or 1-D np.ndarray, default None
|
New times to continue calculating the
|
exponentially weighted mean from the last values and weights.
|
If ``None``, values are assumed to be evenly spaced
|
in time.
|
This feature is currently unsupported.
|
|
Returns
|
-------
|
DataFrame or Series
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({"a": range(5), "b": range(5, 10)})
|
>>> online_ewm = df.head(2).ewm(0.5).online()
|
>>> online_ewm.mean()
|
a b
|
0 0.00 5.00
|
1 0.75 5.75
|
>>> online_ewm.mean(update=df.tail(3))
|
a b
|
2 1.615385 6.615385
|
3 2.550000 7.550000
|
4 3.520661 8.520661
|
>>> online_ewm.reset()
|
>>> online_ewm.mean()
|
a b
|
0 0.00 5.00
|
1 0.75 5.75
|
r, Nz update_times is not implemented.r+ r r= z;Must call mean with update=None first before passing updater¾ Úcolumnsr F)r¿ rq )r© rª r` r/ rj r^ rk rS rD r Úlast_ewmr. r¾ Únewaxisr r rù Úto_numpyÚastyper! r r{ Úrun_ewmrP ÚsqueezeÚ _constructor) rl r r r r Ú result_kwargsÚis_frameÚ update_deltasÚ result_fromÚ
|
last_valueÚnp_arrayÚ ewma_funcrÈ s r9 r z"OnlineExponentialMovingWindow.meanñ s ðX Ø×%Ñ%×*Ñ*¨aÑ/Ø Ð #Ü%Ð&HÓIÐ IÜÜ ×"Ñ"×(Ñ(¨¯©°Q© Ñ7¸!Ñ;¸QÓ ?ÄrÇzÁzô
|
ð Ð Øzz×"Ñ"Ð*Ü ØQóð ð KØ%+§\¡\M'Ñ "ÙØ !ZZ× 0Ñ 0´·±ºQ° Ñ ?
|
Ø+1¯>©> iÒ(à !ZZ× 0Ñ 0
|
Ø(.¯ © fÑ%Ü~~ z°6·?±?Ó3DÐ&EÓFHàKØ%)×%7Ñ%7×%=Ñ%=M'Ñ "ÙØ+/×+=Ñ+=×+EÑ+E iÒ(à(,×(:Ñ(:×(?Ñ(? fÑ%Ø×)Ñ)×0Ñ0´·±À%Ð0ÓH×QÑQÓSHÜ3ñ
|
Ü × 2Ñ 2Ó3ñ
|
ð ×#Ñ#Ù H hªq´"·*±*¨}Ñ&=Ø Ø × Ñ Ø ó
|
ñ Ø^^Ó%FØ Ð%Ø0×#Ñ#×0Ñ0°ÑI¸=ÑIØ r; ) NNNNr TFr Nrä N)rX r) rO rÜ r4 rÜ r5 rÝ r6 rÜ rP rÞ rQ rß rR rß rS r$ rH rà rz rc r{ zdict[str, bool] | Nonerá râ r )F)r¨ rß rë rì rç rè rå ræ ) r¬ rí rî r] r r r¦ rÐ r¶ r r rò ró s @r9 r| r| ¥ sR ø ð !Ø !Ø=AØ "Ø"#ØØ ØØ-1Ø Ø04ð)Eð ñ )Eà ð)Eð ð)Eð ð )Eð
|
;ð )Eð ð )Eð ð)Eð ð)Eð ð)Eð ð)Eð +ð)Eð ð)Eð .ð)Eð
|
õ!)EóVò Cô=ð
|
,0Ø $Ø "ð >à(ð>ð ð>ð ó >ð ,0Ø $ØØ "ð =à(ð=ð ð=ð ð =ð
|
ó =ô=ð "&°D÷ Vð Vr; r| )
|
r3 rÜ r4 rÜ r5 rÜ r6 rÜ rá r2 )rH znp.ndarray | NDFramer5 rÝ rá znpt.NDArray[np.float64])JÚ
|
__future__r rd Ú functoolsr Útextwrapr Útypingr Únumpyr/ Úpandas._libs.tslibsr Ú pandas._libs.window.aggregationsÚ_libsÚwindowÚ aggregationsr Úpandas.util._decoratorsr Úpandas.core.dtypes.commonr r
|
Úpandas.core.dtypes.dtypesr Úpandas.core.dtypes.genericr Úpandas.core.dtypes.missingr Ú pandas.corer Ú pandas.core.arrays.datetimeliker Ú pandas.core.indexers.objectsr r r Úpandas.core.util.numba_r r Úpandas.core.window.commonr Úpandas.core.window.docr r r r r r r r Úpandas.core.window.numba_r r Úpandas.core.window.onliner r! Úpandas.core.window.rollingr" r# Úpandas._typingr$ r% r& rË r' r( Úpandas.core.genericr) r: rL rN rõ r| rq r; r9 ú<module>r9 s ðÝ "ã Ý Ý Ý ã å )ß >Ó >Ý '÷õ 6Ý 0Ý +å Ý 9÷ñ ÷
|
õ ,÷ ÷ ó ÷÷÷ñ
|
÷ñ ÷ õ ,ð Ø ð à
|
ð ð ð ð ð ð
|
ó ðB'Ø ð'à6ð'ð ó'ô:|
|
jô |
|
ô~ Ð%6Ð8Oô ôBbÐ$;õ br;
|
