
    Egv                       d dl mZ d dlZd dlmZ d dlmZ d dlmZ d dl	Z
d dlmZ d dlmc mc mZ d dlmZ d dlmZmZ d d	lmZ d d
lmZ d dlmZ d dlmZ d dlm Z  d dl!m"Z"m#Z#m$Z$ d dl%m&Z&m'Z' d dl(m)Z) d dl*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2 d dl3m4Z4m5Z5 d dl6m7Z7m8Z8 d dl9m:Z:m;Z; erd dl<m=Z=m>Z>m?Z? d dl@mAZAmBZB d dlCmDZD d+dZEd,d$ZF G d% d&e:          ZG G d' d(e;eG          ZH G d) d*eG          ZIdS )-    )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)NDFramecomassfloat | Nonespanhalflifealphareturnfloatc                   t          j        | |||          }|dk    rt          d          | | dk     rt          d          n||dk     rt          d          |dz
  dz  } n|J|dk    rt          d          dt          j        t          j        d          |z            z
  }d|z  dz
  } n5|$|dk    s|dk    rt          d	          d|z
  |z  } nt          d
          t          |           S )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logr0   )r*   r,   r-   r.   valid_countdecays         K/var/www/sysmax/venv/lib/python3.11/site-packages/pandas/core/window/ewm.pyget_center_of_massr<   G   s#    'hFFKQSTTT A::?@@@ 		!88;<<<(a		q==BCCCBF26#;;1222UQ		A::ABBBe)u$LMMM==    timesnp.ndarray | NDFrame(float | TimedeltaConvertibleTypes | Nonenpt.NDArray[np.float64]c                r   t          | j                  }t          | t                    r| j        } t          j        |                     t
          j                  t
          j	                  }t          t          |                              |          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
    dtype)r   rD   
isinstancer   _valuesr6   asarrayviewint64float64r0   r   as_unit_valuediff)r>   r-   unit_times	_halflifes        r;   _calculate_deltasrQ   h   s    * %%D%## Z

28,,BJ???Fi))11$77>??I76??Y&&r=   c                  <    e Zd ZdZg dZ	 	 	 	 	 	 	 	 	 	 dZddd[ fdZd\d$Zd]d&Z	 d^d_d*Z e	e
d+          ed,           ed-          d.d/0           fd1            ZeZ e	e ed2          e e             ed3          e ed4          e ed5          e ed6           ed7          d8d9d:;          	 	 	 d`dad=            Z e	e ed2          e e             ed3          e ed4          e ed5          e ed6           ed>          d8d?d@;          	 	 	 d`dadA            Z e	e ed2           edB          e ed3          e ed4          e ed6           edC          d8dDdE;          dbdcdG            Z e	e ed2           edB          e ed3          e ed4          e ed6           edH          d8dIdJ;          dbdcdK            Z e	e ed2           edL          e ed3          e ed4          e ed6           edM          d8dNdO;          	 	 	 	 dddedT            Z e	e ed2           edU          e ed3          e ed4          e ed6           edV          d8dWdX;          	 	 	 dfdgdY            Z xZS )h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,
    ``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
    )
comr,   r-   r.   min_periodsadjust	ignore_naaxisr>   methodNr   TFsingle	selectionobjr)   rT   r+   r,   r-   r@   r.   rU   
int | NonerV   boolrW   rX   r$   r>   np.ndarray | NDFrame | NonerY   strr/   Nonec          
        t                                          ||dnt          t          |          d          d dd ||	|           || _        || _        || _        || _        || _        || _	        |
| _
        | j
        | j        st          d          t          | j
        dd           }t          |          s$t          |t                    st!          d          t#          | j
                  t#          |          k    rt!          d          t          | j        t$          t&          j        t*          j        f          st!          d          t/          | j
                                                  rt!          d	          t3          | j
        | j                  | _        t7          j        | j        | j        | j                  d
