Ij"SSKJr SSKrSSKJr SSKJrJr SSKr SSK J r SSK J s Js Jr SSKJr SSKJrJr SSKJr SS KJr SS KJr SS KJr SS KJr SS K J!r!J"r"J#r# SSK$J%r%J&r& SSK'J(r( SSK)J*r*J+r+ SSK,J-r-J.r. SSK/J0r0J1r1 \(aSSK2J3r3J4r4J5r5 SSK6J7r7J8r8 SSK9J:r: SSjr;S Sjr<\"S5"SS\055r=\"S5"SS\1\=55r>"SS\=5r?g)!) 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)NDFramec[R"XX#5nUS:a [S5eUbUS:a [S5eOUbUS:a [S5eUS- S- nO{UbJUS::a [S5eS[R"[R "S5U- 5- nSU- S- nO.Ub US::dUS:a [S 5eSU- U- nO [S 5e[ U5$) 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 ValueErrornpexplogfloat)comassspanhalflifealpha valid_countdecays g/root/GenerationalWealth/GenerationalWealth/venv/lib/python3.13/site-packages/pandas/core/window/ewm.pyget_center_of_massr2?s ''hFKQSTT A:?@ @   !8;< <(a   q=BC CBFF266#;122UQ   A:AB Be)u$LMM =c[UR5n[SU5n[U[5(a UR n[ R"UR[ R5[ RS9n[[U5RU5R5n[ R"U5U- $)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)rr6r isinstancer _valuesr'asarrayviewint64float64r*ras_unit_valuediff)timesr-unit_times _halflifes r1_calculate_deltasrD`s*  %D  D !D%##  ZZ 288,BJJ ?Fi)11$7>>?I 776?Y &&r3zpandas.api.typingcX^\rSrSrSr/SQrSSS.SU4SjjjjrSSjrSSjrSSS jjr SU4S jjr \ r SSS jjr SSS jjr SSS jjrSSSjjrSSSjjrSS SjjrSrU=r$)!ExponentialMovingWindow~a 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_nar@methodN selectionc  >[T U]UUcSO[[U5S5SSSU U S9 X lX0lX@lXPlXplXl Xl URGb[URSS5n [U 5(d [U [5(d [S5e[!UR5[!U5:wa [S5e[UR ["[$R&[(R*45(d [S5e[-UR5R/5(a [S5e[1URUR 5Ul[4R6"URUR UR5S :aNUR(d [9S 5e[;URUR SUR5UlgS UlgUR bI[UR ["[$R&[(R*45(a [S 5e[(R>"[UR@RBS S- S 5[(RDS 9Ul[;URUR UR UR5Ulg)Nr#F)objrIoncenterclosedrLrNr6ztimes 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.r5)#super__init__maxintrHr,r-r.rJrKr@getattrr r7r r&lenstrdatetime timedeltar' timedelta64r anyrD_deltasrr%NotImplementedErrorr2_comonesrPshaper<)selfrPrHr,r-r.rIrJrKr@rLrN times_dtype __class__s r1rU ExponentialMovingWindow.__init__Ds0 (0c#k:JA6N      " :: !!$**gt[TU]"U/UQ70UD6$)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 )rT aggregate)rdfuncargskwargsrfs r1r|!ExponentialMovingWindow.aggregates Lw 7777r3c [U5(awURS:Xa[nO[nU"S 0[ U5DUR UR UR[UR5SS.D6nURUSS9$US;atUb [S5eURcSO URn[[RUR UR URUSS9nURUSUS 9$[S 5e) 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 singleTrHrJrKdeltas normalizemeannamecythonNN+cython engine does not accept engine_kwargsr numeric_only)engine must be either 'numba' or 'cython'rj)rrLrrrrarJrKtupler__applyr&r@rwindow_aggregationsewmrdrrurvr}ewm_funcr window_funcs r1rExponentialMovingWindow.meansl 6 " "{{h&.4#M2II{{..T\\* H;;xf;5 5 ' '( !NOO!ZZ/TT\\F!#''II{{.. K;;{l;S SHI Ir3c UR(d [S5eURb [S5e[U5(awURS:Xa[ nO[ nU"S 0[U5DURURUR[UR5SS.D6nURUSS9$US ;atUb [S 5eURcSO URn[[R URURURUSS9nURUSUS 9$[S 5e)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 timesrFrsumrrrrrrj)rJr`r@rrLrrrrarKrr_rr&rrrrs r1rExponentialMovingWindow.sumes$h{{%&PQ Q :: !%&IJ J 6 " "{{h&.4#M2II{{..T\\* H;;xe;4 4 ' '( !NOO!ZZ/TT\\F!#''II{{.. K;;{\;R RHI Ir3c.U(a_URRS:XaE[URR5(d![ [ U5R S35eURb [ S5e[URXS95$)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_onlyz!std is not implemented with times)biasr) _selected_objndimr r6r`type__name__r@rvarrdrrs r1stdExponentialMovingWindow.stdsD ""''1,$T%7%7%=%=>>&:&&''KL  :: !%&IJ JTXX4XCDDr3c^URb [S5e[Rn[ UUR UR URUS9mU4SjnURUSUS9$)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 z!var is not implemented with times)rHrJrKrc>T"XX#U5$rirj)valuesbeginrlrIwfuncs r1var_func-ExponentialMovingWindow.var..var_funcs&A Ar3rr) r@r`rewmcovrrarJrKr)rdrrrrrs @r1rExponentialMovingWindow.varsiB :: !%&IJ J)00   ;;nn   B{{8%l{KKr3c^^^TRb [S5eSSKJm TR SU5 UUU4SjnTR TR XXT5$)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 z!cov is not implemented with timesrr covc >T RU5nT RU5nT R5nT Rb T RO URnUR [ U5UT R T RT RS9upg[R"UUUT RUT RT RT RT 5 nT "XRURSS9$)N num_valuesrIrRrSstepFindexrcopy) _prep_valuesrrrI window_sizeget_window_boundsrYrRrSrrrrarJrKrr) xyx_arrayy_arraywindow_indexerrIrkrlresultr rrds r1cov_func-ExponentialMovingWindow.cov..cov_funcTs''*G''*G!557N##/  #//  (99w<'{{{{YY :JE)//     F&aff5I Ir3r@r`pandasr _validate_numeric_only_apply_pairwiser)rdotherpairwiserrrr s` ` @r1rExponentialMovingWindow.covsWd :: !%&IJ J! ##E<8 J>##     r3c^^TRb [S5eSSKJm TR SU5 UU4SjnTR TR XXC5$)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 z"corr is not implemented with timesrrcorrc*>^ ^ ^ TRU5nTRU5nTR5nTRb TRO URm UR [ U5T TR TRTRS9um m U U UU 4Sjn[R"SS9 U"X#5nU"X"5nU"X35nU[Xx-5- n SSS5 T "W URURSS9$!,(df  N+=f)Nrc |>[R"UTTTUTRTRTRS5 $)NT)rrrarJrK)XYrlrIrdrks r1_cov.cov_func.._covs=*11IIKKNN  r3ignore)allFr)rrrrIrrrYrRrSrr'errstaterrr)rrrrrrrx_vary_varrrlrIrkr rds @@@r1r.ExponentialMovingWindow.corr..cov_funcs''*G''*G!557N##/  #//  (99w<'{{{{YY :JE3  *7,W.W.uU]33 + &aff5I I +*s 6)D Dr)rdrrrrr s` @r1rExponentialMovingWindow.corrwsX^ :: !%&JK K! ##FL9# JJ##     r3) rar_rJr.rHr-rKr,r@) NNNNrTFNr)rPr!rH float | Noner,rr-(float | TimedeltaConvertibleTypes | Noner.rrI int | NonerJboolrKrr@np.ndarray | NDFrame | NonerLrZreturnNone)rk np.ndarrayrlrrmrWrr)rr)numbaN)rurZrrwri)FNN)rrFFrrrrNNFFrDataFrame | Series | Noner bool | NonerrrrNNFrrrrrr)r __module__ __qualname____firstlineno____doc__ _attributesrUrnrrryr|aggrrrrrr__static_attributes__ __classcell__rfs@r1rFrF~svp K!!=A""#-1JJ JJ J ; J  J JJJ+JJ JJX  &0 Provide an exponential moving window groupby implementation. N)_grouperc\>[TU]"U/UQ7SU0UD6 UR(dURbv[R "[ URRR555n[URRU5UR5Ul ggg)Nr)rTrUemptyr@r' concatenatelistrindicesrrDtaker-r_)rdrPrr~r groupby_orderrfs r1rU'ExponentialMovingWindowGroupby.__init__s AtAhA&AyyTZZ3NN4 0E0E0L0L0N+OPM,  . DL4yr3cJ[URR[S9nU$)zk Return an indexer class that will compute the window start and end bounds Returns ------- GroupbyIndexer )groupby_indicesr)rrrr)rdrs r1rr2ExponentialMovingWindowGroupby._get_window_indexers&( MM119 r3)r_rr)rr) rrrrrrFrrrUrrrrrs@r1rrs8*558I8U8UUK,0    r3rc^\rSrSrSSS.SU4SjjjjrSSjrSSjrSSSjjrSSSjjrSSS jjr SSS jjr SSS .S jr S r U=r $)rwiNrMc  >U b [S5e[T U] UUUUUUUUU U S9 [URUR UR UR5Ul[U 5(a Xl Xl g[S5e)Nz0times is not implemented with online operations.) rPrHr,r-r.rIrJrKr@rNz$'numba' is the only supported engine) r`rTrUrrarJrKrc_meanrrurvr&)rdrPrHr,r-r.rIrJrKr@rurvrNrfs r1rU&OnlineExponentialMovingWindow.__init__s  %B  #  "$))T[[$..#))T 6 " " K!. CD Dr3c8URR5 g)z- Reset the state captured by `update` calls. N)rresetrqs r1r#OnlineExponentialMovingWindow.reset!s r3c[S5e)Nzaggregate is not implemented.r`)rdr}r~rs r1r|'OnlineExponentialMovingWindow.aggregate's!"ABBr3c[S5e)Nzstd is not implemented.r )rdrr~rs r1r!OnlineExponentialMovingWindow.std*!";<r r3)update update_timesc0nURRS:HnUb [S5e[R"[ URR SS- S5[RS9nUbURRc [S5eSnURUS 'U(a;URR[RSS24n URUS 'O%URRn URUS '[R"XR!545n OSnURRUS 'U(aURRUS 'OURRUS 'URR#[R5R!5n [%S 0['UR(5D6n URR+U(aU OU SS2[R4UUR,U 5n U(dU R/5n XSn URR0"U 40UD6n U $) a3 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#rr5z;Must call mean with update=None first before passing updatercolumnsrrj)rrr`r'rbrVrcr<rlast_ewmr&rnewaxisrrrto_numpyastyperrrvrun_ewmrIsqueeze _constructor) rdrrr~r result_kwargsis_frame update_deltas result_from last_valuenp_array ewma_funcrs r1r"OnlineExponentialMovingWindow.meanAsX %%**a/  #%&HI I ""((,q0! 4BJJ   zz""* QK%+\\M' "!ZZ00Q? +1>> i(!ZZ00 (. f%~~z??3D&EFHK%)%7%7%=%=M' "+/+=+=+E+E i((,(:(:(?(? f%))00<EEGH3  2 23 ## Hhq"**}&=        ^^%F %##00I=I r3)rrurv) NNNNrTFNrN)rPr!rHrr,rr-rr.rrIrrJrrKrr@rrurZrvzdict[str, bool] | Nonerrrri)F)rrrrrrrr)rrrrrUrr|rrrrrrrrs@r1rwrwsJ!!=A""#-104%E%E %E%E %E ; %E  %E %E%E%E+%E%E.%E %E%EN C= ,0 $" >(>> >,0 $" =(== =  =="&DVVr3rw) r+rr,rr-rr.rrr*)r@znp.ndarray | NDFramer-rrznpt.NDArray[np.float64])@ __future__rr[ 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!r2rDrFrrwrjr3r1r@s#" )>>.60+9 ,  ,      B' '6''<  U  jU  !U  p  %68O!B^$;^r3