
    Owgv                       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ZE	 	 	 	 	 	 d!dZF G d de:      ZG G d de;eG      ZH G d deG      ZIy)"    )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                   t        j                  | |||      }|dkD  rt        d      | | dk  rt        d      |#|dk  rt        d      |dz
  dz  } t        |       S |Q|dk  rt        d      dt        j                  t        j
                  d      |z        z
  }d|z  dz
  } t        |       S |(|dk  s|dkD  rt        d	      d|z
  |z  } t        |       S 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logfloat)comassspanhalflifealphavalid_countdecays         M/var/www/horilla/myenv/lib/python3.12/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                r   t        | j                        }t        | t              r| j                  } t        j                  | j                  t
        j                        t
        j                        }t        t        |      j                  |      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   r>   
isinstancer   _valuesr/   asarrayviewint64float64r2   r   as_unit_valuediff)timesr5   unit_times	_halflifes        r9   _calculate_deltasrL   h   sy    * %D%#ZZ

288,BJJ?Fi)11$7>>?I776?Y&&r;   c                  R    e Zd ZdZg dZ	 	 	 	 	 	 	 	 	 	 d2dd	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d3 fdZ	 	 	 	 	 	 	 	 d4dZd5dZ	 d6	 	 	 d7dZ e	e
d	    ed
       ed      dd       fd       ZeZ e	e ed      e e        ed      e ed      e ed      e ed       ed      ddd      	 	 	 d8	 d9d       Z e	e ed      e e        ed      e ed      e ed      e ed       ed      ddd      	 	 	 d8	 d9d       Z e	e ed       ed      e ed      e ed      e ed       ed       dd!d"      d:d;d#       Z e	e ed       ed      e ed      e ed      e ed       ed$      dd%d&      d:d;d'       Z e	e ed       ed(      e ed      e ed      e ed       ed)      dd*d+      	 	 	 	 d<	 	 	 	 	 	 	 d=d,       Z e	e ed       ed-      e ed      e ed      e ed       ed.      dd/d0      	 	 	 d>	 	 	 	 	 d?d1       Z xZS )@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
    )
comr4   r5   r6   min_periodsadjust	ignore_naaxisrH   methodN	selectionc          
        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#        |      k7  rt!        d      t        | j                  t$        t&        j(                  t*        j,                  f      st!        d      t/        | j                        j1                         rt!        d	      t3        | j                  | j                        | _        t7        j8                  | j                  | j
                  | j                        d
kD  r2t;        | j                  | j
                  d | j                        | _        y d| _        y | j                  Dt        | j                  t$        t&        j(                  t*        j,                  f      rt!        d      t+        j>                  t        | j@                  jB                  | jD                     dz
  d
      t*        jF                        | _        t;        | j                  | j
                  | j                  | j                        | _        y )Nr+   F)objrP   oncenterclosedrT   rS   rV   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intrO   r4   r5   r6   rQ   rR   rH   NotImplementedErrorgetattrr	   r?   r   r.   lenstrdatetime	timedeltar/   timedelta64r   anyrL   _deltasr   r-   r:   _comonesrX   shaperS   rD   )selfrX   rO   r4   r5   r6   rP   rQ   rR   rS   rH   rT   rV   times_dtype	__class__s                 r9   r]   z ExponentialMovingWindow.__init__P  s1     	(0c#k:JA6N 	 		
 	 
"
::!;;)*UVV!$**gt<K#K0k?; !BCC4::#c(* !OPPdmmc83E3Er~~-V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                     y N )rl   startendnum_valss       r9   _check_window_boundsz,ExponentialMovingWindow._check_window_bounds  s    
 	r;   c                    t               S )z[
        Return an indexer class that will compute the window start and end bounds
        )r   rl   s    r9   _get_window_indexerz+ExponentialMovingWindow._get_window_indexer  s     .//r;   c                   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
        )rX   rO   r4   r5   r6   rP   rQ   rR   rS   rH   engineengine_kwargsrV   )OnlineExponentialMovingWindowrX   rO   r4   r5   r6   rP   rQ   rR   rS   rH   
_selection)rl   rz   r{   s      r9   onlinez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klassrS   c                *    t        |   |g|i |S rp   )r\   r   )rl   funcargskwargsrn   s       r9   r   z!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           
        t        |      ry| j                  dk(  rt        }nt        } |d