k    r(t;          | j        | j        d | j                  | _        d S d| _        d S | j        @t          | j        t$          t&          j        t*          j        f          rt!          d          t+          j        t          | j         j!        | j"                 dz
  d
          t*          j#                  | _        t;          | j        | j        | j        | j                  | _        d S )Nr2   F)r]   rU   oncenterclosedrY   rX   r\   z)times is not supported with adjust=False.rD   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.rC   )$super__init__maxintrT   r,   r-   r.   rV   rW   r>   NotImplementedErrorgetattrr	   rE   r   r5   lenra   datetime	timedeltar6   timedelta64r   anyrQ   _deltasr   r4   r<   _comonesr]   shaperX   rJ   )selfr]   rT   r,   r-   r.   rU   rV   rW   rX   r>   rY   r\   times_dtype	__class__s                 r;   rh   z ExponentialMovingWindow.__init__P  s     	(0c#k:J:JA6N6N 	 		
 		
 		
 	 
"
:!; W)*UVVV!$*gt<<K#K00Dk?;;D !!BCCC4:#c((** !OPPPdmc83Er~-VWW T !RSSSDJ##%% I !GHHH,TZGGDL $TXty$*EEII.txD$*UU						}(ZX%7H. .( !)  
 7DHN49-1155RZ  DL + 	
 DIIIr=   start
np.ndarrayendnum_valsrj   c                    d S N )rv   ry   r{   r|   s       r;   _check_window_boundsz,ExponentialMovingWindow._check_window_bounds  s	    
 	r=   r   c                    t                      S )z[
        Return an indexer class that will compute the window start and end bounds
        )r   rv   s    r;   _get_window_indexerz+ExponentialMovingWindow._get_window_indexer  s     .///r=   numbaengineOnlineExponentialMovingWindowc                    t          | j        | j        | j        | j        | j        | j        | j        | j        | j	        | j
        ||| j                  S )a  
        Return an ``OnlineExponentialMovingWindow`` object to calculate
        exponentially moving window aggregations in an online method.

        .. versionadded:: 1.3.0

        Parameters
        ----------
        engine: str, default ``'numba'``
            Execution engine to calculate online aggregations.
            Applies to all supported aggregation methods.

        engine_kwargs : dict, default None
            Applies to all supported aggregation methods.

            * For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil``
              and ``parallel`` dictionary keys. The values must either be ``True`` or
              ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is
              ``{{'nopython': True, 'nogil': False, 'parallel': False}}`` and will be
              applied to the function

        Returns
        -------
        OnlineExponentialMovingWindow
        )r]   rT   r,   r-   r.   rU   rV   rW   rX   r>   r   engine_kwargsr\   )r   r]   rT   r,   r-   r.   rU   rV   rW   rX   r>   
_selection)rv   r   r   s      r;   onlinezExponentialMovingWindow.online  sY    8 -]*(;n*'o
 
 
 	
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klassrX   c                >     t                      j        |g|R i |S r~   )rg   r   )rv   funcargskwargsrx   s       r;   r   z!ExponentialMovingWindow.aggregate  s,    > !uww 777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_methodnumeric_onlyc           
        t          |          ro| j        dk    rt          }nt          } |d
