U +if@sddlmZddlZddlmZddlmZddlmZddl Z ddl Z ddl m Z ddlmmmZddlmZmZerddlmZmZdd lmZdd lmZdd lmZdd l m!Z!dd l"m#Z#ddl$m%Z%ddl&m'm(Z(ddl)m*Z*m+Z+m,Z,ddl-m.Z.ddl/m0Z0ddl1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:ddl;mm?Z?m@Z@ddlAmBZBmCZCddddddddZDdddddd ZEGd!d"d"eBZFGd#d$d$eCeFZGGd%d&d&eFZHdS)') annotationsN)partial)dedent) TYPE_CHECKING) Timedelta)AxisTimedeltaConvertibleTypes) DataFrameSeries)NDFrame)function)doc)find_stack_level)is_datetime64_ns_dtype)isna) BaseIndexerExponentialMovingWindowIndexerGroupbyIndexer)maybe_use_numba)zsqrt) _shared_docs args_compatcreate_section_header kwargs_compat numba_notestemplate_headertemplate_returnstemplate_see_alsowindow_agg_numba_parameters)generate_numba_ewm_funcgenerate_numba_ewm_table_func) EWMMeanStategenerate_online_numba_ewma_func) BaseWindowBaseWindowGroupby float | Nonefloat)comassspanhalflifealphareturncCst||||}|dkr td|dk r:|dkrtdn|dk r`|dkrRtd|dd}nt|dk r|dkrxtddttd|}d|d}n6|dk r|dks|dkrtd d||}ntd t|S) Nz8comass, span, halflife, and alpha are mutually exclusiverz comass must satisfy: comass >= 0zspan must satisfy: span >= 1z#halflife must satisfy: halflife > 0g?z"alpha must satisfy: 0 < alpha <= 1z1Must pass one of comass, span, halflife, or alpha)commoncount_not_none ValueErrornpexplogr&)r'r(r)r*Z valid_countZdecayr4I/home/mars/bis/venv/lib/python3.8/site-packages/pandas/core/window/ewm.pyget_center_of_mass>s* r6!str | np.ndarray | NDFrame | None(float | TimedeltaConvertibleTypes | None np.ndarray)timesr)r+cCs4tj|tjtjd}tt|j}t||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 : str, np.ndarray, Series, default None 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 Zdtype) r1ZasarrayviewZint64float64r&rvaluediff)r:r)Z_timesZ _halflifer4r4r5_calculate_deltas_s  r@cseZdZdZdddddddd d d g Zd^d ddddddddddddd fddZddddd d!d"Zd#d$d%d&Zd_d(d)Ze e d*e d+e d,d-d.d/fd0d1Z e Z e eed2eeeed3eed4eed5ed6d.d7d8d9d:d;d d d<d=d>Ze eed2eeeed3eed4eed5ed6d.d7d8d?d@d;d d d<dAdBZe eed2e dCd6d.d7eeed3eed4ed dDd8dEdFd; d`ddGdHdIZdaddGdJdKZe eed2e dCd6d.d7eeed3eed4ed dDd8dLdMd; dbddGdNdOZe eed2e dPd6d.d7eed3eed4ed dDd8dQdRd; dcdSdTddUdVdWZe eed2e dXd6d.d7eed3eed4ed dDd8dYdZd; dddSdTd[d\d]ZZS)eExponentialMovingWindowa Provide exponentially weighted (EW) calculations. Exactly one parameter: ``com``, ``span``, ``halflife``, or ``alpha`` must 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, the time unit (str or timedelta) over which an observation decays to half its value. Only applicable to ``mean()``, and halflife value will not apply to the other functions. .. versionadded:: 1.1.0 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. times : str, np.ndarray, Series, default None .. versionadded:: 1.1.0 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. .. deprecated:: 1.4.0 If str, the name of the column in the DataFrame representing the times. 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 ------- ``ExponentialMovingWindow`` subclass See Also -------- rolling : Provides rolling window calculations. expanding : Provides expanding transformations. Notes ----- See :ref:`Windowing Operations ` 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 comr(r)r* min_periodsadjust ignore_naaxisr:methodNrTFsingle selectionr r%r8 int | Noneboolrr7str) objrBr(r)r*rCrDrErFr:rGc  stj||dkrdn tt|dddd| | | d||_||_||_||_||_||_ | |_ |j dk rH|jsvt dt |j t rtjdttd|j|j |_ t|j stdt|j t|krtdt |jt tjfstd t|j rtd t|j |j|_t|j|j|jd kr@t|j|jd|j|_nd |_nb|jdk rpt |jt tjfrptd t j!tt|j"dd t j#d|_t|j|j|j|j|_dS)Nr,F)rNrConcenterclosedrGrFrJz)times is not supported with adjust=False.zSpecifying times as a string column label is deprecated and will be removed in a future version. Pass the column into times instead. stacklevelz#times must be datetime64[ns] dtype.z,times must be the same length as the object.z6halflife must be a string or datetime.timedelta objectz$Cannot convert NaT values to integerrg?zKhalflife can only be a timedelta convertible argument if times is not None.r;)$super__init__maxintrBr(r)r*rDrEr:NotImplementedError isinstancerMwarningswarn FutureWarningr _selected_objrr0lendatetime timedeltaranyr@_deltasr.r/r6_comr1onesrNr=) selfrNrBr(r)r*rCrDrErFr:rGrJ __class__r4r5rUNsn     "z ExponentialMovingWindow.__init__r9rWNone)startendnum_valsr+cCsdSNr4)rerirjrkr4r4r5_check_window_boundssz,ExponentialMovingWindow._check_window_boundsrr+cCstS)z[ Return an indexer class that will compute the window start and end bounds )rrer4r4r5_get_window_indexersz+ExponentialMovingWindow._get_window_indexernumbacCs8t|j|j|j|j|j|j|j|j|j |j |||j d 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 ) rNrBr(r)r*rCrDrErFr:engine engine_kwargsrJ) OnlineExponentialMovingWindowrNrBr(r)r*rCrDrErFr:Z _selection)rerrrsr4r4r5onlineszExponentialMovingWindow.online 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)Zsee_alsoZexamplesklassrFcstj|f||Srl)rTrvrefuncargskwargsrfr4r5rvsz!ExponentialMovingWindow.aggregateZ ParametersZReturnszSee AlsoZNotes r,ewmz"(exponential weighted moment) meanmean)Z window_methodZaggregation_descriptionZ agg_method)rrrsc Ost|r^|jdkr$t}dddf}nt}dddf}|||j|j|j|jdd}|j||d S|d kr|dk rvt d t d |||j dkrdn|j}t tj|j|j|j|dd } || St ddS)NrHcSs|Srlr4xr4r4r5z.ExponentialMovingWindow.mean..Zewm_meancSs|Srlr4rr4r4r5rrZewm_mean_tableTrsrBrDrEdeltas normalizenumba_cache_keycythonN+cython engine does not accept engine_kwargsrrBrDrErr)engine must be either 'numba' or 'cython')rrGrr rcrDrErb_applyr0nvvalidate_window_funcr:rwindow_aggregationsr~ rerrrsr{r|rzrZewm_funcr window_funcr4r4r5rsB   zExponentialMovingWindow.meanz!(exponential weighted moment) sumsumc Os|jstdt|rl|jdkr2t}dddf}nt}dddf}|||j|j|j|jdd }|j ||d S|d kr|dk rt d t d |||j dkrdn|j}ttj|j|j|j|dd} | | St ddS)Nz(sum is not implemented with adjust=FalserHcSs|Srlr4rr4r4r5rJrz-ExponentialMovingWindow.sum..Zewm_sumcSs|Srlr4rr4r4r5rMrZ ewm_sum_tableFrrrrrrr)rDrXrrGrr rcrErbrr0rrr:rrr~rr4r4r5r4sF   zExponentialMovingWindow.sumzc bias : bool, default False Use a standard estimation bias correction. z0(exponential weighted moment) standard deviationstdbiascOs&td||t|jfd|i|S)Nrr)rrrvarrerr{r|r4r4r5rlszExponentialMovingWindow.stdcOs$tjdttd|j|f||S)NzGvol is deprecated will be removed in a future version. Use std instead.rR)rZr[r\rrrr4r4r5vols zExponentialMovingWindow.volz&(exponential weighted moment) variancercsBtd||tj}t||j|j|j|dfdd}||S)Nr)rBrDrErcs|||||Srlr4)valuesbeginrjrCZwfuncr4r5var_funcsz-ExponentialMovingWindow.var..var_func) rrrewmcovrrcrDrEr)rerr{r|rrr4rr5rs zExponentialMovingWindow.vara 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/(exponential weighted moment) sample covariancecovDataFrame | Series | None bool | Noneotherpairwiserc s.ddlmfdd}j|||S)Nrr c s|}|}}jdk r,jn|j}|jt||jjd\}}t |||j|j j j  }||j |jdS)NZ num_valuesrCrPrQindexname) _prep_valuesrprC window_sizeget_window_boundsr^rPrQrrrcrDrErr) ryx_arrayy_arraywindow_indexerrCrirjresultr rrer4r5cov_funcs2    z-ExponentialMovingWindow.cov..cov_funcpandasr Z_apply_pairwiser])rerrrr|rr4rr5rs# zExponentialMovingWindow.covaL 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. z0(exponential weighted moment) sample correlationcorrrrc s,ddlmfdd}j|||S)Nrrc s|}|}}jdk r,jn|j|jt|jjd\fdd}tj dd4|||}|||}|||}|t ||} W5QRX| |j |j dS)Nrc s t||jjjd S)NT)rrrcrDrE)XY)rjrCrerir4r5_cov(sz.cov_func.._covignore)allr) rrprCrrr^rPrQr1Zerrstaterrr) rrrrrrrZx_varZy_varrr re)rjrCrir5rs(       z.ExponentialMovingWindow.corr..cov_funcr)rerrr|rr4rr5rs $zExponentialMovingWindow.corr) NNNNrTFrNrH)rqN)F)F)F)NNF)NN)__name__ __module__ __qualname____doc__ _attributesrUrmrprur rrrvZaggrrrrrrrrreplacerrrrrrr __classcell__r4r4rfr5rAsHC*V * & (    )  rAcs@eZdZdZejejZddfdd Zdddd ZZ S) ExponentialMovingWindowGroupbyzF Provide an exponential moving window groupby implementation. N)_groupercs\tj|f|d|i||jsX|jdk rXtt|jj }t |j ||j |_ dS)Nr)rTrUemptyr:r1 concatenatelistrindicesrr@Ztaker)rb)rerNrr{r|Z groupby_orderrfr4r5rUFs z'ExponentialMovingWindowGroupby.__init__rrncCst|jjtd}|S)z Return an indexer class that will compute the window start and end bounds Returns ------- GroupbyIndexer )Zgroupby_indicesr)rrrr)rerr4r4r5rpQs z2ExponentialMovingWindowGroupby._get_window_indexer) rrrrrArr$rUrprr4r4rfr5r?s  rcseZdZd'dddddd dd d d d d ddd fddZddZddZd(d dddZd)dddddZd*ddd dd d!Zd+d dd"d#Z ddd$d%d&Z Z S),rtNrTFrqrIr r%r8rKrLrr7rMzdict[str, bool] | None) rNrBr(r)r*rCrDrErFr:rrrsc  sp| dk rtdtj||||||||| | | d t|j|j|j|j|j|_ t | rd| |_ | |_ nt ddS)Nz0times is not implemented with online operations.) rNrBr(r)r*rCrDrErFr:rJz$'numba' is the only supported engine)rXrTrUr!rcrDrErFshape_meanrrrrsr0)rerNrBr(r)r*rCrDrErFr:rrrsrJrfr4r5rUas8 z&OnlineExponentialMovingWindow.__init__cCs|jdS)z= Reset the state captured by `update` calls. N)rresetror4r4r5rsz#OnlineExponentialMovingWindow.resetcOstSrlrXryr4r4r5rvsz'OnlineExponentialMovingWindow.aggregatercOstSrlrrr4r4r5rsz!OnlineExponentialMovingWindow.stdrrrcKstSrlr)rerrr|r4r4r5rsz"OnlineExponentialMovingWindow.corrrcKstSrlr)rerrrr|r4r4r5rsz!OnlineExponentialMovingWindow.covcOstSrlrrr4r4r5rsz!OnlineExponentialMovingWindow.var)update update_timesc Osli}|jjdkrdnd}|dk r*tdn(tjt|jj|jdddtjd}|dk r|j j dkrnt d d}|j |d <|r|j j tj ddf} |j|d <n|j j } |j|d <t| |f} n@d}|jj |d <|r|jj|d <n |jj|d <|jtj} t|j} |j |r"| n| ddtj f||j| } |sL| } | |d} |jj| f|} | 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-TFNz update_times is not implemented.r,rr;z;Must call mean with update=None first before passing updatercolumnsr)r]ndimrXr1rdrVrrFr=rZlast_ewmr0rZnewaxisrrrZto_numpyZastyper"rsZrun_ewmrCZsqueezeZ _constructor) rerrr{r|Z result_kwargsZis_frameZ update_deltasZ result_from last_valueZnp_arrayZ ewma_funcrr4r4r5rsN,         z"OnlineExponentialMovingWindow.mean) NNNNrTFrNrqN)F)NN)NNF)F) rrrrUrrvrrrrrrr4r4rfr5rt`s4,+  rt)I __future__rr_ functoolsrtextwraprtypingrrZnumpyr1Zpandas._libs.tslibsrZ pandas._libs.window.aggregationsZ_libsZwindowZ aggregationsrZpandas._typingrrrr r Zpandas.core.genericr Zpandas.compat.numpyr rZpandas.util._decoratorsr Zpandas.util._exceptionsrZpandas.core.dtypes.commonrZpandas.core.dtypes.missingrZpandas.core.commoncorer.Zpandas.core.indexers.objectsrrrZpandas.core.util.numba_rZpandas.core.window.commonrZpandas.core.window.docrrrrrrrrrZpandas.core.window.numba_rr Zpandas.core.window.onliner!r"Zpandas.core.window.rollingr#r$r6r@rArrtr4r4r4r5sF             , ! E!