jddlmZddlZddlmZddlmZmZddlZ ddl m Z ddl m cmcmZddlmZddlmZmZddlmZdd lmZdd lmZdd lmZdd lmZdd l m!Z!m"Z"m#Z#ddl$m%Z%m&Z&ddl'm(Z(ddl)m*Z*m+Z+ddl,m-Z-m.Z.ddl/m0Z0m1Z1erddl2m3Z3m4Z4m5Z5ddl6m7Z7m8Z8ddl9m:Z:d*dZ;d+d"Z<ed#Gd$d%e0Z=ed#Gd&d'e1e=Z>Gd(d)e=Z?dS),) annotationsN)partial) TYPE_CHECKINGcast) Timedelta) set_module)is_datetime64_dtypeis_numeric_dtype)DatetimeTZDtype) ABCSeries)isna)common) dtype_to_unit) BaseIndexerExponentialMovingWindowIndexerGroupbyIndexer)get_jit_argumentsmaybe_use_numba)zsqrt)generate_numba_ewm_funcgenerate_numba_ewm_table_func) EWMMeanStategenerate_online_numba_ewma_func) BaseWindowBaseWindowGroupby)TimedeltaConvertibleTypesTimeUnitnpt) DataFrameSeries)NDFramecomass float | Nonespanhalflifealphareturnfloatctj||||}|dkrtd||dkrtdn||dkrtd|dz dz }n|J|dkrtddtjtjd|z z }d|z dz }n5|$|dks|dkrtd d|z |z }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)rcount_not_none ValueErrornpexplogr()r"r$r%r& valid_countdecays DC:\Projects\DSCons\.venv\Lib\site-packages\pandas\core\window\ewm.pyget_center_of_massr4?s# 'hFFKQSTTT A::?@@ @   !88;<< <(a   q==BCC CBF26#;;1222UQ   A::ABB Be)u$LMMM ==timesnp.ndarray | NDFrame(float | TimedeltaConvertibleTypes | Nonenpt.NDArray[np.float64]ct|j}td|}t|tr|j}t j|t j t j }tt| |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 rdtype)rr<r isinstancer _valuesr.asarrayviewint64float64r(ras_unit_valuediff)r6r%unit_times _halflifes r3_calculate_deltasrI`s*  % %D  D ! !D%##  Z 28,,BJ ? ? ?Fi))11$77>??I 76??Y &&r5zpandas.api.typingceZdZdZgdZ d6ddd7fdZd8d"Zd9d$Z d:d;d(Zd<fd) Z e Z d=d>d+Z d=d>d,Z d?d@d.Z d?d@d/Z dAdBd4Z dCdDd5ZxZS)EExponentialMovingWindowa 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 and ``adjust=True``, ``halflife`` and one of ``com``, ``span`` or ``alpha`` may be provided. If ``times`` is provided and ``adjust=False``, ``halflife`` must be the only provided decay-specification parameter. 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``. 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' 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 An instance of ExponentialMovingWindow for further exponentially weighted (EW) calculations, e.g. using the ``mean`` method. 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_nar6methodNrTFsingle selectionobjr!rLr#r$r%r8r&rM int | NonerNboolrOr6np.ndarray | NDFrame | NonerPstrr'Nonec  zt||dntt|dddd| | ||_||_||_||_||_||_ | |_ |j t|j dd} t| s$t| tstdt!|j t!|krtdt|jt"t$jt(jfstdt-|j rtdt1|j |j|_t5j|j|j|jd kr>|jst9d t;|j|jd|j|_dSd |_dS|j@t|jt"t$jt(jfrtd t)jt|j j!d dz d t(j" |_t;|j|j|j|j|_dS)Nr*F)rTrMoncenterclosedrPrSr<ztimes 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 integerrzRNone of com, span, or alpha can be specified if times is provided and adjust=Falseg?zKhalflife can only be a timedelta convertible argument if times is not None.r;)#super__init__maxintrLr$r%r&rNrOr6getattrr r=r r-lenrXdatetime timedeltar. timedelta64r anyrI_deltasrr,NotImplementedErrorr4_comonesrTshaperB)selfrTrLr$r%r&rMrNrOr6rPrS times_dtype __class__s r3r_z ExponentialMovingWindow.__init__Ds (0c#k:J:JA6N6N         " : !!$*gt<tj|g|Ri|S)a[ Aggregate using one or more operations over the specified axis. Parameters ---------- func : function, str, list or dict Function to use for aggregating the data. If a function, must either work when passed a Series/Dataframe or when passed to Series/Dataframe.apply. Accepted combinations are: - function - string function name - list of functions and/or function names, e.g. ``[np.sum, 'mean']`` - dict of axis labels -> functions, function names or list of such. *args Positional arguments to pass to `func`. **kwargs Keyword arguments to pass to `func`. Returns ------- scalar, Series or DataFrame The return can be: * scalar : when Series.agg is called with single function * Series : when DataFrame.agg is called with a single function * DataFrame : when DataFrame.agg is called with several functions See Also -------- pandas.DataFrame.rolling.aggregate Notes ----- The aggregation operations are always performed over an axis, either the index (default) or the column axis. This behavior is different from `numpy` aggregation functions (`mean`, `median`, `prod`, `sum`, `std`, `var`), where the default is to compute the aggregation of the flattened array, e.g., ``numpy.mean(arr_2d)`` as opposed to ``numpy.mean(arr_2d, axis=0)``. `agg` is an alias for `aggregate`. Use the alias. Functions that mutate the passed object can produce unexpected behavior or errors and are not supported. See :ref:`gotchas.udf-mutation` for more details. A passed user-defined-function will be passed a Series for evaluation. If ``func`` defines an index relabeling, ``axis`` must be ``0`` or ``index``. 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 )r^ aggregate)rmfuncargskwargsros r3rz!ExponentialMovingWindow.aggregates-L!uww 7777777r5 numeric_onlyc t|ro|jdkrt}nt}|d it ||j|j|jt|j dd}| |dS|dvrg|td|j dn|j }ttj|j|j|j|d}| |d| Std ) a Calculate the ewm (exponential weighted moment) mean. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. engine : str, default None * ``'cython'`` : Runs the operation through C-extensions from cython. * ``'numba'`` : Runs the operation through JIT compiled code from numba. * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba`` engine_kwargs : dict, default None * For ``'cython'`` engine, there are no accepted ``engine_kwargs`` * 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}`` Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.ewm : Calling ewm with Series data. DataFrame.ewm : Calling ewm with DataFrames. Series.mean : Aggregating mean for Series. DataFrame.mean : Aggregating mean for DataFrame. Notes ----- See :ref:`window.numba_engine` and :ref:`enhancingperf.numba` for extended documentation and performance considerations for the Numba engine. Examples -------- >>> ser = pd.Series([1, 2, 3, 4]) >>> ser.ewm(alpha=0.2).mean() 0 1.000000 1 1.555556 2 2.147541 3 2.775068 dtype: float64 rQTrLrNrOdeltas normalizemeannamecythonNN+cython engine does not accept engine_kwargsrr)engine must be either 'numba' or 'cython'rv)rrPrrrrjrNrOtuplerh_applyr-r6rwindow_aggregationsewmrmrr|rrewm_funcr window_funcs r3rzExponentialMovingWindow.means&l 6 " " J{h&&.4t#M22I{.T\** H;;xf;55 5 ' ' '( !NOOO!Z/TTT\F!#'I{. K;;{l;SS SHII Ir5c J|jstd|jtdt|ro|jdkrt }nt }|d it||j|j|j t|j dd}| |dS|d vrg|td |jdn|j }ttj|j|j|j |d}| |d| Std )a Calculate the ewm (exponential weighted moment) sum. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. engine : str, default None * ``'cython'`` : Runs the operation through C-extensions from cython. * ``'numba'`` : Runs the operation through JIT compiled code from numba. * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba`` engine_kwargs : dict, default None * For ``'cython'`` engine, there are no accepted ``engine_kwargs`` * 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}`` Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.ewm : Calling ewm with Series data. DataFrame.ewm : Calling ewm with DataFrames. Series.sum : Aggregating sum for Series. DataFrame.sum : Aggregating sum for DataFrame. Notes ----- See :ref:`window.numba_engine` and :ref:`enhancingperf.numba` for extended documentation and performance considerations for the Numba engine. Examples -------- >>> ser = pd.Series([1, 2, 3, 4]) >>> ser.ewm(alpha=0.2).sum() 0 1.000 1 2.800 2 5.240 3 8.192 dtype: float64 z(sum is not implemented with adjust=FalseNz!sum is not implemented with timesrQFrsumrrrrrrv)rNrir6rrPrrrrjrOrrhrr-rrrrs r3rzExponentialMovingWindow.sumesWh{ R%&PQQ Q : !%&IJJ J 6 " " J{h&&.4t#M22I{.T\** H;;xe;44 4 ' ' '( !NOOO!Z/TTT\F!#'I{. K;;{\;RR RHII Ir5biasc|rM|jjdkr=t|jjs$t t |jd|jt dt| ||S)a Calculate the ewm (exponential weighted moment) standard deviation. Parameters ---------- bias : bool, default False Use a standard estimation bias correction. numeric_only : bool, default False Include only float, int, boolean columns. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.ewm : Calling ewm with Series data. DataFrame.ewm : Calling ewm with DataFrames. Series.std : Aggregating std for Series. DataFrame.std : Aggregating std for DataFrame. Examples -------- >>> ser = pd.Series([1, 2, 3, 4]) >>> ser.ewm(alpha=0.2).std() 0 NaN 1 0.707107 2 0.995893 3 1.277320 dtype: float64 r*z$.std does not implement numeric_onlyNz!std is not implemented with times)rr) _selected_objndimr r<ritype__name__r6rvarrmrrs r3stdzExponentialMovingWindow.stdsD  "'1,,$T%7%=>>-&::&LLL  : !%&IJJ JTXX4lXCCDDDr5c|jtdtj}t ||j|j|j|fd}||d|S)a Calculate the ewm (exponential weighted moment) variance. Parameters ---------- bias : bool, default False Use a standard estimation bias correction. numeric_only : bool, default False Include only float, int, boolean columns. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.ewm : Calling ewm with Series data. DataFrame.ewm : Calling ewm with DataFrames. Series.var : Aggregating var for Series. DataFrame.var : Aggregating var for DataFrame. Examples -------- >>> ser = pd.Series([1, 2, 3, 4]) >>> ser.ewm(alpha=0.2).var() 0 NaN 1 0.500000 2 0.991803 3 1.631547 dtype: float64 Nz!var is not implemented with times)rLrNrOrc"|||||Srurv)valuesbeginrrrMwfuncs r3var_funcz-ExponentialMovingWindow.var..var_funcs5[&AA Ar5rr) r6rirewmcovrrjrNrOr)rmrrrrrs @r3rzExponentialMovingWindow.varsB : !%&IJJ J)0   ;n     B B B B B{{8%l{KKKr5otherDataFrame | Series | Nonepairwise bool | Nonecjtdddlmd|fd}j||||S)a Calculate the ewm (exponential weighted moment) sample covariance. Parameters ---------- 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. numeric_only : bool, default False Include only float, int, boolean columns. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.ewm : Calling ewm with Series data. DataFrame.ewm : Calling ewm with DataFrames. Series.cov : Aggregating cov for Series. DataFrame.cov : Aggregating cov for DataFrame. Examples -------- >>> ser1 = pd.Series([1, 2, 3, 4]) >>> ser2 = pd.Series([10, 11, 13, 16]) >>> ser1.ewm(alpha=0.2).cov(ser2) 0 NaN 1 0.500000 2 1.524590 3 3.408836 dtype: float64 Nz!cov is not implemented with timesrr covc  |} |} } j jn|j}|t || j j j\}}tj ||| j| j j j } ||j|jdS)N num_valuesrMr\r]stepFindexrcopy) _prep_valuesrzrM window_sizeget_window_boundsrcr\r]rrrrjrNrOrr) xyx_arrayy_arraywindow_indexerrMrprrresultr rrms r3cov_funcz-ExponentialMovingWindow.cov..cov_funcTs''**G''**G!5577N#/  #/  (99w<<'{{Y :JE3)/     F6&af5III Ir5r6ripandasr _validate_numeric_only_apply_pairwiser)rmrrrrrr s` ` @r3rzExponentialMovingWindow.covsd : !%&IJJ J!!!!!! ##E<888 J J J J J J J>##  x<   r5cjtdddlmd|fd}j||||S)a Calculate the ewm (exponential weighted moment) sample correlation. Parameters ---------- 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. numeric_only : bool, default False Include only float, int, boolean columns. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.ewm : Calling ewm with Series data. DataFrame.ewm : Calling ewm with DataFrames. Series.corr : Aggregating corr for Series. DataFrame.corr : Aggregating corr for DataFrame. Examples -------- >>> ser1 = pd.Series([1, 2, 3, 4]) >>> ser2 = pd.Series([10, 11, 13, 16]) >>> ser1.ewm(alpha=0.2).corr(ser2) 0 NaN 1 1.000000 2 0.982821 3 0.977802 dtype: float64 Nz"corr is not implemented with timesrrcorrc0 |}|}}jjn|j |t | jjj\  fd}tj d5|||}|||}|||}|t||zz } dddn #1swxYwY | |j |j dS)Nrc Ztj||jjjd S)NT)rrrjrNrO)XYrrrMrmrps r3_covz.cov_func.._covs9*1IKN   r5ignore)allFr)rrzrMrrrcr\r]rr.errstaterrr)rrrrrrrx_vary_varrrrrMrpr rms @@@r3rz.ExponentialMovingWindow.corr..cov_funcs''**G''**G!5577N#/  #/  (99w<<'{{Y :JE3        *** 4 4d7G,,Wg..Wg..uUU]333  4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 6&af5III Is.:C44C8;C8r)rmrrrrr s` @r3rzExponentialMovingWindow.corrws^ : !%&JKK K!!!!!! ##FL999# J# J# J# J# J# JJ##  x<   r5) NNNNrTFNrQ)rTr!rLr#r$r#r%r8r&r#rMrUrNrVrOrVr6rWrPrXr'rY)rprqrrrqrsrar'rY)r'r)r{N)r|rXr'r}ru)FNN)rrVFFrrVrrVNNFFrrrrrrVrrVNNFrrrrrrV)r __module__ __qualname____doc__ _attributesr_rwrzrraggrrrrrr __classcell__ros@r3rKrK~svvp   K!!=A""#-1JJJJJJJJJX    000048' ' ' ' ' RF8F8F8F8F8F8P C# SJSJSJSJSJn# UJUJUJUJUJn,E,E,E,E,E\/L/L/L/L/Lf,0 $" Z Z Z Z Z |,0 $" ] ] ] ] ] ] ] ] ] r5rKcPeZdZdZejejzZddd fdZd dZxZ S) ExponentialMovingWindowGroupbyzF Provide an exponential moving window groupby implementation. N)_grouperr'rYcHtj|g|Rd|i||jsx|jst jt |jj }t|j ||j |_ dSdSdS)Nr)r^r_emptyr6r. concatenatelistrindicesrrItaker%rh)rmrTrrr groupby_orderros r3r_z'ExponentialMovingWindowGroupby.__init__sAtAAAhA&AAAy TZ3N4 0E0L0L0N0N+O+OPPM,  .. DLLL  33r5rcFt|jjt}|S)z Return an indexer class that will compute the window start and end bounds Returns ------- GroupbyIndexer )groupby_indicesr)rrrr)rmrs r3rzz2ExponentialMovingWindowGroupby._get_window_indexers+( M19   r5r'rY)r'r) rrrrrKrrr_rzrrs@r3rrs{*58I8UUK,0                r5rceZdZ d+ddd,fdZd-dZd.dZd/d0d Z d1d2d&Z d3d4d'Zd5d6d(Z ddd)d*Z xZ S)7r}NrTFr{rRrTr!rLr#r$r%r8r&rMrUrNrVrOr6rWr|rXrdict[str, bool] | Noner'rYc  .| tdt||||||||| |  t|j|j|j|j|_t| r| |_ | |_ dStd)Nz0times is not implemented with online operations.) rTrLr$r%r&rMrNrOr6rSz$'numba' is the only supported engine) rir^r_rrjrNrOrl_meanrr|rr-)rmrTrLr$r%r&rMrNrOr6r|rrSros r3r_z&OnlineExponentialMovingWindow.__init__s  %B  #  "$)T[$.#)TT 6 " " E DK!.D   CDD Dr5c8|jdS)z= Reset the state captured by `update` calls. N)rresetrys r3rz#OnlineExponentialMovingWindow.reset!s r5c td)Nzaggregate is not implemented.ri)rmrrrs r3rz'OnlineExponentialMovingWindow.aggregate's!"ABBBr5rc td)Nzstd is not implemented.r)rmrrrs r3rz!OnlineExponentialMovingWindow.std*!";<<rr5)update update_timesci}|jjdk}|tdtjt |jjddz dtj}||jj tdd}|j |d <|r+|jj tj ddf} |j |d <n|jj } |j|d <tj| |f} nhd}|jj |d <|r|jj |d <n|jj|d <|jtj} t%d it'|j} |j|r| n| ddtj f||j| } |s| } | |d} |jj| 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*rr;z;Must call mean with update=None first before passing updatercolumnsrrv)rrrir.rkr`rlrBrlast_ewmr-rnewaxisrrrto_numpyastyperrrrun_ewmrMsqueeze _constructor) rmrrrr result_kwargsis_frame update_deltas result_from last_valuenp_array ewma_funcrs r3rz"OnlineExponentialMovingWindow.meanAsX %*a/  #%&HII I "(,q0! 4 4BJ     z"* QK%+\M' " 4!Z0QQQ? +1> i((!Z0 (. f%~z6??3D3D&EFFHHK%)%7%=M' " @+/+=+E i(((,(:(? f%)00<<EEGGH3   233  ## =HHhqqq"*}&=         &^^%%F %0#0II=II r5) NNNNrTFNr{N)rTr!rLr#r$r#r%r8r&r#rMrUrNrVrOrVr6rWr|rXrrr'rYrru)F)rrVrrrrrr) rrrr_rrrrrrrrrs@r3r}r}sM!!=A""#-104%E%E%E%E%E%E%E%E%EN CCCC===== ,0 $" >>>>>,0 $" =========="&DVVVVVVVVVr5r}) r"r#r$r#r%r#r&r#r'r()r6r7r%r8r'r9)@ __future__rrd functoolsrtypingrrnumpyr.pandas._libs.tslibsr pandas._libs.window.aggregations_libswindow aggregationsrpandas.util._decoratorsrpandas.core.dtypes.commonr r pandas.core.dtypes.dtypesr pandas.core.dtypes.genericr pandas.core.dtypes.missingr pandas.corerpandas.core.arrays.datetimelikerpandas.core.indexers.objectsrrrpandas.core.util.numba_rrpandas.core.window.commonrpandas.core.window.numba_rrpandas.core.window.onlinerrpandas.core.window.rollingrrpandas._typingrrrrrr pandas.core.genericr!r4rIrKrr}rvr5r3r's"""""" ))))))>>>>>>>>>>>>......655555000000++++++999999 ,+++++  , ,+++++B''''<    U  U  U  U  U  jU  U  ! U  p    %68O! B^^^^^$;^^^^^r5