i t	          |          | j        | j        | j        t          | j	                  dd}| 
                    |d          S |dv rg|t          d          | j        d n| j	        }t          t          j        | j        | j        | j        |d          }| 
                    |d|          S t          d	          )NrZ   TrT   rV   rW   deltas	normalizer   namecythonN+cython engine does not accept engine_kwargsr   r   )engine must be either 'numba' or 'cython'r   )r   rY   r   r   r   rs   rV   rW   tuplerr   _applyr5   r>   r   window_aggregationsr   rv   r   r   r   r   ewm_funcr   window_funcs           r;   r   zExponentialMovingWindow.mean  s&   B 6"" 	J{h&&.4t  #M22I{.T\**   H ;;xf;555'''( !NOOO!Z/TTT\F!#'I{.  K ;;{l;SSSHI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           
        | j         st          d          t          |          ro| j        dk    rt          }nt
          } |di t          |          | j        | j         | j        t          | j
                  dd}|                     |d          S |dv rg|t          d          | j        d n| j
        }t          t          j        | j        | j         | j        |d          }|                     |d|	          S t          d
          )Nz(sum is not implemented with adjust=FalserZ   Fr   r   r   r   r   r   r   r   )rV   rk   r   rY   r   r   r   rs   rW   r   rr   r   r5   r>   r   r   r   r   s           r;   r   zExponentialMovingWindow.sum9  s@   B { 	R%&PQQQ6"" 	J{h&&.4t  #M22I{.T\**   H ;;xe;444'''( !NOOO!Z/TTT\F!#'I{.  K ;;{\;RRRHI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stdbiasc                    |rM| j         j        dk    r=t          | j         j                  s$t	          t          |           j         d          t          |                     ||                    S )Nr2   z$.std does not implement numeric_only)r   r   )	_selected_objndimr
   rD   rk   type__name__r   varrv   r   r   s      r;   r   zExponentialMovingWindow.std{  s}    @ 	"'1,,$T%7%=>> - &::&LLL   TXX4lXCCD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                    t           j        }t          || j        | j        | j        |          fd}|                     |d|          S )N)rT   rV   rW   r   c                "     | ||||           S r~   r   )valuesbeginr{   rU   wfuncs       r;   var_funcz-ExponentialMovingWindow.var.<locals>.var_func  s    5[&AAAr=   r   r   )r   ewmcovr   rs   rV   rW   r   )rv   r   r   r   r   r   s        @r;   r   zExponentialMovingWindow.var  sn    > *0	;n
 
 
	B 	B 	B 	B 	B {{8%l{K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covotherDataFrame | Series | Nonepairwisebool | Nonec                     ddl m                      d|            fd}                      j        ||||          S )Nr   r(   r   c                                        |           }                     |          }                                }j        j        n|j        }|                    t          |          |j        j        j                  \  }}t          j
        |||j        |j        j        j        
	  	        } 	|| j        | j        d          S )N
num_valuesrU   re   rf   stepFindexr   copy)_prep_valuesr   rU   window_sizeget_window_boundsrm   re   rf   r   r   r   rs   rV   rW   r   r   )xyx_arrayy_arraywindow_indexerrU   ry   r{   resultr(   r   rv   s            r;   cov_funcz-ExponentialMovingWindow.cov.<locals>.cov_func  s    ''**G''**G!5577N #/   #/ 
 (99w<<'{{Y :  JE3 )/  	 F 6&af5IIIIr=   pandasr(   _validate_numeric_only_apply_pairwiser   )rv   r   r   r   r   r   r(   s   `  `  @r;   r   zExponentialMovingWindow.cov  s    ` 	"!!!!!##E<888	J 	J 	J 	J 	J 	J 	J> ##x<
 
 	
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                     ddl m                      d|            fd}                      j        ||||          S )Nr   r   r   c                0  
                      |           }                     |          }                                }j        j        n|j        |                    t          |          j        j        j                  \  

fd}t          j
        d          5   |||          } |||          } |||          }|t          ||z            z  }	d d d            n# 1 swxY w Y    |	| j        | j        d          S )Nr   c                Z    t          j        | |j        j        j        d	  	        S )NT)r   r   rs   rV   rW   )XYr{   rU   rv   ry   s     r;   _covz<ExponentialMovingWindow.corr.<locals>.cov_func.<locals>._covk  s9    *1IKN
 
 
