+ Ŝi&^RIHt^RIt^RIHt^RIHtHt^RIt ^RI H t ^RI H uHuHt^RIHt^RIHtHt^RIHt^R IHt^R IHt^R IHt^R IHt^R I H!t!H"t"H#t#^RI$H%t%H&t&^RI'H(t(^RI)H*t*H+t+^RI,H-t-H.t.^RI/H0t0H1t1]'d^RI2H3t3H4t4H5t5^RI6H7t7H8t8^RI9H:t:RRlt;RRlt<]!R4!RR]044t=]!R4!RR]1]=44t>!RR ]=4t?R#)!) 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 ,V^8dQhRRRRRRRRRR/#)comass float | Nonespanhalflifealphareturnfloat)formats"_/Users/mibo/.openclaw/workspace/.venv-ak/lib/python3.14/site-packages/pandas/core/window/ewm.py __annotate__r.?s:      c\P!WW#4pV^8d \R4hVeV^8d \R4hMVe$V^8d \R4hV^, ^, pMVe\V^8:d \R4h^\P!\P !R4V, 4, p^V, ^, pM9Ve+V^8:gV^8d \R4h^V, V, pM \R4h\ V4#)z8comass, span, halflife, and alpha are mutually exclusivez 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&&&& r-get_center_of_massr9?s ''hFKQSTT A:?@ @   !8;< <(a   q=BC CBFF266#;122UQ   A:AB Be)u$LMM =r/c$V^8dQhRRRRRR/#)r#timesznp.ndarray | NDFramer'(float | TimedeltaConvertibleTypes | Noner)znpt.NDArray[np.float64]r+)r,s"r-r.r.`s&'' '6''r/c\VP4p\RV4p\V\4'd VP p\ P!VP\ P4\ PR7p\\V4PV4P4p\ P!V4V, #)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 _valuesr4asarrayviewint64float64r*ras_unit_valuediff)r;r'unit_times _halflifes&& r-_calculate_deltasrL`s*  %D  D !D%##  ZZ 288,BJJ ?Fi)11$7>>?I 776?Y &&r/zpandas.api.typingca]tRt^~tRt.ROtRRR/RV3RlllltRRltRR ltRR R llt RV3R llt ] t RR Rllt RRRllt RRRlltRRRlltR RRlltR!RRlltRtV;t#)"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 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 N selectioncDV^8dQhRRRRRRRRRRR R R R R R RRRRRR/ #)r#objr!comr%r&r'r<r( min_periods int | Noneadjustbool ignore_nar;np.ndarray | NDFrame | Nonemethodstrr)Noner+)r,s"r-r.$ExponentialMovingWindow.__annotate__DsJJ JJ J ; J  J JJJ+JJ Jr/c   <\S T`TVf^M\\V4^4RRRV V R7W nW0nW@nWPnWpnWn Wn VPEe\VPRR4p \V 4'g"\V \4'g \R4h\!VP4\!V48wd \R4h\VP \"\$P&\(P*34'g \R4h\-VP4P/4'd \R4h\1VPVP 4Vn\4P6!VPVP VP4^8dQVP'g \9R4h\;VPVP RVP4VnR#R VnR#VP eK\VP \"\$P&\(P*34'd \R 4h\(P>!\VP@PB^,^, ^4\(PDR 7Vn\;VPVP VP VP4VnR#) NF)rQrSoncenterclosedrYrOr?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 integerzRNone 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__maxintrRr&r'r(rUrWr;getattrr r@r r3lenrZdatetime timedeltar4 timedelta64r anyrL_deltasrr2NotImplementedErrorr9_comonesrQshaperE)selfrQrRr&r'r(rSrUrWr;rYrO times_dtype __class__s&&&&&&&&&&&$ r-rb ExponentialMovingWindow.__init__Ds2 (0c#k:JA6N      " :: !!$**gt 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 )ra aggregate)rpfuncargskwargsrrs&&*,r-r!ExponentialMovingWindow.aggregates Lw 7777r/cV^8dQhRR/#r# numeric_onlyrVr+)r,s"r-r.r\sSJSJSJr/c >\V4'dVPR8Xd\pM\pV!R/\ V4BRVP RVP RVPR\VP4RR/BpVPVRR 7#VR9d}Ve \R 4hVPfR M VPp\\PVP VP VPVRR 7pVPVRVR 7#\R4h)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 singlerRrUrWdeltas normalizeTmeannameN+cython engine does not accept engine_kwargsrRrUrWrrrr)engine must be either 'numba' or 'cython'r+cythonN)rrYrrrrmrUrWtuplerk_applyr3r;rwindow_aggregationsewmrprrrrewm_funcr window_funcs&&&& r-rExponentialMovingWindow.meansl 6 " "{{h&.4#M2II{{..  T\\*   H;;xf;5 5 ' '( !NOO!ZZ/TT\\F!#''II{{.. K;;{l;S SHI Ir/cV^8dQhRR/#rr+)r,s"r-r.r\esUJUJUJr/c VP'g \R4hVPe \R4h\V4'dVPR8Xd\ pM\ pV!R/\V4BRVPRVPRVPR\VP4R R /BpVPVR R 7#VR9d}Ve \R 4hVPfRM VPp\\P VPVPVPVR R7pVPVR VR7#\R4h)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 timesrrRrUrWrrFsumrrrrrr+r)rUrlr;rrYrrrrmrWrrkrr3rrrrs&&&& r-rExponentialMovingWindow.sumesBh{{{%&PQ Q :: !%&IJ J 6 " "{{h&.4#M2II{{..  T\\*   H;;xe;4 4 ' '( !NOO!ZZ/TT\\F!#''II{{.. K;;{\;R RHI Ir/c V^8dQhRRRR/#r#biasrVrr+)r,s"r-r.r\s,E,E,ED,Er/c <V'dbVPP^8XdG\VPP4'g"\ \ V4P R24hVPe \ R4h\VPWR74#)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 z$.std does not implement numeric_onlyz!std is not implemented with times)rr) _selected_objndimr r?rltype__name__r;rvarrprrs&&&r-stdExponentialMovingWindow.stdsD ""''1,$T%7%7%=%=>>&:&&''KL  :: !%&IJ JTXX4XCDDr/c V^8dQhRRRR/#rr+)r,s"r-r.r\s/L/L/LD/Lr/c aVPe \R4h\Pp\ VVP VP VPVR7oV3RlpVPVRVR7#)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)rRrUrWrc<S!WW#V4#ryr+)valuesbeginrvrSwfuncs&&&&r-var_func-ExponentialMovingWindow.var..var_funcs&A Ar/rr) r;rlrewmcovrrmrUrWr)rprrrrrs&&& @r-rExponentialMovingWindow.varsiB :: !%&IJ J)00   ;;nn   B{{8%l{KKr/c(V^8dQhRRRRRRRR/#r#otherDataFrame | Series | Nonepairwise bool | NonerrVrr+)r,s"r-r.r\s8Z Z (Z Z  Z  Z r/c aaaSPe \R4h^RIHoSP RV4VVV3RlpSP SP WWT4#)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 timesr covc <S PV4pS PV4pS P4pS Pe S PM VPpVP \ V4VS P S PS PR7wrg\P!VVVS PVS PS PS PS 4 pS !WPVPRR7#)N num_valuesrSr_r`stepFindexrcopy) _prep_valuesrrS window_sizeget_window_boundsrfr_r`rrrrmrUrWrr) xyx_arrayy_arraywindow_indexerrSrurvresultr rrps && r-cov_func-ExponentialMovingWindow.cov..cov_funcTs''*G''*G!557N##/  #//  (99w<'{{{{YY :JE)//     F&aff5I Ir/r;rlpandasr _validate_numeric_only_apply_pairwiser)rprrrrrr sf&&f& @r-rExponentialMovingWindow.covsWd :: !%&IJ J! ##E<8 J>##     r/c$V^8dQhRRRRRR/#r#rrrrrrVr+)r,s"r-r.r\ws-] ] (] ]  ] r/c aaSPe \R4h^RIHoSP RV4VV3RlpSP SP WWC4#)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 timesrcorrcb<a a a SPV4pSPV4pSP4pSPe SPM VPo VP \ V4S SP SPSPR7wo o V V VV 3Rlp\P!RR7;_uu_4V!W#4pV!W"4pV!W34pV\Wx,4, p RRR4S !X VPVPRR7# +'giL0;i)Nrc |<\P!VSSSVSPSPSPR4 #)T)rrrmrUrW)XYrvrSrprus&&r-_cov.cov_func.._covs=*11IIKKNN  r/ignore)allFr)rrrSrrrfr_r`rr4errstaterrr)rrrrrrrx_vary_varrrvrSrur rps&& @@@r-r.ExponentialMovingWindow.corr..cov_funcs''*G''*G!557N##/  #//  (99w<'{{{{YY :JE3  **7,W.W.uU]33 + &aff5I I +*s 1D D. r)rprrrrr sf&&& @r-rExponentialMovingWindow.corrwsX^ :: !%&JK K! ##FL9# JJ##     r/) rmrkrUr(rRr'rWr&r;) rRr&r'r(rSrUrWr;rY) NNNNrTFNr)numbaNry)FNNFFNNFFNNF)r __module__ __qualname____firstlineno____doc__ _attributesrbrzrrraggrrrrrr__static_attributes__ __classcell__rrs@r-rNrN~sxvp KJJJX 0 ' RF8P CSJjUJn,E\/LbZ x] ] r/rNca]tRtRtRt]P ]P ,tRR/RV3RllltRRlt R t V;t #) ExponentialMovingWindowGroupbyiz> Provide an exponential moving window groupby implementation. _grouperNcV^8dQhRR/#r#r)r[r+)r,s"r-r.+ExponentialMovingWindowGroupby.__annotate__s  t r/c f<\SV`!V.VO5RV/VBVP'gVPex\P !\ VPPP444p\VPPV4VP4Vn R#R#R#)rN)rarbemptyr;r4 concatenatelistrindicesrrLtaker'rk)rprQrrr groupby_orderrrs&&$*, r-rb'ExponentialMovingWindowGroupby.__init__s AtAhA&AyyyTZZ3NN4 0E0E0L0L0N+OPM,  . DL4yr/cV^8dQhRR/#)r#r)rr+)r,s"r-r.rs  ^ r/c P\VPP\R7pV#)zk Return an indexer class that will compute the window start and end bounds Returns ------- GroupbyIndexer )groupby_indicesr)rrr r)rprs& r-r2ExponentialMovingWindowGroupby._get_window_indexers&( MM119 r/)rk) rrrrrrNrrrbrrrrs@r-rrs<*558I8U8UUK D    r/rca]tRtRtRRR/RV3RlllltRRltRRltRR R lltRR R lltRR Rllt RRRllt RRRR/Rlt Rt V;t #)riNrOcHV^8dQhRRRRRRRRRRR R R R R R RRRRRRRR/ #)r#rQr!rRr%r&r'r<r(rSrTrUrVrWr;rXrrZrzdict[str, bool] | Noner)r[r+)r,s"r-r.*OnlineExponentialMovingWindow.__annotate__s%E%E %E%E %E ; %E  %E %E%E%E+%E%E.%E %Er/c   <V e \R4h\S V` VVVVVVVVV V R7 \VPVP VP VP4Vn\V 4'dWn Wn R#\R4h)Nz0times is not implemented with online operations.) rQrRr&r'r(rSrUrWr;rOz$'numba' is the only supported engine) rlrarbrrmrUrWro_meanrrrr3)rprQrRr&r'r(rSrUrWr;rrrOrrs&&&&&&&&&&&&$r-rb&OnlineExponentialMovingWindow.__init__s  %B  #  "$))T[[$..#))T 6 " " K!. CD Dr/cV^8dQhRR/#rr+)r,s"r-r.r!str/c :VPP4R#)z- Reset the state captured by `update` calls. N)rresetr~s&r-r#OnlineExponentialMovingWindow.reset!s r/c \R4h)zaggregate is not implemented.rl)rprrrs&&*,r-r'OnlineExponentialMovingWindow.aggregate's!"ABBr/cV^8dQhRR/#)r#rrVr+)r,s"r-r.r*s===r/c \R4h)zstd is not implemented.r)rprrrs&&*,r-r!OnlineExponentialMovingWindow.std*!";<>(>> >r/c \R4h)zcorr is not implemented.r)rprrrs&&&&r-r"OnlineExponentialMovingWindow.corr-s ""<==r/c(V^8dQhRRRRRRRR/#rr+)r,s"r-r.r5s2==(== =  =r/c \R4h)zcov is not implemented.r)rprrrrs&&&&&r-r!OnlineExponentialMovingWindow.cov5s"";<s===D=r/c \R4h)zvar is not implemented.rrs&&&r-r!OnlineExponentialMovingWindow.var>r!r/update update_timesc /pVPP^8HpVe \R4h\P!\ VPP R ,^, ^4\PR7pVeVPPf \R4h^pVPVR&V'd>VPP\PR3,p VPVR&M%VPPp VPVR&\P!WP!434p M^pVPPVR&V'dVPPVR&MVPPVR&VPP#\P4P!4p \%R /\'VP(4Bp VPP+V'dT MV R\P3,VVP,V 4p V'gV P/4p WRp VPP0!V 3/VBp V #) 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 Nz update_times is not implemented.r>z;Must call mean with update=None first before passing updater:NNNcolumnsrr+)rrrlr4rnrcrorErlast_ewmr3rnewaxisr.rrto_numpyastyperrrrun_ewmrSsqueeze _constructor) rpr+r,rr result_kwargsis_frame update_deltas result_from last_valuenp_array ewma_funcrs &$$*, r-r"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 r/)rrr) NNNNrTFNrNry)Frrr)rrrrrbrrrrrrrrrrs@r-rrsV%E%E%EN C=>==VVDVVr/r)@ __future__rrg functoolsrtypingrrnumpyr4pandas._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!r9rLrNrrr+r/r-rWs" )>>.60+9 ,  ,B'<  U  jU  !U  p  %68O!B^$;^r/