
    Mhv                       S SK Jr  S SKrS SKJr  S SKJr  S SKJr  S SK	r
S SKJr  S SKJs  Js  Jr  S SKJr  S SKJrJr  S S	KJr  S S
KJr  S SKJr  S SKJr  S SKJ r   S SK!J"r"J#r#J$r$  S SK%J&r&J'r'  S SK(J)r)  S SK*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2  S SK3J4r4J5r5  S SK6J7r7J8r8  S SK9J:r:J;r;  \(       a  S SK<J=r=J>r>J?r?  S SK@JArAJBrB  S SKCJDrD            S S jrE      S!S jrF " S S\:5      rG " S S\;\G5      rH " S S\G5      rIg)"    )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                   [         R                  " XX#5      nUS:  a  [        S5      eU b  U S:  a  [        S5      eOUb  US:  a  [        S5      eUS-
  S-  n O{UbJ  US::  a  [        S5      eS[        R                  " [        R
                  " S5      U-  5      -
  nSU-  S-
  n O.Ub   US::  d  US:  a  [        S	5      eSU-
  U-  n O[        S
5      e[        U 5      $ )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         H/var/www/html/env/lib/python3.13/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UQ		A:ABBe)u$LMM=    c                z   [        U R                  5      n[        U [        5      (       a  U R                  n [
        R                  " U R                  [
        R                  5      [
        R                  S9n[        [        U5      R                  U5      R                  5      n[
        R                  " U5      U-  $ )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   s|    * %D%##ZZ

288,BJJ?Fi)11$7>>?I776?Y&&r;   c                  Z  ^  \ rS rSrSr/ SQr          S4SS.                       S5U 4S jjjjr        S6S jrS7S jr S8   S9S	 jjr	\
" \S
   \" S5      \" S5      SSS9U 4S j5       r\r\
" \\" S5      \\" 5       \" S5      \\" S5      \\" S5      \\" S5      \" S5      SSSS9   S: S;S jj5       r\
" \\" S5      \\" 5       \" S5      \\" S5      \\" S5      \\" S5      \" S5      SSSS9   S: S;S jj5       r\
" \\" S5      \" S 5      \\" S5      \\" S5      \\" S5      \" S!5      SS"S#S9S<S=S$ jj5       r\
" \\" S5      \" S 5      \\" S5      \\" S5      \\" S5      \" S%5      SS&S'S9S<S=S( jj5       r\
" \\" S5      \" S)5      \\" S5      \\" S5      \\" S5      \" S*5      SS+S,S9    S>       S?S- jj5       r\
" \\" S5      \" S.5      \\" S5      \\" S5      \\" S5      \" S/5      SS0S1S9   S@     SAS2 jj5       rS3rU =r$ )B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,
``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U ]  UUc  SO[        [        U5      S5      S SS UU	US9  X l        X0l        X@l        XPl        Xpl        Xl	        Xl
        U R                  Gb  U R                  (       d  [        S5      e[        U R                  SS 5      n[        U5      (       d   [        U[        5      (       d  [!        S5      e[#        U R                  5      [#        U5      :w  a  [!        S5      e[        U R                  [$        [&        R(                  [*        R,                  45      (       d  [!        S5      e[/        U R                  5      R1                  5       (       a  [!        S	5      e[3        U R                  U R                  5      U l        [6        R8                  " U R                  U R
                  U R                  5      S
:  a2  [;        U R                  U R
                  S U R                  5      U l        g SU l        g U R                  bI  [        U R                  [$        [&        R(                  [*        R,                  45      (       a  [!        S5      e[*        R>                  " [        U R@                  RB                  U RD                     S-
  S
5      [*        RF                  S9U l        [;        U R                  U R
                  U R                  U R                  5      U l        g )Nr+   F)objrQ   oncenterclosedrU   rT   rW   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intrP   r4   r5   r6   rR   rS   rH   NotImplementedErrorgetattrr	   r?   r   r.   lenstrdatetime	timedeltar/   timedelta64r   anyrL   _deltasr   r-   r:   _comonesrY   shaperT   rD   )selfrY   rP   r4   r5   r6   rQ   rR   rS   rT   rH   rU   rW   times_dtype	__class__s                 r9   r^    ExponentialMovingWindow.__init__P  s4     	(0c#k:JA6N 	 		
 	 
"
::!;;)*UVV!$**gt<K#K00k?;; !BCC4::#c(* !OPPdmmc83E3Er~~-VWW !RSSDJJ##%% !GHH,TZZGDL $$TXXtyy$**EI.txxD$**U		}}(ZX%7%7H. . !) 
 77DHHNN499-115RZZDL + 		

DIr;   c                    g N )rm   startendnum_valss       r9   _check_window_bounds,ExponentialMovingWindow._check_window_bounds  s    
 	r;   c                    [        5       $ )zK
Return an indexer class that will compute the window start and end bounds
)r   rm   s    r9   _get_window_indexer+ExponentialMovingWindow._get_window_indexer  s     .//r;   c                   [        U R                  U R                  U R                  U R                  U R
                  U R                  U R                  U R                  U R                  U R                  UUU R                  S9$ )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
)rY   rP   r4   r5   r6   rQ   rR   rS   rT   rH   engineengine_kwargsrW   )OnlineExponentialMovingWindowrY   rP   r4   r5   r6   rQ   rR   rS   rT   rH   
_selection)rm   r~   r   s      r9   online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
        zSeries/Dataframe )see_alsoexamplesklassrT   c                ,   > [         TU ]  " U/UQ70 UD6$ rr   )r]   r   )rm   funcargskwargsro   s       r9   r   !ExponentialMovingWindow.aggregate  s    > w 7777r;   
ParametersReturnszSee 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           
        [        U5      (       aw  U R                  S:X  a  [        nO[        nU" S
0 [	        U5      DU R
                  U R                  U R                  [        U R                  5      SS.D6nU R                  USS9$ US;   at  Ub  [        S5      eU R                  c  S OU R                  n[        [        R                  U R
                  U R                  U R                  USS9nU R                  USUS9$ [        S	5      e)NsingleTrP   rR   rS   deltas	normalizer   namecythonN+cython engine does not accept engine_kwargsr   numeric_only)engine must be either 'numba' or 'cython'rs   )r   rU   r   r   r   rj   rR   rS   tupleri   _applyr.   rH   r   window_aggregationsr   rm   r   r~   r   r   ewm_funcr   window_funcs           r9   r   ExponentialMovingWindow.mean  s    B 6""{{h&.4 #M2II{{..T\\*H ;;xf;55''( !NOO!ZZ/TT\\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           
     R   U R                   (       d  [        S5      e[        U5      (       aw  U R                  S:X  a  [        nO[
        nU" S0 [        U5      DU R                  U R                   U R                  [        U R                  5      SS.D6nU R                  USS9$ US;   at  Ub  [        S5      eU R                  c  S OU R                  n[        [        R                   U R                  U R                   U R                  USS9nU R                  USUS	9$ [        S
5      e)Nz(sum is not implemented with adjust=Falser   Fr   r   r   r   r   r   r   rs   )rR   ra   r   rU   r   r   r   rj   rS   r   ri   r   r.   rH   r   r   r   r   s           r9   r   ExponentialMovingWindow.sum9  s   B {{%&PQQ6""{{h&.4 #M2II{{..T\\*H ;;xe;44''( !NOO!ZZ/TT\\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                    U(       a_  U R                   R                  S:X  aE  [        U R                   R                  5      (       d!  [	        [        U 5      R                   S35      e[        U R                  XS95      $ )Nr+   z$.std does not implement numeric_only)biasr   )	_selected_objndimr
   r>   ra   type__name__r   varrm   r   r   s      r9   r   ExponentialMovingWindow.std{  sp    @ ""''1,$T%7%7%=%=>> &:&&''KL  TXX4X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                   ^ [         R                  n[        UU R                  U R                  U R
                  US9mU4S jnU R                  USUS9$ )N)rP   rR   rS   r   c                   > T" XX#U 5      $ rr   rs   )valuesbeginru   rQ   wfuncs       r9   var_func-ExponentialMovingWindow.var.<locals>.var_func  s    &AAr;   r   r   )r   ewmcovr   rj   rR   rS   r   )rm   r   r   r   r   r   s        @r9   r   ExponentialMovingWindow.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                   ^ ^^ SSK Jm  T R                  SU5        UUU 4S jnT R                  T R                  XXT5      $ )Nr   r(   r   c                  > TR                  U 5      nTR                  U5      nTR                  5       nTR                  b  TR                  OUR                  nUR	                  [        U5      UTR                  TR                  TR                  S9u  pg[        R                  " UUUTR                  UTR                  TR                  TR                  T
5	      nT	" XR                  U R                  SS9$ )N
num_valuesrQ   r[   r\   stepFindexr   copy)_prep_valuesr{   rQ   window_sizeget_window_boundsrc   r[   r\   r   r   r   rj   rR   rS   r   r   )xyx_arrayy_arraywindow_indexerrQ   rt   ru   resultr(   r   rm   s            r9   cov_func-ExponentialMovingWindow.cov.<locals>.cov_func  s    ''*G''*G!557N ##/   #// 
 (99w<'{{{{YY : JE )//   		F &aff5IIr;   pandasr(   _validate_numeric_only_apply_pairwiser   )rm   otherpairwiser   r   r   r(   s   `  `  @r9   r   ExponentialMovingWindow.cov  sA    ` 	"##E<8	J> ##
 	
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                ~   ^ ^ SSK Jm  T R                  SU5        UU 4S jnT R                  T R                  XXC5      $ )Nr   r   r   c                *  >^
^^ TR                  U 5      nTR                  U5      nTR                  5       nTR                  b  TR                  OUR                  mUR	                  [        U5      TTR                  TR                  TR                  S9u  mm
U
UUU4S jn[        R                  " SS9   U" X#5      nU" X"5      nU" X35      nU[        Xx-  5      -  n	S S S 5        T" W	U R                  U R                  SS9$ ! , (       d  f       N+= f)Nr   c                |   > [         R                  " U TTTUTR                  TR                  TR                  S5	      $ )NT)r   r   rj   rR   rS   )XYru   rQ   rm   rt   s     r9   _cov<ExponentialMovingWindow.corr.<locals>.cov_func.<locals>._covk  s=    *11IIKKNN
 
r;   ignore)allFr   )r   r{   rQ   r   r   rc   r[   r\   r   r/   errstater   r   r   )r   r   r   r   r   r   r   x_vary_varr   ru   rQ   rt   r(   rm   s             @@@r9   r   .ExponentialMovingWindow.corr.<locals>.cov_funcZ  s   ''*G''*G!557N ##/   #// 
 (99w<'{{{{YY : JE3  *7,W.W.uU]33	 +
 &aff5II +*s   6)D
Dr   )rm   r   r   r   r   r(   s   `    @r9   r   ExponentialMovingWindow.corr)  sB    Z 	"##FL9#	JJ ##
 	
r;   )	rj   ri   rR   r6   rP   r5   rS   r4   rH   )
NNNNr   TFr   Nr   )rY   r)   rP   float | Noner4   r   r5   (float | TimedeltaConvertibleTypes | Noner6   r   rQ   
int | NonerR   boolrS   r   rT   r$   rH   np.ndarray | NDFrame | NonerU   rd   returnNone)rt   
np.ndarrayru   r   rv   r`   r   r   )r   r   )numbaN)r~   rd   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____firstlineno____doc___attributesr^   rw   r{   r   r   r   r   r   aggr   r   r   r   r   r   r   r   r   r   r   r   r   __static_attributes____classcell__ro   s   @r9   rN   rN      s|   {zK  !!=A""#-1K 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&N1
r;   rN   c                  t   ^  \ rS rSrSr\R                  \R                  -   rSS.SU 4S jjjrS	S jr	Sr
U =r$ )
ExponentialMovingWindowGroupbyi  z>
Provide an exponential moving window groupby implementation.
N)_grouperc               \  > [         TU ]  " U/UQ7SU0UD6  UR                  (       d  U R                  bv  [        R
                  " [        U R                  R                  R                  5       5      5      n[        U R                  R                  U5      U R                  5      U l        g g g )Nr  )r]   r^   emptyrH   r/   concatenatelistr  indicesr   rL   taker5   ri   )rm   rY   r  r   r   groupby_orderro   s         r9   r^   'ExponentialMovingWindowGroupby.__init__  s    AtAhA&AyyTZZ3NN40E0E0L0L0N+OPM,

.DL 4yr;   c                J    [        U R                  R                  [        S9nU$ )zk
Return an indexer class that will compute the window start and end bounds

Returns
-------
GroupbyIndexer
)groupby_indicesr   )r   r  r  r   )rm   r   s     r9   r{   2ExponentialMovingWindowGroupby._get_window_indexer  s&     ( MM119
 r;   )ri   r   r   )r   r   )r   r   r   r   r   rN   r  r#   r^   r{   r  r  r  s   @r9   r  r    s8     *558I8U8UUK,0 	 	 r;   r  c                     ^  \ rS rSr           SSS.                         SU 4S jjjjrSS jrS rSSS jjr   S     SS jjr    S       SS	 jjr	SSS
 jjr
SSS.S jrSrU =r$ )r   i  NrV   c               *  > U
b  [        S5      e[        TU ]	  UUUUUUUUU	U
US9  [        U R                  U R
                  U R                  U R                  UR                  5      U l	        [        U5      (       a  Xl        Xl        g [        S5      e)Nz0times is not implemented with online operations.)rY   rP   r4   r5   r6   rQ   rR   rS   rT   rH   rW   z$'numba' is the only supported engine)ra   r]   r^   r    rj   rR   rS   rT   rl   _meanr   r~   r   r.   )rm   rY   rP   r4   r5   r6   rQ   rR   rS   rT   rH   r~   r   rW   ro   s                 r9   r^   &OnlineExponentialMovingWindow.__init__  s    " %B  	# 	 	
 "IIt{{DNNDIIsyy

 6"" K!.CDDr;   c                8    U R                   R                  5         g)z-
Reset the state captured by `update` calls.
N)r  resetrz   s    r9   r  #OnlineExponentialMovingWindow.reset  s     	

r;   c                    [        S5      e)Nzaggregate is not implemented.ra   )rm   r   r   r   s       r9   r   'OnlineExponentialMovingWindow.aggregate  s    !"ABBr;   c                    [        S5      e)Nzstd is not implemented.r  )rm   r   r   r   s       r9   r   !OnlineExponentialMovingWindow.std      !";<<r;   c                    [        S5      e)Nzcorr is not implemented.r  )rm   r   r   r   s       r9   r   "OnlineExponentialMovingWindow.corr  s     ""<==r;   c                    [        S5      e)Nzcov is not implemented.r  )rm   r   r   r   r   s        r9   r   !OnlineExponentialMovingWindow.cov  s     "";<<r;   c                    [        S5      e)Nzvar is not implemented.r  r   s      r9   r   !OnlineExponentialMovingWindow.var  r!  r;   )updateupdate_timesc                  0 nU R                   R                  S:H  nUb  [        S5      e[        R                  " [        U R                   R                  U R                  S-
     S-
  S5      [        R                  S9nUb  U R                  R                  c  [        S5      eSnUR                  US'   U(       a;  U R                  R                  [        R                  SS24   n	UR                  US	'   O%U R                  R                  n	UR                  US
'   [        R                   " XR#                  5       45      n
OSnU R                   R                  US'   U(       a  U R                   R                  US	'   OU R                   R                  US
'   U R                   R%                  [        R                  SS9R#                  5       n
['        S0 [)        U R*                  5      D6nU R                  R-                  U(       a  U
OU
SS2[        R                  4   UU R.                  U5      nU(       d  UR1                  5       nXS nU R                   R2                  " U40 UD6n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+   r   r=   z;Must call mean with update=None first before passing updater   columnsr   F)r   rs   )r   r   ra   r/   rk   r_   rl   rT   rD   r  last_ewmr.   r   newaxisr+  r   r  to_numpyastyper!   r   r   run_ewmrQ   squeeze_constructor)rm   r(  r)  r   r   result_kwargsis_frameupdate_deltasresult_from
last_valuenp_array	ewma_funcr   s                r9   r   "OnlineExponentialMovingWindow.mean  s   X %%**a/#%&HII""((Q7!;Q?rzz
 zz""* Q  K%+\\M'"!ZZ00Q?
+1>>i(!ZZ00
(.f%~~z??3D&EFHK%)%7%7%=%=M'"+/+=+=+E+Ei((,(:(:(?(?f%))00%0HQQSH3 
 2 23
	 ## Hhq"**}&=	
 ^^%F%##00I=Ir;   )r  r~   r   )NNNNr   TFr   Nr   N)rY   r)   rP   r   r4   r   r5   r   r6   r   rQ   r   rR   r   rS   r   rT   r$   rH   r   r~   rd   r   zdict[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  r  r  s   @r9   r   r     sX    !!=A""#-104)E )E)E )E 	)E
 ;)E )E  )E )E )E )E +)E )E .)E  
!)E )EVC=
 ,0 $"	>(> > 	> ,0 $"=(= = 	=
 == "&D V Vr;   r   )
r3   r   r4   r   r5   r   r6   r   r   r2   )rH   znp.ndarray | NDFramer5   r   r   znpt.NDArray[np.float64])J
__future__r   re   	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   rs   r;   r9   <module>rU     s   "       ) > > ' 6 0 +  9 
 ,	 	 	
   ,
  	
 B''6' ':|
j |
~%68O Bb$; br;   