r=   ignore)allFr   )r   r   rU   r   r   rm   re   rf   r   r6   errstater   r   r   )r   r   r   r   r   r   r   x_vary_varr   r{   rU   ry   r(   rv   s             @@@r;   r   z.ExponentialMovingWindow.corr.<locals>.cov_funcZ  s   ''**G''**G!5577N #/   #/ 
 (99w<<'{{Y :  JE3        *** 4 4d7G,,Wg..Wg..uUU]333	4 4 4 4 4 4 4 4 4 4 4 4 4 4 4
 6&af5IIIIs   .:C44C8;C8r   )rv   r   r   r   r   r(   s   `    @r;   r   zExponentialMovingWindow.corr)  s|    Z 	"!!!!!##FL999#	J #	J #	J #	J #	J #	JJ ##x<
 
 	
r=   )
NNNNr   TFr   NrZ   )r]   r)   rT   r+   r,   r+   r-   r@   r.   r+   rU   r^   rV   r_   rW   r_   rX   r$   r>   r`   rY   ra   r/   rb   )ry   rz   r{   rz   r|   rj   r/   rb   )r/   r   )r   N)r   ra   r/   r   )FNN)r   r_   FFr   r_   r   r_   NNFFr   r   r   r   r   r_   r   r_   NNFr   r   r   r   r   r_   )r   
__module____qualname____doc___attributesrh   r   r   r   r   r   r   r   aggr   r   r   r   r   r   r   r   r   r   r   r   r   __classcell__rx   s   @r;   rS   rS      s       { {z  K  !!=A""#-1K K K K K K K K KZ   0 0 0 0 48*
 *
 *
 *
 *
X 	S[!
 
 
 
$ !9  <8 8 8 8= <8 CSl++##%%i((j))g&&j))
	
 
	
  D3  : #	#J #J #J #J7 6#JJ 	Sl++##%%i((j))g&&j))
	
 
	
  C3  : #	%J %J %J %J7 6%JN 	Sl++	
 	
 	i((j))j))
	
 
	
  R9  <
E 
E 
E 
E= <
E 	Sl++	
 	
 	i((j))j))
	
 
	
  H9  <L L L L= <L 	Sl++	
 	
  	i((j))j))		
 	
  QO( ( (V ,0 $",
 ,
 ,
 ,
S( (R,
\ 	Sl++	
 	
 	i((j))j))		
 	
  RK& & &R ,0 $"	1
 1
 1
 1
O& &N1
 1
 1
 1
 1
r=   rS   c                  P     e Zd ZdZej        ej        z   Zddd	 fdZd
dZ xZ	S )ExponentialMovingWindowGroupbyzF
    Provide an exponential moving window groupby implementation.
    N)_grouperr/   rb   c               H    t                      j        |g|R d|i| |j        sx| j        st	          j        t          | j        j        	                                                    }t          | j                            |          | j                  | _        d S d S d S )Nr   )rg   rh   emptyr>   r6   concatenatelistr   indicesr   rQ   taker-   rr   )rv   r]   r   r   r   groupby_orderrx   s         r;   rh   z'ExponentialMovingWindowGroupby.__init__  s    AtAAAhA&AAAy 	TZ3N40E0L0L0N0N+O+OPPM,
.. DLLL	 	33r=   r   c                F    t          | j        j        t                    }|S )z
        Return an indexer class that will compute the window start and end bounds

        Returns
        -------
        GroupbyIndexer
        )groupby_indicesr   )r   r   r   r   )rv   r   s     r;   r   z2ExponentialMovingWindowGroupby._get_window_indexer  s+     ( M19
 
 
 r=   r/   rb   )r/   r   )
