a
    Ofv                     @  s  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  m  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rzd dl<m=Z=m>Z>m?Z? d dl@mAZAmBZB d dlCmDZD ddddddddZEdddd d!d"ZFG d#d$ d$e:ZGG d%d& d&e;eGZHG d'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float | Nonefloat)comassspanhalflifealphareturnc                 C  s   t | |||}|dkr td| d ur:| dk rtdn|d ur`|dk rRtd|d d } nt|d ur|dkrxtddttd|  }d| d } n6|d ur|dks|dkrtd	d| | } 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logr*   )r+   r,   r-   r.   Zvalid_countZdecay r7   O/var/www/ai-form-bot/venv/lib/python3.9/site-packages/pandas/core/window/ewm.pyget_center_of_massG   s*    
r9   znp.ndarray | NDFrame(float | TimedeltaConvertibleTypes | Noneznpt.NDArray[np.float64])timesr-   r/   c                 C  sT   t | j}t| tr| j} tj| tjtj	d}t
t||j}t|| 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   r=   
isinstancer   Z_valuesr4   ZasarrayviewZint64float64r*   r   Zas_unit_valuediff)r;   r-   unitZ_timesZ	_halflifer7   r7   r8   _calculate_deltash   s    

rD   c                      s  e Zd ZdZg dZdYddd	d
d
dd
dddddddd fddZdddddddZddddZdZddd d!d"Ze	e
d# ed$ed%d&d'd( fd)d*ZeZe	eed+ee ed,eed-eed.eed/ed0d1d2d3d4d[dd5d6d7Ze	eed+ee ed,eed-eed.eed/ed8d1d9d:d4d\dd5d;d<Ze	eed+ed=eed,eed-eed/ed>d1d?d@d4d]dddAdBdCZe	eed+ed=eed,eed-eed/edDd1dEdFd4d^dddAdGdHZe	eed+edIeed,eed-eed/edJd1dKdLd4d_dMdNdddOdPdQZe	eed+edReed,eed-eed/edSd1dTdUd4d`dMdNddVdWdXZ  ZS )a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	selectionr(   r)   r:   
int | Noneboolr#   np.ndarray | NDFrame | NonestrNone)objrF   r,   r-   r.   rG   rH   rI   rJ   r;   rK   r/   c             
     s  t  j||d u rdntt|dd dd ||	|d || _|| _|| _|| _|| _|| _	|
| _
| j
d ur6| jsvtdt| j
dd }t|st|tstdt| j
t|krtdt| jttjtjfstdt| j
 rtd	t| j
| j| _t| j| j| jd
kr.t| j| jd | j| _nd| _nj| jd urbt| jttjtjfrbtdtjt| j j!| j" d d
tj#d| _t| j| j| j| j| _d S )Nr0   F)rT   rG   oncenterclosedrK   rJ   rN   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intrF   r,   r-   r.   rH   rI   r;   NotImplementedErrorgetattrr   r>   r
   r3   lenrR   datetime	timedeltar4   Ztimedelta64r   anyrD   _deltasr   r2   r9   _comonesrT   shaperJ   r@   )selfrT   rF   r,   r-   r.   rG   rH   rI   rJ   r;   rK   rN   Ztimes_dtype	__class__r7   r8   rY   P  sf    
z ExponentialMovingWindow.__init__z
np.ndarrayr[   )startendnum_valsr/   c                 C  s   d S Nr7   )rf   ri   rj   rk   r7   r7   r8   _check_window_bounds  s    z,ExponentialMovingWindow._check_window_boundsr   r/   c                 C  s   t  S )z[
        Return an indexer class that will compute the window start and end bounds
        )r   rf   r7   r7   r8   _get_window_indexer  s    z+ExponentialMovingWindow._get_window_indexernumbaOnlineExponentialMovingWindow)enginer/   c                 C  s8   t | j| j| j| j| j| j| j| j| j	| j
||| jd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
        )rT   rF   r,   r-   r.   rG   rH   rI   rJ   r;   rs   engine_kwargsrN   )rr   rT   rF   r,   r-   r.   rG   rH   rI   rJ   r;   Z
_selection)rf   rs   rt   r7   r7   r8   online  s    zExponentialMovingWindow.online	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 )Zsee_alsoZexamplesklassrJ   c                   s   t  j|g|R i |S rl   )rX   rv   rf   funcargskwargsrg   r7   r8   rv     s    z!ExponentialMovingWindow.aggregateZ
ParametersZReturnszSee AlsoZNotesZ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)Zwindow_methodZaggregation_descriptionZ
agg_method)numeric_onlyc              	   C  s   t |rX| jdkrt}nt}|f i t|| j| j| jt| j	dd}| j
|ddS |dv r|d urptd| jd u r~d n| j	}ttj| j| j| j|dd}| j
|d|dS td	d S )
NrL   TrF   rH   rI   deltas	normalizer~   namecythonN+cython engine does not accept engine_kwargsr   r   )engine must be either 'numba' or 'cython')r   rK   r   r   r   rc   rH   rI   tuplerb   _applyr3   r;   r   window_aggregationsr}   rf   r   rs   rt   rz   Zewm_funcr   window_funcr7   r7   r8   r~     s8    !

