U +if_Q@sdZddlmZddlZddlmZddlmZddlZddl m Z ddl m Z m Z mZmZddlZddlZddlmZmZddlmmmZdd lmZmZmZmZdd l m!Z!dd l"m#Z$dd l%m&Z&dd l'm(Z(ddl)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/ddl0m1Z1m2Z2ddl3m4Z4ddl5m6Z6ddl7m8Z8ddl9m:Z:ddl;mZ>m?Z?ddl@mAmBZCddlDmEZEmFZFmGZGmHZHddlImJZJmKZKmLZLmMZMmNZNddlOmPZPddlQmRZRmSZSddlTmUZUmVZVddlWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbddlcmdZdmeZemfZfe rLddlgmhZhmiZiddljmkZkddllmmZmdd lnmoZoGd!d"d"e?ZpGd#d$d$epZqGd%d&d&epZrGd'd(d(epZsGd)d*d*esZterjet_Gd+d,d,eqetZudS)-zc Provide a generic structure to support window functions, similar to how we have a Groupby object. ) annotationsN) timedelta)partial)dedent) TYPE_CHECKINGAnyCallableHashable) BaseOffset to_offset) ArrayLikeAxisNDFrameTWindowingRankType)import_optional_dependency)function)doc)find_stack_level)ensure_float64is_bool is_integer is_list_like is_scalarneeds_i8_conversion) ABCDataFrame ABCSeries)notna)executor) factorize)ResamplerWindowApply)ExtensionArray) DataErrorSelectionMixin) BaseIndexerFixedWindowIndexerGroupbyIndexerVariableWindowIndexer) DatetimeIndexIndex MultiIndex PeriodIndexTimedeltaIndex)concat)NUMBA_FUNC_CACHEmaybe_use_numba)flex_binary_momentzsqrt) _shared_docs args_compatcreate_section_header kwargs_compat kwargs_scipy numba_notestemplate_headertemplate_returnstemplate_see_alsowindow_agg_numba_parameterswindow_apply_parameters)'generate_manual_numpy_nan_agg_with_axisgenerate_numba_apply_funcgenerate_numba_table_func) DataFrameSeries)NDFrame BaseGrouper)Blockc @seZdZUdZgZded<eZded<ded<dbdd d ddddddddddZe ddZ e ddddZ ddddZ dddd Z d!d!d"dd#d$d%Zd&d&d'd(d)Zdcd*d+Zdd,d-d.Zd/d0Zddd1d2Zd3d4Zd5d!d6d7d8Zd9d9dd:d;d<Ze d=d>Zd9d9d9d?d@dAZdBddCdDZdddEddFdGdHdIZdedEddJdGdKdLZdfdEddJdGdMdNZdJdOdPdQdJdRdSdTZdgdVddWdXdYdZd[ZdhdVdd\d]d^d_Zd`daZ e Z!dS)i BaseWindowz7Provides utilities for performing windowing operations. list[str] _attributeszfrozenset[Hashable] exclusionsr(_onNFrsingle) selectionrAz int | Nonebool str | Noner zstr | Index | Nonestr)obj min_periodscenterwin_typeaxisonclosedmethodc  Cs||_||_||_||_||_||_||_|dk r<||nd|_| |_ d|_ |jdkrz|jdkrn|jj |_ q|jj |_ nVt|jtr|j|_ n@t|jtr|j|jj krt|j|j|_ ntd|jd| |_|dS)Nrzinvalid on specified as z3, must be a column (of DataFrame), an Index or None)rOrTrUwindowrPrQ _win_typeZ_get_axis_numberrSrV _win_freq_i8indexrIcolumns isinstancer(r ValueErrorZ _selection _validate) selfrOrWrPrQrRrSrTrUrVrKr`M/home/mars/bis/venv/lib/python3.8/site-packages/pandas/core/window/rolling.py__init__ws.       zBaseWindow.__init__cCs&|jdk r tjdttddS|jS)Nzawin_type will no longer return 'freq' in a future version. Check the type of self.window instead. stacklevelfreq)rYwarningswarn FutureWarningrrXr_r`r`rarRs zBaseWindow.win_typereturncCstjdttd|jdk S)NzFis_datetimelike is deprecated and will be removed in a future version.rc)rfrgrhrrYrir`r`rais_datetimelikes zBaseWindow.is_datetimelikeNonecCstjdttd|S)Nz?validate is deprecated and will be removed in a future version.rc)rfrgrhrr^rir`r`ravalidates zBaseWindow.validatecCs(|jdk rt|jstd|jdk r|t|js:tdnB|jdkrNtdn.t|jr||j|jkr|td|jd|j|jdk r|jdkrtdt|jt t fst d t |t|jt rt|jjj}tt jj}||krtt |jjd |jd kr$td dS) Nzcenter must be a booleanzmin_periods must be an integerrzmin_periods must be >= 0z min_periods z must be <= window )rightZbothleftZneitherz3closed must be 'right', 'left', 'both' or 'neither'zinvalid type: z? does not implement the correct signature for get_window_bounds)tablerJz!method must be 'table' or 'single)rQrr]rPrrWrUr\rOrr TypeErrortyper#inspect signatureget_window_bounds parameterskeys__name__rV)r_Zget_window_bounds_signatureZexpected_signaturer`r`rar^s8         zBaseWindow._validate np.ndarrayint)startendnum_valsrkcCsZt|t|kr0tdt|dt|dn&t||krVtdt|d|ddS)Nzstart (z ) and end (z ) bounds must be the same lengthzstart and end bounds (z)) must be the same length as the object ())lenr])r_r|r}r~r`r`ra_check_window_boundss zBaseWindow._check_window_boundsrrOrkcCst|jdk r:t|jts:|jdkr:|j|j|jgdd}|jdkrp|jdgdgd}|j d dd }|j |_ |S) A Split data into blocks & return conformed data. NF)r[copynumberr)includeexcludefloat64)r) rTr\r(ndimreindexr[ differencerSZ select_dtypesastype_mgr consolidate)r_rOr`r`ra _create_datas   zBaseWindow._create_datac s|dkrj}t(tddtfddjD}W5QRXd}|jdkrnt|rb||ksjt|rn|}t |fd|i|}|S)a  Sub-classes to define. Return a sliced object. Parameters ---------- key : str / list of selections ndim : {1, 2} requested ndim of result subset : object, default None subset to act on NignorerRcsi|]}|t|qSr`getattr).0attrrir`ra sz'BaseWindow._gotitem..rrK) rOrfcatch_warningsfilterwarningsrhrGrrrrs)r_keyrsubsetkwargsrKZnew_winr`rira_gotitems   zBaseWindow._gotitem)rcCsH||jkrt||S||jkr(||Stdt|jd|ddS)N'z' object has no attribute ')Z_internal_names_setobject__getattribute__rOAttributeErrorrsry)r_rr`r`ra __getattr__$s   zBaseWindow.__getattr__cCs |jSN)rO_dir_additionsrir`r`rar.szBaseWindow._dir_additionscs4fddjD}d|}tjd|dS)z@ Provide a nice str repr of our rolling object. c3s>|]6}t|ddk r|ddkr|dt|VqdS)Nr_=r)r attr_namerir`ra 5s z&BaseWindow.__repr__..,z [])rGjoinrsry)r_Z attrs_listattrsr`rira__repr__1s   zBaseWindow.__repr__ccs|j|j}||}|}|jt||j|j|j d\}}| ||t|t ||D]\}}|j t ||}|Vq\dSNZ num_valuesrPrQrU) _selected_objZset_axisrIr_get_window_indexerrvrrPrQrUrzipZilocslice)r_rOindexerr|r}seresultr`r`ra__iter__=s  zBaseWindow.__iter__r valuesrkc Cst|jr*tdt|jd|jdndz*t|trJ|jtj tj d}nt |}Wn8t t fk r}zt d|j|W5d}~XYnXt|}|rt|tj |}|S)z1Convert input to numpy arrays for Cython routineszops for z for this dtype z are not implemented)Zna_valuezcannot handle this type -> N)rdtypeNotImplementedErrorrsryr\r to_numpynprnanrr]rrisinfanywhere)r_rerrinfr`r`ra _prep_valuesNs   $ zBaseWindow._prep_valuesr?)rrOrkc Csddlm}|jdk r|j|js|jj}||j|jj|d}||jkrT|||<nd||jj krbnV||j jkr|j j}|j}| |}| |d|} t | } || ||n|||<dS)Nrr@rZname)pandasr@rTrIequalsrZrrOr[namesrZget_loc intersectionrinsert) r_rrOr@rZ extra_colZold_colsZnew_colsZold_locoverlapnew_locr`r`ra_insert_on_columngs       zBaseWindow._insert_on_columncCst|jjr|jjSdSr)rrIrZasi8rir`r`ra _index_arrays zBaseWindow._index_array)outrOrkcCsN|jddkr&|jddkr&tdn|jddkr>|dS||||S)zValidate and finalize result.rrNo numeric types to aggregater)shaper!rr)r_rrOr`r`ra_resolve_outputs    zBaseWindow._resolve_outputr#cCs<t|jtr|jS|jdk r0t|j|j|jdSt|jdS)z[ Return an indexer class that will compute the window start and end bounds N) index_array window_sizerQ)r)r\rWr#rYr&rrQr$rir`r`rars  zBaseWindow._get_window_indexerzCallable[..., ArrayLike]r@)homogeneous_funcrrkc Cs||j}|dkr"t|t}z||j}Wn0ttfk rb}zt d|W5d}~XYnX||}|j ||j |j dS)z4 Series version of _apply_blockwise countrNr) rrrrr{rZ_valuesrrrr! _constructorrZr)r_rrrOrrrr`r`ra _apply_seriess zBaseWindow._apply_seriesDataFrame | Seriesc sRjjdkr|Sj}|dkrFt|t}|j|_dddfdd }j dkrl|j }g}g}t | D]B\}}z ||} Wnt tfk rYqX|| ||qt|j||j|j|dd} j dkr| j } d t|krt|jkrFnn,|j|j|} tjd | ttd | |S) zl Apply the given function to the DataFrame broken down into homogeneous sub-frames. rrr rcs|}|Sr)rrrr_r`rahfuncs z*BaseWindow._apply_blockwise..hfuncF)rZr[verify_integrityrzDropping of nuisance columns in rolling operations is deprecated; in a future version this will raise TypeError. Select only valid columns before calling the operation. Dropped columns were rc)rrrrrrr{rrrST enumerateZ_iter_column_arraysrrrappendrsZ _from_arraysrZr[takerrrfrgrhrr) r_rrrOrZtakerZ res_valuesiZarrresZdfZdroppedr`rra_apply_blockwisesD          & zBaseWindow._apply_blockwisecCs~|jjdkrtd||j}||}|jdkr>|jn|}||}|jdkrZ|jn|}|j||j |j d}| ||S)zT Apply the given function to the DataFrame across the entire object rz1method='table' not applicable for Series objects.rZr[) rrr]rrrrSrrrZr[r)r_rrrOrrrr`r`ra_apply_tablewises  zBaseWindow._apply_tablewiseDataFrame | Series | None bool | NoneFCallable[[DataFrame | Series, DataFrame | Series], DataFrame | Series]targetotherpairwisefuncrkcCsH|dkr|}|dkrdn|}nt|ttfs4tdt|||t|dS)] Apply the given pairwise function given 2 pandas objects (DataFrame/Series) NTz#other must be a DataFrame or Series)r)r\rrr]r/rL)r_rrrrr`r`ra_apply_pairwises zBaseWindow._apply_pairwiser`Callable[..., Any]tuple[Callable, str] | Nonetuple[Any, ...]rrnumba_cache_key numba_argsc s`jdk rjnjddfdd }jdkrP||S||SdS)a@ Rolling statistical measure using supplied function. Designed to be used with passed-in Cython array-based functions. Parameters ---------- func : callable function to apply name : str, numba_cache_key : tuple caching key to be used to store a compiled numba func numba_args : tuple args to be passed when func is a numba func **kwargs additional arguments for rolling function and window function Returns ------- y : type of input Nrzrc sZ|jdkr|Sfdd}tjdd||}W5QRXdk rVt<|S)NrcsDjt|jjd\}}||t||||fSr)rvrrQrUr)xr|r})rrPrr_window_indexerr`racalc:s z9BaseWindow._apply..homogeneous_func..calcrall)sizerrerrstater-rrrrrPrrr_rr`rar4s  z+BaseWindow._apply..homogeneous_funcrJ)rrPrrVrrr_rrrrrrr`rra_applys  zBaseWindow._applydict[str, bool] | None)rnumba_cache_key_str engine_kwargscGs|}|jdk r|jn|j}||j}|jdkr:|j}||}|j dkr^| dd}|j t |||j |jd\} } || | t |t|||} | || | |f|} | t||f<|jdkr| jn| } |j dkr| } |j| |j|jd} | S|j| |j|jd} || |SdS)Nrrrr)rrPrrrrSrrrrZreshapervrrQrUrrZgenerate_shared_aggregatorr-ZsqueezerrZrr[r)r_rrrZ func_argsrrPrOrr|r}Z aggregatorrrr`r`ra _numba_applyRs@       zBaseWindow._numba_applycOs2t||||d}|dkr.|j|d||dS|S)NargsrF)rawr r)raggapplyr_rr rrr`r`ra aggregatezszBaseWindow.aggregate)NNFNrNNrJ)N)N)N)N)NNr`)N)"ry __module__ __qualname____doc__rG__annotations__ frozensetrHrbpropertyrRrlrnr^rrrrrrrrrrrrrrrrrr rr r`r`r`rarEpsb    , &     <E(rEcseZdZUdZded<ded<dgZded<dd d ddd fd d Zd#ddddd dfdd Zd dddd dfdd Zdddfdd Z d$fd!d" Z Z S)%BaseWindowGroupbyz3 Provide the groupby windowing facilities. rC_grouperrL _as_indexrFrGT)rr)rOrrcsTddlm}t||std||_||_|j|jjdd}tj |f||dS)NrrBzMust pass a BaseGrouper object.rr[errors) pandas.core.groupby.opsrCr\r]rrdroprsuperrb)r_rOrrr rrC __class__r`rarbs  zBaseWindowGroupby.__init__Nr`rrMrr)rrrrrkc sLtj||||f|}jj}|j}tjj} | |} fddjjD} t| t| krp|j| dd}jj } tjj } jj }|rt t|nt jgt jdfdd| D} |dk r|}t|tst|g}| t|j | t|j t| | | dd}||_jsH|jttt| d }|S) Ncs&g|]}|jjjks|dkr|qSr)rOrZr)rrrir`ra sz,BaseWindowGroupby._apply..rrrcsg|]}|qSr`)rrc)rr`rar!sFrr)level)rrrOrZrrrrrcodeslevelsindicesrr concatenatelistarrayintprr\r)Z from_arraysextendrZ reset_indexrange)r_rrrrrrZgrouped_object_indexZgrouped_index_nameZ groupby_keysZresult_index_namesZ drop_columnsr'r( group_indicesidx result_indexr)rr_rarsP       zBaseWindowGroupby._applyrrrrcs|j|jjdd}||}t|||dk rtfdd|jjDst }t fdd|jjDdd|jj D}g}g}t t t|D]6} tt| |} t| \} } || || qnr|jj}|jj}|jj} | rtt | ntjgtjd |jd kr4d n t |jfd d|D}tjtrt jj}t jj}t jj}n$tj\}}|g}|g}jjg}||}||}|jj|}t|||d d }|_S)rrrNc3s|]}t|tkVqdSr)r)rgroup)rr`rarsz4BaseWindowGroupby._apply_pairwise..csg|]}|jqSr`)rrrZ)rZ gb_indices)rr`rar!sz5BaseWindowGroupby._apply_pairwise..css|]}t|VqdSr)comZmaybe_make_list)rpairr`r`rarsr"rcsg|]}t|qSr`)rrepeatrr#)r repeat_byr`rar!sFr%)rrrrrrrr)rrr,rxmapr+rrr6r,rrr'r(r*r-rr[r\rZr)r)r_rrrrZold_result_lenZgb_pairsZ groupby_codesZgroupby_levelsZ gb_level_pairlabelsr'r(r0Z result_codesZ result_levelsZ result_namesZ idx_codesZ idx_levelsr2r)rrr7rrarsj                z!BaseWindowGroupby._apply_pairwiserrcs:|js.tt|jjtj}| |}t |S)r) emptyrr*r+rr)rrZint64rrr)r_rOZ groupby_orderrr`rar1s  zBaseWindowGroupby._create_datacs*|jdk r|j|j}tj|||dS)N)r)rTrOZ set_indexrIrr)r_rrrrr`rar?s zBaseWindowGroupby._gotitem)NNr`)N) ryrrrrrGrbrrrr __classcell__r`r`rrars =Trc szeZdZdZdddddddd gZfd d Zd d d dddZd;dddddddZee de de ddddd d!Z e Z ee ed"eed#eed$edd%d&d'd(d) d*d+Zee ed"eed#eed$edd%d&d,d-d) d.d/Zee d0ed"eed#eed$edd%d&d1d2d) dWindowa Provide rolling window calculations. Parameters ---------- window : int, offset, or BaseIndexer subclass Size of the moving window. If an integer, the fixed number of observations used for each window. If an offset, the time period of each window. Each window will be a variable sized based on the observations included in the time-period. This is only valid for datetimelike indexes. To learn more about the offsets & frequency strings, please see `this link `__. If a BaseIndexer subclass, the window boundaries based on the defined ``get_window_bounds`` method. Additional rolling keyword arguments, namely ``min_periods``, ``center``, and ``closed`` will be passed to ``get_window_bounds``. min_periods : int, default None Minimum number of observations in window required to have a value; otherwise, result is ``np.nan``. For a window that is specified by an offset, ``min_periods`` will default to 1. For a window that is specified by an integer, ``min_periods`` will default to the size of the window. center : bool, default False If False, set the window labels as the right edge of the window index. If True, set the window labels as the center of the window index. win_type : str, default None If ``None``, all points are evenly weighted. If a string, it must be a valid `scipy.signal window function `__. Certain Scipy window types require additional parameters to be passed in the aggregation function. The additional parameters must match the keywords specified in the Scipy window type method signature. on : str, optional For a DataFrame, a column label or Index level on which to calculate the rolling window, rather than the DataFrame's index. Provided integer column is ignored and excluded from result since an integer index is not used to calculate the rolling window. axis : int or str, default 0 If ``0`` or ``'index'``, roll across the rows. If ``1`` or ``'columns'``, roll across the columns. closed : str, default None If ``'right'``, the first point in the window is excluded from calculations. If ``'left'``, the last point in the window is excluded from calculations. If ``'both'``, the no points in the window are excluded from calculations. If ``'neither'``, the first and last points in the window are excluded from calculations. Default ``None`` (``'right'``). .. versionchanged:: 1.2.0 The closed parameter with fixed windows is now supported. method : str {'single', 'table'}, default 'single' .. versionadded:: 1.3.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. Returns ------- ``Window`` subclass if a ``win_type`` is passed ``Rolling`` subclass if ``win_type`` is not passed See Also -------- expanding : Provides expanding transformations. ewm : Provides exponential weighted functions. 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 **window** Rolling sum with a window length of 2 observations. >>> df.rolling(2).sum() B 0 NaN 1 1.0 2 3.0 3 NaN 4 NaN Rolling sum with a window span of 2 seconds. >>> df_time = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]}, ... index = [pd.Timestamp('20130101 09:00:00'), ... pd.Timestamp('20130101 09:00:02'), ... pd.Timestamp('20130101 09:00:03'), ... pd.Timestamp('20130101 09:00:05'), ... pd.Timestamp('20130101 09:00:06')]) >>> df_time B 2013-01-01 09:00:00 0.0 2013-01-01 09:00:02 1.0 2013-01-01 09:00:03 2.0 2013-01-01 09:00:05 NaN 2013-01-01 09:00:06 4.0 >>> df_time.rolling('2s').sum() B 2013-01-01 09:00:00 0.0 2013-01-01 09:00:02 1.0 2013-01-01 09:00:03 3.0 2013-01-01 09:00:05 NaN 2013-01-01 09:00:06 4.0 Rolling sum with forward looking windows with 2 observations. >>> indexer = pd.api.indexers.FixedForwardWindowIndexer(window_size=2) >>> df.rolling(window=indexer, min_periods=1).sum() B 0 1.0 1 3.0 2 2.0 3 4.0 4 4.0 **min_periods** Rolling sum with a window length of 2 observations, but only needs a minimum of 1 observation to calculate a value. >>> df.rolling(2, min_periods=1).sum() B 0 0.0 1 1.0 2 3.0 3 2.0 4 4.0 **center** Rolling sum with the result assigned to the center of the window index. >>> df.rolling(3, min_periods=1, center=True).sum() B 0 1.0 1 3.0 2 3.0 3 6.0 4 4.0 >>> df.rolling(3, min_periods=1, center=False).sum() B 0 0.0 1 1.0 2 3.0 3 3.0 4 6.0 **win_type** Rolling sum with a window length of 2, using the Scipy ``'gaussian'`` window type. ``std`` is required in the aggregation function. >>> df.rolling(2, win_type='gaussian').sum(std=3) B 0 NaN 1 0.986207 2 2.958621 3 NaN 4 NaN rWrPrQrRrSrTrUrVcstt|jts&td|jtddd}t||jd|_|jdkr\td|jt|j t rrt dnt |j r|j dkrtd|j dkrt d dS) NzInvalid win_type z scipy.signalz,Scipy is required to generate window weight.)extraz6BaseIndexer subclasses not implemented with win_types.r&window must be an integer 0 or greaterrJz+'single' is the only supported method type.)rr^r\rRrNr]rr_scipy_weight_generatorrWr#rrrV)r_signalrr`rar^#s$     zWindow._validaterzr{)roffsetrkcCsV|j|jdkrtd|dkrRtdg|j}t|d||j<t|t|}|S)zT Center the result in the window for weighted rolling aggregations. rz8Requested axis is larger then no. of argument dimensionsrN)rSrr]rrrtuple)r_rrAZ lead_indexerr`r`ra_center_window9szWindow._center_windowNr`z,Callable[[np.ndarray, int, int], np.ndarray]rMrrrc sNjjf|jr&tddndddfdd }||S)a Rolling with weights statistical measure using supplied function. Designed to be used with passed-in Cython array-based functions. Parameters ---------- func : callable function to apply name : str, use_numba_cache : tuple unused numba_args : tuple unused **kwargs additional arguments for scipy windows if necessary Returns ------- y : type of input rrrrzrc s`|jdkr|Sfdd}tjddt||}W5QRXjr\|}|S)Nrcs6ttjg}t||f}|jp2tSr)rr,rr*rPr)rZadditional_nansrrAr_rWr`rarnsz5Window._apply..homogeneous_func..calcrr)rrrrZasarrayrQrCrrDr`rarhs  z'Window._apply..homogeneous_func)r?rWrQrrrr`rDrarFsz Window._applyrz See Also -------- pandas.DataFrame.aggregate : Similar DataFrame method. pandas.Series.aggregate : Similar Series method. at 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.rolling(2, win_type="boxcar").agg("mean") A B C 0 NaN NaN NaN 1 1.5 4.5 7.5 2 2.5 5.5 8.5 zSeries/DataFrameZsee_alsoZexamplesklassrScOs(t||||d}|dkr$||}|S)Nr )rr rr`r`rar~s zWindow.aggregate ParametersReturnsSee Alsorrollingzweighted window sumsumZ window_methodZaggregation_descriptionZ agg_methodcOs*td||tj}|j|fddi|S)NrLr)nvvalidate_window_funcwindow_aggregationsZroll_weighted_sumrr_r r window_funcr`r`rarLs z Window.sumzweighted window meanmeancOs*td||tj}|j|fddi|S)NrSr)rNrOrPZroll_weighted_meanrrQr`r`rarSs z Window.meanz.. versionadded:: 1.0.0 zweighted window variancevarrddofcOs>td||ttj|d}|dd|j|fddi|S)NrTrUr)rNrOrrPZroll_weighted_varpopr)r_rVr rrRr`r`rarTs z Window.varz"weighted window standard deviationstdcOs(td||t|jf|dd|S)NrX)rVr)rNrOr0rTr_rVr rr`r`rarXsz Window.std)NNr`)r)r)ryrrrrGr^rCrrr1rrr r7r3r5r8r9rLrSrTrXr;r`r`rrar<IsP 8         r<c@s\eZdZddZd@ddddd d d d d ZddddddddZddddddddZddddddddZddddddddZddddddddZ dAdddddZ dBdddd ddd!d"d#Z dCdddd ddd!d$d%Z d&d'Z dDd d(d)d*Zd+d,ZdEd.d/d0d1d2ZdFd5ddd6d7d8ZdGd9d:d d;dd?ZdS)IRollingAndExpandingMixincCstj}|j|ddS)Nr)r)rProll_sumr)r_rRr`r`rarszRollingAndExpandingMixin.countFNrrLrMrtuple[Any, ...] | Nonedict[str, Any] | Nonerr enginerr rc Cs|dkr d}|dkri}t|s(tdd}d}t|r|dkrHtdt|j} |}|jdkr~t|||| } || df}qt|||| d} || df}n2|d kr|dk rtd |||||} ntd |j | ||d S) Nr`z'raw parameter must be `True` or `False`Fz.raw must be `True` when using the numba enginerJZ _apply_singlerZ _apply_table)cythonNz+cython engine does not accept engine_kwargsz)engine must be either 'numba' or 'cython')rr) rr]r.rsryrVr=r>_generate_cython_apply_funcr) r_rr r_rr rrrZ caller_name apply_funcr`r`rarsL   zRollingAndExpandingMixin.applyrzdict[str, Any]z?Callable[[np.ndarray, np.ndarray, np.ndarray, int], np.ndarray])r rr rrkcs8ddlmttj||||d|ffdd }|S)Nrr)r rr rcs |s|jd}||||S)N)rZ)rI)rbeginr}rPr r@r_rRr`rarb:szHRollingAndExpandingMixin._generate_cython_apply_func..apply_func)rr@rrPZ roll_apply)r_r rr rrbr`rdrara)s z4RollingAndExpandingMixin._generate_cython_apply_funcr_rcOsrtd||t|rV|jdkr.zsqrt_funcr) rNrOr.rVrrhrur0r rProll_varr)r_rVr_rr rrurwr`rvrarXs"   zRollingAndExpandingMixin.stdcOsjtd||t|rF|jdkr*tdnddlm}||d||Stt j |d}|j |fddi|S) NrTrqz%var not supported with method='table'rrtZ rolling_varrUr) rNrOr.rVrrhrur rrPrxr)r_rVr_rr rrurRr`r`rarTs&   zRollingAndExpandingMixin.varcKstj}|j|fddi|S)Nrskew)rPZ roll_skewrr_rrRr`r`raryszRollingAndExpandingMixin.skewrUcOs|j||||dSN?rXrpowrYr`r`rasemszRollingAndExpandingMixin.semcKstj}|j|fddi|S)Nrkurt)rPZ roll_kurtrrzr`r`rarszRollingAndExpandingMixin.kurtlinearfloatrNquantile interpolationcKsF|dkrtj}n |dkr tj}nttj||d}|j|fddi|S)Ng?grrr)rPrlrorZ roll_quantiler)r_rrrrRr`r`rarsz!RollingAndExpandingMixin.quantileaverageTrrV ascendingpctcKs(ttj|||d}|j|fddi|S)N)rVrZ percentilerrank)rrPZ roll_rankr)r_rVrrrrRr`r`rarszRollingAndExpandingMixin.rankrrrrrVc s.ddlmfdd}j|||S)Nrrc s|}|}}jdk r,jn|j}|jt||jjd\}}||t|t j ddrt |||||}t ||||} t ||||} t t||t j||d} || | | | } W5QRX| |j|jdS)Nrrrrr)rrrPrrvrrQrUrrrrPrqr[rrrrZr) ryx_arrayy_arrayrrPr|r}mean_x_ymean_xmean_y count_x_yrr@rVr_r`racov_func+s>   "z.RollingAndExpandingMixin.cov..cov_funcrr@rr)r_rrrVrrr`rracov"s zRollingAndExpandingMixin.covc s.ddlmfdd}j|||S)Nrrc s0|}|}}jdk r,jn|j}|jt||jjd\}}||t|t j ddt |||||}t ||||} t ||||} t t||t j||d} t ||||} t ||||} || | | | }| | d}||}W5QRX||j|jdS)Nrrrrr|r)rrrPrrvrrQrUrrrrPrqr[rrrrxrZr)rrrrrrPr|r}rrrrZx_varZy_var numerator denominatorrrr`ra corr_funcTsb      z0RollingAndExpandingMixin.corr..corr_funcr)r_rrrVrrr`rracorrJs 'zRollingAndExpandingMixin.corr)FNNNN)NN)r)r)r)r)rTF)NNr)NNr)ryrrrrrarLrirnrSrrrXrTryrrrrrrr`r`r`rarZsb/*rZcseZdZUddddddddgZd ed <fd d Zd dZddddZee de de ddddfddZ e Z ee edeedeede dddd d!d"d#d$ fd%d&Zee ed'eedeeded(d)d!d*d+d$ dd-d.d/d0d1d2d3fd4d5 Zee ed'eeeedeedeed6eede d7ddd d!d8d8d$d(d(d9d/d0d9fd:d;Zee ed'eeeedeedeed6ed(d)d!dd?Zee ed'eeeedeedeed6eede d@ddd d!dAdBd$d(d(d9d/d0d9fdCdDZee ed'eeeedeedeed6eede dEddd d!dFdFd$d(d(d9d/d0d9fdGdHZee ed'eeedeedeed6eede dIddd d!dJdJd$dd/d0d9fdKdL Zee ed'e dMddd eedNeedeeddOeed6e dPddd ede dQddd d!dRdSd$dd(d(d9dTd/d0dUfdVdWZee ed'e dMddd eedNeedeeddXeed6e dYddd ede dZddd d!d[d\d$dd(d(d9dTd/d0dUfd]d^Zee ed'eedeedd_eed6d`d!dadbd$ fdcddZ ee ed'e dMddd eeedeedeed6deede dfddd d!dgdhd$ddTdidjdkZ!ee ed'eedeeddleed6dmede dnddd d!dodpd$fdqdrZ"ee ed'e dsddd eedeedeede dtddd d!dudud$ ddwddxfdydz Z#ee d{ed'e d|ddd eedeedeede d}ddd d!d~d~d$ddd.d.dfdd Z$ee ed'e dddd eedeeded(d)d!ddd$ ddddTdfdd Z%ee ed'e dddd eedeede dddd eed6e dddd ede dddd d!ddd$ddddTdfdd Z&Z'S)RollingrWrPrQrRrSrTrUrVrFrGc st|jjs$t|jtttfrt|j t t t fr| zt|j }Wn:ttfk r}ztd|j d|W5d}~XYnXt|jtr|j|jjj|jjj|_n|j|_|jdkrd|_n,t|j trdSt|j r|j dkrtddS)Nzpassed window z, is not compatible with a datetimelike indexrrr>)rr^rOr:r\rIr'r+r*rWrNr r _validate_datetimelike_monotonicr rrr]ZnanosrenrYrPr#r)r_rerrr`rar^s2     zRolling._validatecCs0|jjr|d|jjs,|jjs,|ddS)z Validate self._on is monotonic (increasing or decreasing) and has no NaT values for frequency windows. values must not have NaTzvalues must be monotonicN)rIhasnans_raise_monotonic_erroris_monotonic_increasingis_monotonic_decreasingrir`r`rars z(Rolling._validate_datetimelike_monotonicrN)msgcCs8|j}|dkr"|jdkrd}nd}t|d|dS)NrrZcolumn )rTrSr])r_rrTr`r`rars  zRolling._raise_monotonic_errorrz See Also -------- pandas.Series.rolling : Calling object with Series data. pandas.DataFrame.rolling : Calling object with DataFrame data. 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.rolling(2).sum() A B C 0 NaN NaN NaN 1 3.0 9.0 15.0 2 5.0 11.0 17.0 >>> df.rolling(2).agg({"A": "sum", "B": "min"}) A B 0 NaN NaN 1 3.0 4.0 2 5.0 5.0 zSeries/DataframerErFcstj|f||Sr)rr)r_rr rrr`rars&zRolling.aggregaterIrJZExamplesa >>> s = pd.Series([2, 3, np.nan, 10]) >>> s.rolling(2).count() 0 1.0 1 2.0 2 1.0 3 1.0 dtype: float64 >>> s.rolling(3).count() 0 1.0 1 2.0 2 2.0 3 2.0 dtype: float64 >>> s.rolling(4).count() 0 1.0 1 2.0 2 2.0 3 3.0 dtype: float64  rrKzcount of non NaN observationsrrMcsB|jdkr4tjdttdd|_t}d|_n t}|S)Nzmin_periods=None will default to the size of window consistent with other methods in a future version. Specify min_periods=0 instead.rcr)rPrfrgrhrrr)r_rrr`rars#    z Rolling.countrHNrzcustom aggregation functionrFrrLrMrr\r]r^cstj||||||dS)N)r r_rr r)rr)r_rr r_rr rrr`rarsz Rolling.applyZNotesa] >>> s = pd.Series([1, 2, 3, 4, 5]) >>> s 0 1 1 2 2 3 3 4 4 5 dtype: int64 >>> s.rolling(3).sum() 0 NaN 1 NaN 2 6.0 3 9.0 4 12.0 dtype: float64 >>> s.rolling(3, center=True).sum() 0 NaN 1 6.0 2 9.0 3 12.0 4 NaN dtype: float64 For DataFrame, each sum is computed column-wise. >>> df = pd.DataFrame({{"A": s, "B": s ** 2}}) >>> df A B 0 1 1 1 2 4 2 3 9 3 4 16 4 5 25 >>> df.rolling(3).sum() A B 0 NaN NaN 1 NaN NaN 2 6.0 14.0 3 9.0 29.0 4 12.0 50.0 rLrecs&td||tj|||d|S)NrLre)rNvalidate_rolling_funcrrLr_r_rr rrr`rarL<sGz Rolling.summaximumrics&td||tj|||d|S)Nrire)rNrrrirrr`rarisz Rolling.maxz Performing a rolling minimum with a window size of 3. >>> s = pd.Series([4, 3, 5, 2, 6]) >>> s.rolling(3).min() 0 NaN 1 NaN 2 3.0 3 2.0 4 2.0 dtype: float64 minimumrncs&td||tj|||d|S)Nrnre)rNrrrnrrr`rarns&z Rolling.mina The below examples will show rolling mean calculations with window sizes of two and three, respectively. >>> s = pd.Series([1, 2, 3, 4]) >>> s.rolling(2).mean() 0 NaN 1 1.5 2 2.5 3 3.5 dtype: float64 >>> s.rolling(3).mean() 0 NaN 1 NaN 2 2.0 3 3.0 dtype: float64 rScs&td||tj|||d|S)NrSre)rNrrrSrrr`rarSs-z Rolling.meana  Compute the rolling median of a series with a window size of 3. >>> s = pd.Series([0, 1, 2, 3, 4]) >>> s.rolling(3).median() 0 NaN 1 NaN 2 1.0 3 2.0 4 3.0 dtype: float64 rrc stjf||d|S)Nre)rrr)r_r_rrrr`rarrs$zRolling.medianz ddof : int, default 1 Delta Degrees of Freedom. The divisor used in calculations is ``N - ddof``, where ``N`` represents the number of elements. z1.4z/numpy.std : Equivalent method for NumPy array. aK The default ``ddof`` of 1 used in :meth:`Series.std` is different than the default ``ddof`` of 0 in :func:`numpy.std`. A minimum of one period is required for the rolling calculation. The implementation is susceptible to floating point imprecision as shown in the example below. a& >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5]) >>> s.rolling(3).std() 0 NaN 1 NaN 2 5.773503e-01 3 1.000000e+00 4 1.000000e+00 5 1.154701e+00 6 2.580957e-08 dtype: float64 zstandard deviationrXr{rscs(td||tjf|||d|S)NrXrs)rNrrrXr_rVr_rr rrr`rarXs9z Rolling.stdz/numpy.var : Equivalent method for NumPy array. aK The default ``ddof`` of 1 used in :meth:`Series.var` is different than the default ``ddof`` of 0 in :func:`numpy.var`. A minimum of one period is required for the rolling calculation. The implementation is susceptible to floating point imprecision as shown in the example below. a& >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5]) >>> s.rolling(3).var() 0 NaN 1 NaN 2 3.333333e-01 3 1.000000e+00 4 1.000000e+00 5 1.333333e+00 6 6.661338e-16 dtype: float64 ZvariancerTcs(td||tjf|||d|S)NrTrs)rNrrrTrrr`rarT]s9z Rolling.varz:scipy.stats.skew : Third moment of a probability density. zDA minimum of three periods is required for the rolling calculation. zunbiased skewnessryc stjf|Sr)rryr_rrr`rarysz Rolling.skewz:A minimum of one period is required for the calculation. z >>> s = pd.Series([0, 1, 2, 3]) >>> s.rolling(2, min_periods=1).sem() 0 NaN 1 0.707107 2 0.707107 3 0.707107 dtype: float64 zstandard error of meanrrUcOs|j||||dSr{r}rYr`r`rars#z Rolling.semz/scipy.stats.kurtosis : Reference SciPy method. z>> arr = [1, 2, 3, 4, 999] >>> import scipy.stats >>> print(f"{{scipy.stats.kurtosis(arr[:-1], bias=False):.6f}}") -1.200000 >>> print(f"{{scipy.stats.kurtosis(arr[1:], bias=False):.6f}}") 3.999946 >>> s = pd.Series(arr) >>> s.rolling(4).kurt() 0 NaN 1 NaN 2 NaN 3 -1.200000 4 3.999946 dtype: float64 z,Fisher's definition of kurtosis without biasrc stjf|Sr)rrrrr`rars&z Rolling.kurta quantile : float Quantile to compute. 0 <= quantile <= 1. interpolation : {{'linear', 'lower', 'higher', 'midpoint', 'nearest'}} This optional parameter specifies the interpolation method to use, when the desired quantile lies between two data points `i` and `j`: * linear: `i + (j - i) * fraction`, where `fraction` is the fractional part of the index surrounded by `i` and `j`. * lower: `i`. * higher: `j`. * nearest: `i` or `j` whichever is nearest. * midpoint: (`i` + `j`) / 2. ae >>> s = pd.Series([1, 2, 3, 4]) >>> s.rolling(2).quantile(.4, interpolation='lower') 0 NaN 1 1.0 2 2.0 3 3.0 dtype: float64 >>> s.rolling(2).quantile(.4, interpolation='midpoint') 0 NaN 1 1.5 2 2.5 3 3.5 dtype: float64 rrrrc stjf||d|S)Nr)rr)r_rrrrr`rars 0zRolling.quantilez.. versionadded:: 1.4.0 a method : {{'average', 'min', 'max'}}, default 'average' How to rank the group of records that have the same value (i.e. ties): * average: average rank of the group * min: lowest rank in the group * max: highest rank in the group ascending : bool, default True Whether or not the elements should be ranked in ascending order. pct : bool, default False Whether or not to display the returned rankings in percentile form. a( >>> s = pd.Series([1, 4, 2, 3, 5, 3]) >>> s.rolling(3).rank() 0 NaN 1 NaN 2 2.0 3 2.0 4 3.0 5 1.5 dtype: float64 >>> s.rolling(3).rank(method="max") 0 NaN 1 NaN 2 2.0 3 2.0 4 3.0 5 2.0 dtype: float64 >>> s.rolling(3).rank(method="min") 0 NaN 1 NaN 2 2.0 3 2.0 4 3.0 5 1.0 dtype: float64 rrTrrc stjf|||d|S)Nr)rr)r_rVrrrrr`rar0 sDz Rolling.ranka 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 MultiIndexed DataFrame in the case of DataFrame inputs. In the case of missing elements, only complete pairwise observations will be used. ddof : int, default 1 Delta Degrees of Freedom. The divisor used in calculations is ``N - ddof``, where ``N`` represents the number of elements. zsample covariancerrrrc stjf|||d|SNr)rrr_rrrVrrr`rar{ s$z Rolling.covz cov : Similar method to calculate covariance. numpy.corrcoef : NumPy Pearson's correlation calculation. ao This function uses Pearson's definition of correlation (https://en.wikipedia.org/wiki/Pearson_correlation_coefficient). When `other` is not specified, the output will be self correlation (e.g. all 1's), except for :class:`~pandas.DataFrame` inputs with `pairwise` set to `True`. Function will return ``NaN`` for correlations of equal valued sequences; this is the result of a 0/0 division error. When `pairwise` is set to `False`, only matching columns between `self` and `other` will be used. When `pairwise` is set to `True`, the output will be a MultiIndex DataFrame with the original index on the first level, and the `other` DataFrame columns on the second level. In the case of missing elements, only complete pairwise observations will be used. a  The below example shows a rolling calculation with a window size of four matching the equivalent function call using :meth:`numpy.corrcoef`. >>> v1 = [3, 3, 3, 5, 8] >>> v2 = [3, 4, 4, 4, 8] >>> # numpy returns a 2X2 array, the correlation coefficient >>> # is the number at entry [0][1] >>> print(f"{{np.corrcoef(v1[:-1], v2[:-1])[0][1]:.6f}}") 0.333333 >>> print(f"{{np.corrcoef(v1[1:], v2[1:])[0][1]:.6f}}") 0.916949 >>> s1 = pd.Series(v1) >>> s2 = pd.Series(v2) >>> s1.rolling(4).corr(s2) 0 NaN 1 NaN 2 NaN 3 0.333333 4 0.916949 dtype: float64 The below example shows a similar rolling calculation on a DataFrame using the pairwise option. >>> matrix = np.array([[51., 35.], [49., 30.], [47., 32.], [46., 31.], [50., 36.]]) >>> print(np.corrcoef(matrix[:-1,0], matrix[:-1,1]).round(7)) [[1. 0.6263001] [0.6263001 1. ]] >>> print(np.corrcoef(matrix[1:,0], matrix[1:,1]).round(7)) [[1. 0.5553681] [0.5553681 1. ]] >>> df = pd.DataFrame(matrix, columns=['X','Y']) >>> df X Y 0 51.0 35.0 1 49.0 30.0 2 47.0 32.0 3 46.0 31.0 4 50.0 36.0 >>> df.rolling(4).corr(pairwise=True) X Y 0 X NaN NaN Y NaN NaN 1 X NaN NaN Y NaN NaN 2 X NaN NaN Y NaN NaN 3 X 1.000000 0.626300 Y 0.626300 1.000000 4 X 1.000000 0.555368 Y 0.555368 1.000000 Z correlationrc stjf|||d|Sr)rrrrr`rar s{z Rolling.corr)FNNNN)NN)r)r)r)r)rTF)NNr)NNr)(ryrrrGrr^rrrr1rrr r7r3r8r9replacerr;rr2r:r4r6rLrirnrSrrrXrTryrrrrrrr;r`r`rrar~s  "  %"  ./C    " )      3    3   "%/?  78vrc@s2eZdZdZejejZddddZddZdS) RollingGroupbyz3 Provide a rolling groupby implementation. r%rjcCsd}|j}t|jtrNt|j}|jj}t|ts:t| dd|j}n |j dk rdt }|j }n t }|j}t |||jj||d}|S)z Return an indexer class that will compute the window start and end bounds Returns ------- GroupbyIndexer Nr)rrZgroupby_indicesrindexer_kwargs)rr\rWr#rs__dict__rdictAssertionErrorrWrYr&r$r%rr))r_rrZrolling_indexerrWrr`r`rar) s*      z"RollingGroupby._get_window_indexercCsj|jjr|d|jjD]F}|j|}|js|js|j dkrHdn|j }t d|d|dqdS)zC Validate that each group in self._on is monotonic rNrZzEach group within z' must be monotonic. Sort the values in z first.) rIrrrr)rrrrrTr])r_r0Zgroup_onrTr`r`rarJ s  z/RollingGroupby._validate_datetimelike_monotonicN) ryrrrrrGrrrr`r`r`rar" s !r)vr __future__rrdatetimer functoolsrrttextwraprtypingrrrr rfnumpyrZpandas._libs.tslibsr r Z pandas._libs.window.aggregationsZ_libsrWZ aggregationsrPZpandas._typingr r rrZpandas.compat._optionalrZpandas.compat.numpyrrNZpandas.util._decoratorsrZpandas.util._exceptionsrZpandas.core.dtypes.commonrrrrrrZpandas.core.dtypes.genericrrZpandas.core.dtypes.missingrZpandas.core._numbarZpandas.core.algorithmsrZpandas.core.applyrZpandas.core.arraysr Zpandas.core.baser!r"Zpandas.core.commoncorecommonr4Zpandas.core.indexers.objectsr#r$r%r&Zpandas.core.indexes.apir'r(r)r*r+Zpandas.core.reshape.concatr,Zpandas.core.util.numba_r-r.Zpandas.core.window.commonr/r0Zpandas.core.window.docr1r2r3r4r5r6r7r8r9r:r;Zpandas.core.window.numba_r<r=r>rr?r@Zpandas.core.genericrArrCZpandas.core.internalsrDrErr<rZrrr`r`r`ras|               4    G/ (