r   r   r   r   rS   r   r#   rh   r   r   r   s   @r;   r   r     s{          *58I8UUK,0 	 	 	 	 	 	 	 	       r=   r   c                       e Zd Z	 	 	 	 	 	 	 	 	 	 	 d-ddd. fdZd/dZd  Zd0d1d"Z	 	 	 d2d3d(Z	 	 	 	 d4d5d)Zd6d7d*Z	ddd+d,Z
 xZS )8r   Nr   TFr   r[   r]   r)   rT   r+   r,   r-   r@   r.   rU   r^   rV   r_   rW   rX   r$   r>   r`   r   ra   r   dict[str, bool] | Noner/   rb   c               <   |
t          d          t                                          |||||||||	|
|           t          | j        | j        | j        | j        |j                  | _	        t          |          r|| _        || _        d S t          d          )Nz0times is not implemented with online operations.)r]   rT   r,   r-   r.   rU   rV   rW   rX   r>   r\   z$'numba' is the only supported engine)rk   rg   rh   r    rs   rV   rW   rX   ru   _meanr   r   r   r5   )rv   r]   rT   r,   r-   r.   rU   rV   rW   rX   r>   r   r   r\   rx   s                 r;   rh   z&OnlineExponentialMovingWindow.__init__  s    " %B   	# 	 	
 	
 	
 "It{DNDIsy
 

 6"" 	E DK!.DCDDDr=   c                8    | j                                          dS )z=
        Reset the state captured by `update` calls.
        N)r  resetr   s    r;   r  z#OnlineExponentialMovingWindow.reset  s     	
r=   c                     t          d          )Nzaggregate is not implemented.rk   )rv   r   r   r   s       r;   r   z'OnlineExponentialMovingWindow.aggregate  s    !"ABBBr=   r   c                     t          d          )Nzstd is not implemented.r
  )rv   r   r   r   s       r;   r   z!OnlineExponentialMovingWindow.std      !";<<<r=   r   r   r   r   r   c                     t          d          )Nzcorr is not implemented.r
  )rv   r   r   r   s       r;   r   z"OnlineExponentialMovingWindow.corr  s     ""<===r=   c                     t          d          )Nzcov is not implemented.r
  )rv   r   r   r   r   s        r;   r   z!OnlineExponentialMovingWindow.cov  s     "";<<<r=   c                     t          d          )Nzvar is not implemented.r
  r   s      r;   r   z!OnlineExponentialMovingWindow.var  r  r=   )updateupdate_timesc                  i }| j         j        dk    }|t          d          t          j        t          | j         j        | j        dz
           dz
  d          t          j                  }|| j	        j
        t          d          d}|j        |d<   |r+| j	        j
        t          j        ddf         }	|j        |d	<   n| j	        j
        }	|j        |d
<   t          j        |	|                                f          }
njd}| j         j        |d<   |r| j         j        |d	<   n| j         j        |d
<   | j                             t          j        d                                          }
t'          di t)          | j                  }| j	                            |r|
n|
ddt          j        f         || j        |          }|s|                                }||d         } | j         j        |fi |}|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
        r3   Nz update_times is not implemented.r2   r   rC   z;Must call mean with update=None first before passing updater   columnsr   F)r   r   )r   r   rk   r6   rt   ri   ru   rX   rJ   r  last_ewmr5   r   newaxisr  r   r   to_numpyastyper!   r   r   run_ewmrU   squeeze_constructor)rv   r  r  r   r   result_kwargsis_frameupdate_deltasresult_from
last_valuenp_array	ewma_funcr   s                r;   r   z"OnlineExponentialMovingWindow.mean  s'   X %*a/#%&HIII"(Q7!;Q??rz
 
 
 z"* Q   K%+\M'" 4!Z0QQQ?
+1>i((!Z0
(.f%~z6??3D3D&EFFHHK%)%7%=M'" @+/+=+Ei(((,(:(?f%)00%0HHQQSSH3 
 
 233
 
	 ## =HHhqqq"*}&=	
 
  	&^^%%F%0#0II=IIr=   )NNNNr   TFr   Nr   N)r]   r)   rT   r+   r,   r+   r-   r@   r.   r+   rU   r^   rV   r_   rW   r_   rX   r$   r>   r`   r   ra   r   r  r/   rb   r  )F)r   r_   r   r   r   r   r   r   )r   r   r   rh   r  r   r   r   r   r   r   r   r   s   @r;   r   r     sJ        !!=A""#-104)E )E )E )E )E )E )E )E )EV   C C C= = = = =
 ,0 $"	> > > > > ,0 $"= = = = == = = = = "&D V V V V V V V V Vr=   r   )
r*   r+   r,   r+   r-   r+   r.   r+   r/   r0   )r>   r?   r-   r@   r/   rA   )J
__future__r   rn   	functoolsr   textwrapr   typingr   numpyr6   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<   rQ   rS   r   r   r   r=   r;   <module>r<     s   " " " " " "                              ) ) ) ) ) ) > > > > > > > > > > > > ' ' ' ' ' '        6 5 5 5 5 5 0 0 0 0 0 0 + + + + + +       9 9 9 9 9 9         
        , + + + + +	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	                     
  ,                 ,+++++   B' ' ' ':|
 |
 |
 |
 |
j |
 |
 |
~    %68O   Bb b b b b$; b b b b br=   