zExponentialMovingWindow.meanz        >>> 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              	   C  s   | j stdt|rf| jdkr&t}nt}|f i t|| j| j | jt	| j
dd}| j|ddS |dv r|d ur~td| jd u rd n| j
}ttj| j| j | j|dd}| j|d|d	S td
d S )Nz(sum is not implemented with adjust=FalserL   Fr   r   r   r   r   r   r   )rH   r\   r   rK   r   r   r   rc   rI   r   rb   r   r3   r;   r   r   r}   r   r7   r7   r8   r   9  s<    !

zExponentialMovingWindow.sumzb        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biasr   c                 C  sB   |r0| j jdkr0t| j js0tt| j dt| j||dS )Nr0   z$.std does not implement numeric_onlyr   )	_selected_objndimr	   r=   r\   type__name__r   varrf   r   r   r7   r7   r8   r   {  s     

zExponentialMovingWindow.stdz        >>> 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                   s:   t j}t|| j| j| j|d  fdd}| j|d|dS )N)rF   rH   rI   r   c                   s    | |||| S rl   r7   )valuesbeginrj   rG   Zwfuncr7   r8   var_func  s    z-ExponentialMovingWindow.var.<locals>.var_funcr   r   )r   ewmcovr   rc   rH   rI   r   )rf   r   r   r   r   r7   r   r8   r     s    zExponentialMovingWindow.vara          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DataFrame | Series | Nonebool | Noneotherpairwiser   r   c                   s<   ddl m  d|  fdd}j||||S )Nr   r'   r   c           	        s    | } |} }jd ur,jn|j}|jt||jjjd\}}t	
|||j|jjj	} || j| jddS )NZ
num_valuesrG   rV   rW   stepFindexr   copy)_prep_valuesrp   rG   window_sizeget_window_boundsr^   rV   rW   r   r   r   rc   rH   rI   r   r   )	xyx_arrayy_arraywindow_indexerrG   ri   rj   resultr'   r   rf   r7   r8   cov_func  s4    


z-ExponentialMovingWindow.cov.<locals>.cov_funcpandasr'   Z_validate_numeric_onlyZ_apply_pairwiser   )rf   r   r   r   r   r   r7   r   r8   r     s    0zExponentialMovingWindow.covaK          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corrr   r   r   c                   s:   ddl m  d|  fdd}j||||S )Nr   r   r   c           
        s    | } |} }jd ur,jn|j|jt|jjjd\  fdd}t	j
dd> |||}|||}|||}|t||  }	W d    n1 s0    Y  |	| j| jddS )Nr   c                   s    t |  |jjjd	S )NT)r   r   rc   rH   rI   )XY)rj   rG   rf   ri   r7   r8   _covk  s    z<ExponentialMovingWindow.corr.<locals>.cov_func.<locals>._covignore)allFr   )r   rp   rG   r   r   r^   rV   rW   r   r4   Zerrstater   r   r   )
r   r   r   r   r   r   r   Zx_varZy_varr   r'   rf   )rj   rG   ri   r8   r   Z  s*    





.z.ExponentialMovingWindow.corr.<locals>.cov_funcr   )rf   r   r   r   r   r7   r   r8   r   )  s    -%zExponentialMovingWindow.corr)
NNNNr   TFr   NrL   )rq   N)FNN)FNN)FF)FF)NNFF)NNF)r   
__module____qualname____doc___attributesrY   rm   rp   ru   r   r   r   rv   Zaggr   r   r   r   r   r   r   r~   r   r   r   r   r   __classcell__r7   r7   rg   r8   rE      sL   >          ,M ,   %   '+    .)   rE   c                      sF   e Zd ZdZejej Zdddd fddZddd	d
Z  Z	S )ExponentialMovingWindowGroupbyzF
    Provide an exponential moving window groupby implementation.
    N)_grouperrS   rn   c                  s^   t  j|g|R d|i| |jsZ| jd urZtt| jj	 }t
| j|| j| _d S )Nr   )rX   rY   emptyr;   r4   concatenatelistr   indicesr   rD   Ztaker-   rb   )rf   rT   r   r{   r|   Zgroupby_orderrg   r7   r8   rY     s    
z'ExponentialMovingWindowGroupby.__init__r   c                 C  s   t | jjtd}|S )z
        Return an indexer class that will compute the window start and end bounds

        Returns
        -------
        GroupbyIndexer
        )Zgroupby_indicesr   )r   r   r   r   )rf   r   r7   r7   r8   rp     s
    z2ExponentialMovingWindowGroupby._get_window_indexer)