i t	        |      | j
                  | j                  | j                  t        | j                        dd}| j                  |d      S |dv rx|t        d      | j                  d n| j                  }t        t        j                  | j
                  | j                  | j                  |d      }| j                  |d|      S t        d	      )NsingleTrO   rQ   rR   deltas	normalizer   namecythonN+cython engine does not accept engine_kwargsr   numeric_only)engine must be either 'numba' or 'cython'rq   )r   rT   r   r   r   ri   rQ   rR   tuplerh   _applyr.   rH   r   window_aggregationsr   rl   r   rz   r{   r   ewm_funcr   window_funcs           r9   r   z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           
     F   | j                   st        d      t        |      ry| j                  dk(  rt        }nt
        } |di t        |      | j                  | j                   | j                  t        | j                        dd}| j                  |d      S |dv rx|t        d      | j                  d n| j                  }t        t        j                   | j                  | j                   | j                  |d      }| j                  |d|	      S t        d
      )Nz(sum is not implemented with adjust=Falser   Fr   r   r   r   r   r   r   rq   )rQ   r`   r   rT   r   r   r   ri   rR   r   rh   r   r.   rH   r   r   r   r   s           r9   r   z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                    |rY| j                   j                  dk(  r@t        | j                   j                        s!t	        t        |       j                   d      t        | j                  ||            S )Nr+   z$.std does not implement numeric_only)biasr   )	_selected_objndimr
   r>   r`   type__name__r   varrl   r   r   s      r9   r   zExponentialMovingWindow.std{  so    @ ""''1,$T%7%7%=%=> &:&&''KL  TXX4lX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                    t         j                  }t        || j                  | j                  | j
                  |      fd}| j                  |d|      S )N)rO   rQ   rR   r   c                     | ||||       S rp   rq   )valuesbeginrs   rP   wfuncs       r9   var_funcz-ExponentialMovingWindow.var.<locals>.var_func  s    [&AAr;   r   r   )r   ewmcovr   ri   rQ   rR   r   )rl   r   r   r   r   r   s        @r9   r   z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                     ddl m  j                  d|        fd} j                   j                  ||||      S )Nr   r(   r   c                   j                  |       }j                  |      }j                         }j                  j                  n|j                  }|j	                  t        |      |j                  j                  j                        \  }}t        j                  |||j                  |j                  j                  j                  
	      } 	|| j                  | j                  d      S )N
num_valuesrP   rZ   r[   stepFindexr   copy)_prep_valuesrx   rP   window_sizeget_window_boundsrb   rZ   r[   r   r   r   ri   rQ   rR   r   r   )xyx_arrayy_arraywindow_indexerrP   rr   rs   resultr(   r   rl   s            r9   cov_funcz-ExponentialMovingWindow.cov.<locals>.cov_func  s    ''*G''*G!557N ##/   #// 
 (99w<'{{{{YY : JE3 )//   		F &aff5IIr;   pandasr(   _validate_numeric_only_apply_pairwiser   )rl   otherpairwiser   r   r   r(   s   `  `  @r9   r   zExponentialMovingWindow.cov  sE    ` 	"##E<8	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  j                  d|        fd} j                   j                  ||||      S )Nr   r   r   c                4  
 j                  |       }j                  |      }j                         }j                  j                  n|j                  |j	                  t        |      j                  j                  j                        \  

fd}t        j                  d      5   |||      } |||      } |||      }|t        ||z        z  }	d d d         	| j                  | j                  d      S # 1 sw Y   )xY w)Nr   c                z    t        j                  | |j                  j                  j                  d	      S )NT)r   r   ri   rQ   rR   )XYrs   rP   rl   rr   s     r9   _covz<ExponentialMovingWindow.corr.<locals>.cov_func.<locals>._covk  s=    *11IIKKNN
 
