o 5c͊@sddlmZddlZddlmZddlmZddlmZm Z ddl Z ddl Z ddl mZddlmmmZddlmZmZerPddlmZmZdd lmZdd lmZdd lm Z dd l!m"Z"dd l#m$Z$m%Z%ddl&m'Z'ddl(m)m*Z*ddl+m,Z,m-Z-m.Z.ddl/m0Z0m1Z1ddl2m3Z3m4Z4ddl5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?ddl@mAZAmBZBddlCmDZDmEZEddlFmGZGmHZHd+ddZId,d#d$ZJGd%d&d&eGZKGd'd(d(eHeKZLGd)d*d*eKZMdS)-) annotationsN)partial)dedent) TYPE_CHECKINGcast) Timedelta)AxisTimedeltaConvertibleTypes) DataFrameSeries)NDFrame)function)doc)find_stack_level)is_datetime64_ns_dtypeis_numeric_dtype)isna) BaseIndexerExponentialMovingWindowIndexerGroupbyIndexer)get_jit_argumentsmaybe_use_numba)maybe_warn_args_and_kwargszsqrt) _shared_docs args_compatcreate_section_header kwargs_compatkwargs_numeric_only numba_notestemplate_headertemplate_returnstemplate_see_alsowindow_agg_numba_parameters)generate_numba_ewm_funcgenerate_numba_ewm_table_func) EWMMeanStategenerate_online_numba_ewma_func) BaseWindowBaseWindowGroupbycomass float | NonespanhalflifealphareturnfloatcCst||||}|dkrtd|dur |dkrtdt|S|dur6|dkr,td|dd}t|S|durX|dkrBtddttd|}d|d}t|S|durr|dksd|dkrhtd d||}t|Std ) Nz8comass, span, halflife, and alpha are mutually exclusiverz comass must satisfy: comass >= 0zspan must satisfy: span >= 1z#halflife must satisfy: halflife > 0g?z"alpha must satisfy: 0 < alpha <= 1z1Must pass one of comass, span, halflife, or alpha)commoncount_not_none ValueErrornpexplogr0)r*r,r-r. valid_countdecayr;L/var/www/html/gps/gps/lib/python3.10/site-packages/pandas/core/window/ewm.pyget_center_of_massKs0    r=times!str | np.ndarray | NDFrame | None(float | TimedeltaConvertibleTypes | None np.ndarraycCs4tj|tjtjd}tt|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 : str, np.ndarray, Series, default None 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) r6asarrayviewint64float64r0rvaluediff)r>r-_times _halflifer;r;r<_calculate_deltasls rLcseZdZdZgdZ          dcddddfddZded%d&Zdfd(d)Z dgdhd,d-Ze e d.e d/e d0d1d2d3fd4d5Z e Z e eed6eeeeed7eed8eed9ed:d2d;dd? diddd@djdBdCZe eed6eeeeed7eed8eed9ed:d2d;d 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. .. versionadded:: 1.1.0 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 : str, np.ndarray, Series, default None .. versionadded:: 1.1.0 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. .. deprecated:: 1.4.0 If str, the name of the column in the DataFrame representing the times. 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 ------- ``ExponentialMovingWindow`` subclass See Also -------- rolling : Provides rolling window calculations. expanding : Provides expanding transformations. Notes ----- See :ref:`Windowing Operations ` for further usage details and examples. Examples -------- >>> df = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]}) >>> df B 0 0.0 1 1.0 2 2.0 3 NaN 4 4.0 >>> df.ewm(com=0.5).mean() B 0 0.000000 1 0.750000 2 1.615385 3 1.615385 4 3.670213 >>> df.ewm(alpha=2 / 3).mean() B 0 0.000000 1 0.750000 2 1.615385 3 1.615385 4 3.670213 **adjust** >>> df.ewm(com=0.5, adjust=True).mean() B 0 0.000000 1 0.750000 2 1.615385 3 1.615385 4 3.670213 >>> df.ewm(com=0.5, adjust=False).mean() B 0 0.000000 1 0.666667 2 1.555556 3 1.555556 4 3.650794 **ignore_na** >>> df.ewm(com=0.5, ignore_na=True).mean() B 0 0.000000 1 0.750000 2 1.615385 3 1.615385 4 3.225000 >>> df.ewm(com=0.5, ignore_na=False).mean() B 0 0.000000 1 0.750000 2 1.615385 3 1.615385 4 3.670213 **times** Exponentially weighted mean with weights calculated with a timedelta ``halflife`` relative to ``times``. >>> times = ['2020-01-01', '2020-01-03', '2020-01-10', '2020-01-15', '2020-01-17'] >>> df.ewm(halflife='4 days', times=pd.DatetimeIndex(times)).mean() B 0 0.000000 1 0.585786 2 1.523889 3 1.523889 4 3.233686 ) comr,r-r. min_periodsadjust ignore_naaxisr>methodNrTFsingle selectionobjr rNr+r,r-r@r.rO int | NonerPboolrQrRrr>r?rSstrr/Nonec  stj||dur dntt|dddd| | | d||_||_||_||_||_||_ | |_ |j dur|js:t dt |j t rStjdttdtd|j|j |_ t|j s\tdt|j t|kritd t |jt tjtjfsxtd t|j rtd t|j |j|_t |j|j|jd krt!|j|jd|j|_"dSd |_"dS|jdurt |jt tjtjfrtdtj#t|j$j%|j&dd tj'd|_t!|j|j|j|j|_"dS)Nr1F)rWrOoncenterclosedrSrRrVz)times is not supported with adjust=False.zSpecifying times as a string column label is deprecated and will be removed in a future version. Pass the column into times instead. stacklevelr z#times must be datetime64[ns] dtype.z,times must be the same length as the object.z/halflife must be a timedelta convertible objectz$Cannot convert NaT values to integerrg?zKhalflife can only be a timedelta convertible argument if times is not None.rB)(super__init__maxintrNr,r-r.rPrQr>NotImplementedError isinstancerZwarningswarn FutureWarningrr _selected_objrr5lendatetime timedeltar6 timedelta64ranyrL_deltasr3r4r=_comonesrWshaperRrG) selfrWrNr,r-r.rOrPrQrRr>rSrV __class__r;r<rb^sl       z ExponentialMovingWindow.__init__startrAendnum_valsrdcCsdSNr;)rtrwrxryr;r;r<_check_window_boundssz,ExponentialMovingWindow._check_window_boundsrcCstS)z[ Return an indexer class that will compute the window start and end bounds )rrtr;r;r<_get_window_indexersz+ExponentialMovingWindow._get_window_indexernumbaOnlineExponentialMovingWindowcCs8t|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 ) rWrNr,r-r.rOrPrQrRr>engine engine_kwargsrV) rrWrNr,r-r.rOrPrQrRr> _selection)rtrrr;r;r<onlineszExponentialMovingWindow.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 zSeries/Dataframe)see_alsoexamplesklassrRcstj|g|Ri|Srz)rarrtfuncargskwargsrur;r<rsz!ExponentialMovingWindow.aggregate ParametersReturnszSee AlsoNotes r1ewmz"(exponential weighted moment) meanmean) window_methodaggregation_description agg_method)rr numeric_onlyc Ostt|d||t|r5|jdkrt}nt}|d it||j|j|j t |j dd}|j |ddS|dvrh|durAt dtd|||jdurOdn|j }ttj|j|j|j |dd} |j | d|dSt d ) NrrTTrNrPrQdeltas normalizenamecythonN+cython engine does not accept engine_kwargsrr)engine must be either 'numba' or 'cython'r;)rtyperrSr$r%rrqrPrQtuplerp_applyr5nvvalidate_window_funcr>rwindow_aggregationsr rtrrrrrrewm_funcr window_funcr;r;r<rs<  zExponentialMovingWindow.meanz!(exponential weighted moment) sumsumc Ostt|d|||jstdt|r<|jdkrt}nt}|d it||j |j|j t |j dd}|j |ddS|dvro|durHtdtd|||jdurVdn|j }ttj|j |j|j |dd} |j | d|d Std ) Nrz(sum is not implemented with adjust=FalserTFrrrrrrr;)rrrPrerrSr$r%rrqrQrrprr5rrr>rrrrr;r;r<rIs@  zExponentialMovingWindow.sumzc bias : bool, default False Use a standard estimation bias correction. z0(exponential weighted moment) standard deviationstdbiascOsjtt|d||td|||r(|jjdkr(t|jjs(tt|j dt |j d||d|S)Nrr1z$.std does not implement numeric_only)rrr;) rrrrrjndimrrCre__name__rvar)rtrrrrr;r;r<rs  zExponentialMovingWindow.stdcOs*tjdttd|j|g|Ri|S)NzGvol is deprecated will be removed in a future version. Use std instead.r_)rgrhrirrrtrrrr;r;r<vols zExponentialMovingWindow.volz&(exponential weighted moment) variancercsZtt|d||td||tj}t||j|j|j |dfdd}|j |d|dS)Nr)rNrPrQrcs|||||Srzr;)valuesbeginrxrOwfuncr;r<var_funcsz-ExponentialMovingWindow.var..var_funcr) rrrrrewmcovrrqrPrQr)rtrrrrrrr;rr<rs zExponentialMovingWindow.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/(exponential weighted moment) sample covariancecovotherDataFrame | Series | Nonepairwise bool | Nonec sNddlmttdd|d|fdd}j||||S)Nrr rc s|}|}}jdurjn|j}|jt||jjjd\}}t |||j|j j j  }||j|jdS)N num_valuesrOr]r^stepindexr) _prep_valuesr}rO window_sizeget_window_boundsrkr]r^rrrrqrPrQrr) xyx_arrayy_arraywindow_indexerrOrwrxresultr rrtr;r<cov_funcs4    z-ExponentialMovingWindow.cov..cov_funcpandasr rr_validate_numeric_only_apply_pairwiserj)rtrrrrrrr;rr<rs %  zExponentialMovingWindow.covaL 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. z0(exponential weighted moment) sample correlationcorrc sLddlmttdd|d|fdd}j||||S)Nrrrc s|}|}}jdurjn|j|jt|jjjd\fdd}t j dd|||}|||}|||}|t ||} Wdn1s[wY| |j |j dS)Nrc s t||jjjd S)NT)rrrqrPrQ)XY)rxrOrtrwr;r<_cov\sz.cov_func.._covignore)allr)rr}rOrrrkr]r^rr6errstaterrr) rrrrrrrx_vary_varrr rt)rxrOrwr<rKs,      z.ExponentialMovingWindow.corr..cov_funcr)rtrrrrrr;rr<r$s " % zExponentialMovingWindow.corr) NNNNrTFrNrT)rWr rNr+r,r+r-r@r.r+rOrXrPrYrQrYrRrr>r?rSrZr/r[)rwrArxrAryrdr/r[)r/r)r~N)r/rF)rrY)FF)rrYrrYrrYNNFFrrrrrrYrrYNNFrrrrrrY) r __module__ __qualname____doc__ _attributesrbr{r}rrrrraggr rrrr#rr!r"rreplacerrrrrrr __classcell__r;r;rur<rMs@E U  , ) +        0  rMcs>eZdZdZejejZddd fddZd d d ZZ S) ExponentialMovingWindowGroupbyzF Provide an exponential moving window groupby implementation. N)_grouperr/r[csftj|g|Rd|i||js/|jdur1tt|jj }t |j ||j |_ dSdSdS)Nr)rarbemptyr>r6 concatenatelistrindicesrrLtaker-rp)rtrWrrr groupby_orderrur;r<rb|s  z'ExponentialMovingWindowGroupby.__init__rcCst|jjtd}|S)z Return an indexer class that will compute the window start and end bounds Returns ------- GroupbyIndexer )groupby_indicesr)rrrr)rtrr;r;r<r}s z2ExponentialMovingWindowGroupby._get_window_indexerr/r[)r/r) rrrrrMrr)rbr}rr;r;rur<rus   rcseZdZ           d5ddd6fddZd7d d!Zd"d#Zd8d9d%d&Z   d:d;d,d-Z    drNrTFr~rUrWr rNr+r,r-r@r.rOrXrPrYrQrRrr>r?rrZrdict[str, bool] | Noner/r[c  sn| durtdtj||||||||| | | d t|j|j|j|j|j|_ t | r3| |_ | |_ dSt d)Nz0times is not implemented with online operations.) rWrNr,r-r.rOrPrQrRr>rVz$'numba' is the only supported engine)rerarbr&rqrPrQrRrs_meanrrrr5)rtrWrNr,r-r.rOrPrQrRr>rrrVrur;r<rbs0  z&OnlineExponentialMovingWindow.__init__cCs|jdS)z= Reset the state captured by `update` calls. N)rresetr|r;r;r<rsz#OnlineExponentialMovingWindow.resetcOtSrzrerr;r;r<rz'OnlineExponentialMovingWindow.aggregatercOrrzrrr;r;r<rrz!OnlineExponentialMovingWindow.stdrrrrrcKrrzr)rtrrrrr;r;r<rsz"OnlineExponentialMovingWindow.corrcKrrzr)rtrrrrrr;r;r<rsz!OnlineExponentialMovingWindow.covcOrrzrrr;r;r<rrz!OnlineExponentialMovingWindow.var)update update_timesc Osti}|jjdkr dnd}|durtdtjt|jj|jdddtjd}|durc|j j dur6t d d}|j |d <|rP|j j tj ddf} |j|d <n |j j } |j|d <t| |f} n d}|jj |d <|rt|jj|d <n|jj|d <|jtj} td it|j} |j |r| n| ddtj f||j| } |s| } | |d} |jj| fi|} | 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 r2TFNz update_times is not implemented.r1rrBz;Must call mean with update=None first before passing updatercolumnsrr;)rjrrer6rrrcrsrRrGrlast_ewmr5rnewaxisrrrto_numpyastyper'rrrun_ewmrOsqueeze _constructor) rtrrrr result_kwargsis_frame update_deltas result_from last_valuenp_array ewma_funcrr;r;r<rsP,       z"OnlineExponentialMovingWindow.mean) NNNNrTFrNr~N)rWr rNr+r,r+r-r@r.r+rOrXrPrYrQrYrRrr>r?rrZrrr/r[rrrrrrr) rrrrbrrrrrrrrr;r;rur<rs: +    r) r*r+r,r+r-r+r.r+r/r0)r>r?r-r@r/rA)N __future__rrl functoolsrtextwraprtypingrrrgnumpyr6pandas._libs.tslibsr pandas._libs.window.aggregations_libswindow aggregationsrpandas._typingrr rr r pandas.core.genericr pandas.compat.numpyr rpandas.util._decoratorsrpandas.util._exceptionsrpandas.core.dtypes.commonrrpandas.core.dtypes.missingrpandas.core.commoncorer3pandas.core.indexers.objectsrrrpandas.core.util.numba_rrpandas.core.window.commonrrpandas.core.window.docrrrrrrr r!r"r#pandas.core.window.numba_r$r%pandas.core.window.onliner&r'pandas.core.window.rollingr(r)r=rLrMrrr;r;r;r<sH         0   ! n!