r   r   r   r   rE   r   r"   rY   rp   r   r7   r7   rg   r8   r     s   r   c                      s   e Zd Zd*dddddd	dd
dddddddd fddZddddZdd Zd+ddddZd,dddddd Zd-ddddd!d"d#Zd.ddd$d%d&Z	ddd'd(d)Z
  ZS )/rr   Nr   TFrq   rM   r(   r)   r:   rO   rP   r#   rQ   rR   zdict[str, bool] | NonerS   )rT   rF   r,   r-   r.   rG   rH   rI   rJ   r;   rs   rt   r/   c                  sp   |
d urt dt j|||||||||	|
|d t| j| j| j| j|j| _	t
|rd|| _|| _ntdd S )Nz0times is not implemented with online operations.)rT   rF   r,   r-   r.   rG   rH   rI   rJ   r;   rN   z$'numba' is the only supported engine)r\   rX   rY   r   rc   rH   rI   rJ   re   _meanr   rs   rt   r3   )rf   rT   rF   r,   r-   r.   rG   rH   rI   rJ   r;   rs   rt   rN   rg   r7   r8   rY     s0    z&OnlineExponentialMovingWindow.__init__rn   c                 C  s   | j   dS )z=
        Reset the state captured by `update` calls.
        N)r   resetro   r7   r7   r8   r     s    z#OnlineExponentialMovingWindow.resetc                 O  s   t dd S )Nzaggregate is not implemented.r\   ry   r7   r7   r8   rv     s    z'OnlineExponentialMovingWindow.aggregate)r   c                 O  s   t dd S )Nzstd is not implemented.r   )rf   r   r{   r|   r7   r7   r8   r     s    z!OnlineExponentialMovingWindow.stdr   r   r   c                 C  s   t dd S )Nzcorr is not implemented.r   )rf   r   r   r   r7   r7   r8   r     s    z"OnlineExponentialMovingWindow.corrr   c                 C  s   t dd S )Nzcov is not implemented.r   )rf   r   r   r   r   r7   r7   r8   r     s    z!OnlineExponentialMovingWindow.covr   c                 C  s   t dd S )Nzvar is not implemented.r   r   r7   r7   r8   r     s    z!OnlineExponentialMovingWindow.var)updateupdate_timesc                O  st  i }| j jdk}|dur tdtjt| j j| jd  d dtjd}|dur| j	j
du rdtdd}|j|d< |r| j	j
tjddf }	|j|d	< n| j	j
}	|j|d
< t|	| f}
nDd}| j j|d< |r| j j|d	< n| j j|d
< | j jtjdd }
tf i t| j}| j	|r&|
n|
ddtjf || j|}|sP| }||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
        r1   Nz update_times is not implemented.r0   r   r<   z;Must call mean with update=None first before passing updater   columnsr   F)r   )r   r   r\   r4   rd   rZ   re   rJ   r@   r   Zlast_ewmr3   r   Znewaxisr   r   r   Zto_numpyZastyper    r   rt   Zrun_ewmrG   ZsqueezeZ_constructor)rf   r   r   r{   r|   Zresult_kwargsZis_frameZupdate_deltasZresult_from
last_valueZnp_arrayZ	ewma_funcr   r7   r7   r8   r~     sP    ,

z"OnlineExponentialMovingWindow.mean)NNNNr   TFr   Nrq   N)F)NNF)NNFF)FF)r   r   r   rY   r   rv   r   r   r   r   r~   r   r7   r7   rg   r8   rr     s8              .+   
    	rr   )J
__future__r   r_   	functoolsr   textwrapr   typingr   numpyr4   Zpandas._libs.tslibsr   Z pandas._libs.window.aggregationsZ_libsZwindowZaggregationsr   Zpandas.util._decoratorsr   Zpandas.core.dtypes.commonr   r	   Zpandas.core.dtypes.dtypesr
   Zpandas.core.dtypes.genericr   Zpandas.core.dtypes.missingr   Zpandas.corer   Zpandas.core.arrays.datetimeliker   Zpandas.core.indexers.objectsr   r   r   Zpandas.core.util.numba_r   r   Zpandas.core.window.commonr   Zpandas.core.window.docr   r   r   r   r   r   r   r   Zpandas.core.window.numba_r   r   Zpandas.core.window.onliner   r    Zpandas.core.window.rollingr!   r"   Zpandas._typingr#   r$   r%   r   r&   r'   Zpandas.core.genericr(   r9   rD   rE   r   rr   r7   r7   r7   r8   <module>   sH   (
!      !