r;   ignore)allFr   )r   rx   rP   r   r   rb   rZ   r[   r   r/   errstater   r   r   )r   r   r   r   r   r   r   x_vary_varr   rs   rP   rr   r(   rl   s             @@@r9   r   z.ExponentialMovingWindow.corr.<locals>.cov_funcZ  s   ''*G''*G!557N ##/   #// 
 (99w<'{{{{YY : JE3 * 47G,Wg.Wg.uUU]33	4
 &aff5II4 4s   9-DDr   )rl   r   r   r   r   r(   s   `    @r9   r   zExponentialMovingWindow.corr)  sF    Z 	"##FL9#	JJ ##x<
 	
r;   )
NNNNr   TFr   Nr   )rX   r)   rO   float | Noner4   r   r5   (float | TimedeltaConvertibleTypes | Noner6   r   rP   
int | NonerQ   boolrR   r   rS   r$   rH   np.ndarray | NDFrame | NonerT   rc   returnNone)rr   
np.ndarrayrs   r   rt   r_   r   r   )r   r   )numbaN)rz   rc   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____doc___attributesr]   ru   rx   r~   r   r   r   r   aggr   r   r   r   r   r   r   r   r   r   r   r   r   __classcell__rn   s   @r9   rN   rN      sv   {zK  !!=A""#-1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                  d     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)_grouperc               L   t        |   |g|d|i| |j                  s| j                  ut	        j
                  t        | j                  j                  j                                     }t        | j                  j                  |      | j                        | _        y y y )Nr   )r\   r]   emptyrH   r/   concatenatelistr   indicesr   rL   taker5   rh   )rl   rX   r   r   r   groupby_orderrn   s         r9   r]   z'ExponentialMovingWindowGroupby.__init__  s    AtAhA&AyyTZZ3NN40E0E0L0L0N+OPM,

.DL 4yr;   c                P    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   )rl   r   s     r9   rx   z2ExponentialMovingWindowGroupby._get_window_indexer  s&     ( MM119
 r;   r   r   )r   r   )
r   r   r   r   rN   r   r#   r]   rx   r   r   s   @r9   r   r     s.     *558I8U8UUK,0 	r;   r   c                       e Zd Z	 	 	 	 	 	 	 	 	 	 	 ddd	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d fdZddZd ZdddZ	 	 	 d	 	 	 	 	 ddZ	 	 	 	 d	 	 	 	 	 	 	 ddZddd	Z	ddd
dZ
 xZS )r|   NrU   c               (   |
t        d      t        | 	  |||||||||	|
|       t        | j                  | j
                  | j                  | j                  |j                        | _	        t        |      r|| _        || _        y t        d      )Nz0times is not implemented with online operations.)rX   rO   r4   r5   r6   rP   rQ   rR   rS   rH   rV   z$'numba' is the only supported engine)r`   r\   r]   r    ri   rQ   rR   rS   rk   _meanr   rz   r{   r.   )rl   rX   rO   r4   r5   r6   rP   rQ   rR   rS   rH   rz   r{   rV   rn   s                 r9   r]   z&OnlineExponentialMovingWindow.__init__  s    " %B  	# 	 	
 "IIt{{DNNDIIsyy

 6" DK!.DCDDr;   c                8    | j                   j                          y)z=
        Reset the state captured by `update` calls.
        N)r  resetrw   s    r9   r  z#OnlineExponentialMovingWindow.reset  s     	

r;   c                    t        d      )Nzaggregate is not implemented.r`   )rl   r   r   r   s       r9   r   z'OnlineExponentialMovingWindow.aggregate  s    !"ABBr;   c                    t        d      )Nzstd is not implemented.r  )rl   r   r   r   s       r9   r   z!OnlineExponentialMovingWindow.std      !";<<r;   c                    t        d      )Nzcorr is not implemented.r  )rl   r   r   r   s       r9   r   z"OnlineExponentialMovingWindow.corr  s     ""<==r;   c                    t        d      )Nzcov is not implemented.r  )rl   r   r   r   r   s        r9   r   z!OnlineExponentialMovingWindow.cov  s     "";<<r;   c                    t        d      )Nzvar is not implemented.r  r   s      r9   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                   |	|j#                         f      }
nd}| j                   j                  |d<   |r| j                   j                  |d	<   n| j                   j                  |d
<   | j                   j%                  t        j                  d      j#                         }
t'        di t)        | j*                        }| j                  j-                  |r|
n|
ddt        j                  f   || j.                  |      }|s|j1                         }||d } | j                   j2                  |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
        r,   Nz update_times is not implemented.r+   r   r=   z;Must call mean with update=None first before passing updater   columnsr   F)r   rq   )r   r   r`   r/   rj   r^   rk   rS   rD   r  last_ewmr.   r   newaxisr  r   r   to_numpyastyper!   r   r{   run_ewmrP   squeeze_constructor)rl   r  r  r   r   result_kwargsis_frameupdate_deltasresult_from
last_valuenp_array	ewma_funcr   s                r9   r   z"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%~~z6??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0I=Ir;   )NNNNr   TFr   Nr   N)rX   r)   rO   r   r4   r   r5   r   r6   r   rP   r   rQ   r   rR   r   rS   r$   rH   r   rz   rc   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   s   @r9   r|   r|     sR    !!=A""#-104)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   rd   	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|   rq   r;   r9   <module>r9     s   "       ) > > ' 6 0 +  9 
 ,	 	 	
   ,
  	
 B''6' ':|
j |
~%68O Bb$; br;   