ehudZddlmZddlZddlmZddlmZddlZddl m Z ddl m Z m Z mZmZddlZddlmZmZmZddlmcmcmZdd lmZdd lmZdd lm Z m!Z!dd l"m#Z#m$Z$m%Z%m&Z&m'Z'dd l(m)Z)ddl*m+Z+m,Z,ddl-m.Z.ddl/m0Z0ddl1m2Z2ddl3m4Z4ddl5m6Z6ddl7m8Z8ddl9m:cm;Z<ddl=m>Z>m?Z?m@Z@mAZAddlBmCZCmDZDmEZEmFZFmGZGddlHmIZIddlJmKZKmLZLddlMmNZNmOZOddlPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZddl[m\Z\m]Z]m^Z^e r.ddl_m`Z`maZambZbddlcmdZdmeZemfZfmgZgmhZhmiZiddljmkZkmlZlddlmmnZndd lompZpdd!lqmrZrGd"d#e8ZsGd$d%esZtGd&d'esZuGd(d)esZvGd*d+evZweujew_Gd,d-etewZxy).zc Provide a generic structure to support window functions, similar to how we have a Groupby object. ) annotationsN) timedelta)partial)dedent) TYPE_CHECKINGAnyCallableLiteral) BaseOffset Timedelta to_offset)import_optional_dependency) DataError)deprecate_kwargdoc)ensure_float64is_bool is_integeris_numeric_dtypeneeds_i8_conversion) ArrowDtype) ABCDataFrame ABCSeries)notna)executor) factorize)ResamplerWindowApply)ExtensionArray)SelectionMixin) BaseIndexerFixedWindowIndexerGroupbyIndexerVariableWindowIndexer) DatetimeIndexIndex MultiIndex PeriodIndexTimedeltaIndex)concat)get_jit_argumentsmaybe_use_numba)flex_binary_momentzsqrt) _shared_docscreate_section_headerkwargs_numeric_only 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)HashableIteratorSized) ArrayLikeAxisNDFrameTQuantileInterpolationWindowingRankTypenpt) DataFrameSeries)NDFrame BaseGrouper) dtype_to_unitceZdZUdZgZded<eZded<ded< d"dd  d#d Zd$d Z d%d Z d&d'd Z d(dZ d)dZ d*d+dZd&dZd,dZdZd-dZd.dZd/dZd0dZed1dZd2dZd3dZ d& d4dZ d* d5dZ d6 d7dZ d8dZ d9 d:dZ d& d;d Zd!Z e Z!y)< BaseWindowz7Provides utilities for performing windowing operations. list[str] _attributeszfrozenset[Hashable] exclusionsr%_onN) selectionc ||_||_||_| |_||_||_||_||_||j|nd|_ | |_ d|_ |jG|jdk(r|jj|_ n|jj|_ nt|jt r|j|_ n}t|jt"rJ|j|jjvr(t!|j|j|_ nt%d|jd| |_|j)y)Nrzinvalid on specified as z3, must be a column (of DataFrame), an Index or None)objonclosedstepwindow min_periodscenterwin_type_get_axis_numberaxismethod _win_freq_i8indexrOcolumns isinstancer%r ValueError _selection _validate) selfrRrVrWrXrYr[rSrTrUr\rPs X/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/pandas/core/window/rolling.py__init__zBaseWindow.__init__s'   &   262BC((.  (, 77?yyA~88>> 88++  'wwDH , /DGGtxx?O?O4OTXXdgg./DH*477)4DD  $ c|j t|js td|jt |js td|jdkr tdt |j r>|j|j kDr%td|jd|j |j |j dvr tdt|jttfstd t|t|j trtj|j j j"j%}tjtj j"j%}||k7r+tt|j j&d |j(d vr td |j*;t |j*s td |j*dkr tdyy)Nzcenter must be a booleanzmin_periods must be an integerrzmin_periods must be >= 0z min_periods z must be <= window )rightbothleftneitherz3closed must be 'right', 'left', 'both' or 'neither'zinvalid type: z? does not implement the correct signature for get_window_bounds)tablesinglez!method must be 'table' or 'singlezstep must be an integerzstep must be >= 0)rXrrarWrrVrTr`rRrr TypeErrortyper inspect signatureget_window_bounds parameterskeys__name__r\rU)rdget_window_bounds_signatureexpected_signatures rerczBaseWindow._validates ;; "74;;+?78 8    'd../ !ABB!# !;<<$++&4+;+;dkk+I "4#3#3"44G }U ;; "t{{; ( RS S$((Y $=>nT$ZL9: : dkk; /+2*;*; --+j (")!2!2 //"j +.@@ DKK(1123BC ;;1 1@A A 99 dii( !:;;yy1} !455 !rgc 0t|t|k7r$tdt|dt|dt|||jxsdzdz |jxsdzk7r(tdt|d|d|jdy) Nzstart (z ) and end (z ) bounds must be the same lengthzstart and end bounds (z)) must be the same length as the object (z) divided by the step (z) if given and rounded up)lenrarU)rdstartendnum_valss re_check_window_boundszBaseWindow._check_window_boundss u:S !#e*[S ;  u:(diin159tyy~AN N(U 5""*+B499+N*+  Orgc\|t|t|k(r|S|dd|jS)zJ Slices the index for a given result and the preset step. N)r{rU)rdr^results re_slice_axis_for_stepzBaseWindow._slice_axis_for_steps9 ~VE !:  |$))|$ rgc|jjdk(rG|rDt|jjs$t t |j d|dyyy)z Validate numeric_only argument, raising if invalid for the input. Parameters ---------- name : str Name of the operator (kernel). numeric_only : bool Value passed by user. rz.z does not implement numeric_onlyN) _selected_objndimrdtypeNotImplementedErrorrprv)rdname numeric_onlys re_validate_numeric_onlyz!BaseWindow._validate_numeric_onlysg    # #q ($T%7%7%=%=>%:&&'q.NO ? )rgc0|jdgdg}|S)zSubset DataFrame to numeric columns. Parameters ---------- obj : DataFrame Returns ------- obj subset to numeric-only columns. numberr)includeexclude) select_dtypes)rdrRrs re_make_numeric_onlyzBaseWindow._make_numeric_onlys"""H: }"M rgc|j`t|jtsF|jdk(r7|j |j j |jgd}|jdkDr"|s|jdk(r|j|}|jdk(r2|jdd}|jj|_ |S)A Split data into blocks & return conformed data. F)r_copyrzfloat64)r) rSr`r%rreindexr_ differencer[rastype_mgr consolidate)rdrRrs re _create_datazBaseWindow._create_datas 77 z$''5'AchhRSm++ckk&<&**YU*3Cxx++-CH rgc| |j}|jDcic]}|t||}}|j||}t ||fd|i|}|Scc}w)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 rP)rRrMgetattr_infer_selectionrp)rdkeyrsubsetattrkwargsrPnew_wins re_gotitemzBaseWindow._gotitem#sp >XXF9=8H8HI$d++II))#v6 $t*VCyCFC JsAc||jvrtj||S||jvr||St dt |j d|d)N'z' object has no attribute ')_internal_names_setobject__getattribute__rRAttributeErrorrprv)rdrs re __getattr__zBaseWindow.__getattr__;sd 4++ +**46 6 488 : T ##$$?vQ G  rgc6|jjSN)rR_dir_additionsrds rerzBaseWindow._dir_additionsEsxx&&((rgcfdjD}dj|}tjd|dS)z@ Provide a nice str repr of our rolling object. c3jK|]*}t|d|ddk7r|dt|,yw)Nr_=)r).0 attr_namerds re z&BaseWindow.__repr__..LsF tY-9ilc>Qk7434 5 s03,z [])rMjoinrprv)rd attrs_listattrss` re__repr__zBaseWindow.__repr__HsF !-- $t*%%&bq11rgc#K|jj|j}|j|}|j }|j t ||j|j|j|j\}}|j||t |t||D]"\}}|jt||}|$ywN num_valuesrWrXrTrU)rset_axisrOr_get_window_indexerrsr{rWrXrTrUrzipilocslice)rdrRindexerr|r}sers re__iter__zBaseWindow.__iter__Ts  ))$((3$**,..3x((;;;; / s !!%c#h7sO DAqXXeAqk*FL sCC!ct|jr/tdt|jd|jd t |t r0|jtjtj}n t|}tj|}|jr%tj |tj|}|S#ttf$r}td|j|d}~wwxYw)z1Convert input to numpy arrays for Cython routineszops for z for this dtype z are not implemented)na_valuezcannot handle this type -> N)rrrrprvr`rto_numpynprnanrraroisinfanywhere)rdvalueserrinfs re _prep_valueszBaseWindow._prep_valuesfs v|| ,%4:../0&:<   S&.1bffE'/ hhv 779XXc26662F I& S9&,,HIs R SsA CD ,DD cXddlm}|j|jj |j s|jj }||j|jj |d}||jvr|||<y||j jvry||jjvrf|jj}|j}|j|}|j|d|} t| } |j| ||y|||<yyy)NrrEFr^rr)pandasrErSrOequalsr^rrRr_namesrget_loc intersectionr{insert) rdrrRrEr extra_colold_colsnew_colsold_locoverlapnew_locs re_insert_on_columnzBaseWindow._insert_on_column~s " 77 txxsyy'A88==Dtxxtxx~~DuUIv~~%(t +++++333--55!>>"**40"//'0BCg, gtY7 )t %(B rgcZt|jtttfr|jj St|jj trL|jj jdvr*|jjtjSy)NmMr) r`rOr'r$r(asi8rrkindrrint64rs re _index_arrayzBaseWindow._index_arraysm dhhm^ L M88==  38K8Kt8S88$$288$4 4rgc|jddk(r|jddkDr td|jddk(r|jdS|j|||S)zValidate and finalize result.rzrNo numeric types to aggregater)shaperrr)rdoutrRs re_resolve_outputzBaseWindow._resolve_outputsa 99Q<1 1!1;< < 99Q<1 ::i( ( sC( rgct|jtr |jS|j,t |j |j|j St|jS)z[ Return an indexer class that will compute the window start and end bounds ) index_array window_sizerX)r)r`rVr r]r#rrXr!rs rerzBaseWindow._get_window_indexers_ dkk; /;;     (( -- --{{  "dkk::rgc|j|j}|dk(rt|jt} |j |j }||}|j|j|}|j|||jS#ttf$r}td|d}~wwxYw)z5 Series version of _apply_columnwise countrNr^r)rrrrintr_valuesrorrrr^ _constructorr)rdhomogeneous_funcrrRrrrr^s re _apply_serieszBaseWindow._apply_seriess  2 23 7?*##C(C F&&s{{3F"&)))#))V<e#((CC ./ F;<# E FsBB=, B88B=c|j|||jjdk(r|j||S|j |j|}|dk(r=t |j t}|jj|_|jdk(r |j}g}g}t|jD]A\}} |j|}||} |j'| |j'|C|j)|j*t-|dkDr|dnd} t/|j1|| |j2j5|d} |jdk(r | j} |j7| |S#tt f$r} t#d|j$| d} ~ wwxYw)zl Apply the given function to the DataFrame broken down into homogeneous sub-frames. rzrz#Cannot aggregate non-numeric type: NrF)r^r_verify_integrity)rrrrrrrrrrr[T enumerate_iter_column_arraysrrorrrappendrr^r{rp _from_arraysr_taker) rdrrrrRtaker res_valuesiarrrresr^dfs re_apply_columnwisezBaseWindow._apply_columnwises ##D,7    " "a '%%&6= = 2 2LA 7?*##C(Cxx++-CH 99>%%C  7 7 9: FAs '', #3'C   c " LLO )) IIJ!(;z!} #Y # # KK$$U+" $  99>B##B,,+23 9#))E sF++G:GGcb|jjdk(r td|j|j|}|j |j }|j dk(r |jn|}||}|j dk(r |jn|}|j|j|}|jdt|jk(r |jn|jdd|j}|j|||} |j| |S)zT Apply the given function to the DataFrame across the entire object rzz1method='table' not applicable for Series objects.Nr^r_)rrrarrrr[rrr^rr{r_rUrr) rdrrrrRrrr^r_rs re_apply_tablewisezBaseWindow._apply_tablewises    " "a 'PQ Q 2 2LA""3<<>2!YY!^!&)!YY!^))#))V<||A#ckk"22 KK\ \*  vUGD##C--rgc|j||}| |}|dn|}nCt|ttfs t d|j dk(r|r|j |}t|||t|S)] Apply the given pairwise function given 2 pandas objects (DataFrame/Series) Tz#other must be a DataFrame or Seriesr)pairwise) rr`rrrarrr,bool)rdtargetotherrfuncrs re_apply_pairwisezBaseWindow._apply_pairwisesy""6<8 =E'/tXHEL)#<=BC C ZZ1_++E2E!&%XOOrgc jj jn jdfd }jdk(rj |||Sj |||S)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_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 c|jdk(r|jSfd}tjd5||}ddd|S#1swYSxYw)Nrcjt|jjj\}}j ||t||||gSr)rsr{rXrTrUr)xr|r}rrW numba_argsrdwindow_indexers recalcz9BaseWindow._apply..homogeneous_func..calcYsi+=="1v +;;;; > s))%c!f=Auc;DDDrgignoreall)sizerrerrstate)rrrrrWrrdrs rerz+BaseWindow._apply..homogeneous_funcSs^{{a{{}$ E E* &f &M &Ms AArnr np.ndarray)rrWrr\r r) rdrrrrrrrWrs `` ` @@re_applyzBaseWindow._apply2s~4113+   ++    . ;;( "))*:D,O O(()94N Nrgc <|j}|j |jn |j}|j|j}|j dk(r |j }|j|j}|jdk(r|jdd}|jt|||j|j|j\}} |j!|| t|t"j$} t#j&|| fddit)|} | |j f|| |d|j } |j dk(r | j n| } |j+|j,| } |jdk(r0| j/} |j1| | |j2}|S|j+|j4| j }|j1| | |}|j7||S) Nrzris_grouped_kernelF)r|r}rWrr)rrWrrrr[rrrrreshapersr{rXrTrUrrfloat_dtype_mappinggenerate_shared_aggregatorr*rr^squeezerrr_r)rdr engine_kwargs func_kwargsrrWrRrr|r} dtype_mapping aggregatorrr^rr_s re _numba_applyzBaseWindow._numba_applyos 113+   ++   2 23 99>%%C""3<<>2 ;;! ^^B*F#556{#;;;; 6 s !!%c&k: !44 88   $  .   HH !s  GR ! "YY!^))#))V< 88q=^^%F""6SXX"FCJ// VXXFG""6"HC''S1 1rgcnt||||j}||j|d||S|S)NargsrF)rawr5r)raggapplyrdrr5rrs re aggregatezBaseWindow.aggregates<%dDtFKOOQ >::dD:H H rg) NNFNrNNNrn)rRrFrW int | NonerX bool | NonerY str | Noner[r?rSzstr | Index | NonerTr=rUr;r\strreturnNoner?r@)r|r%r}r%r~rr?r@r)r^r%rz Sized | Noner?r%)rr>rrr?r@)rRr@r?r@FrRr@rrr?r@)rr>)r?r>)r?r<)rr>r?r%)rrDrRrDr?r@)r?znpt.NDArray[np.int64] | None)rrDrRrDr?rD)r?r )rCallable[..., ArrayLike]rr=r?rE)rrDrr>rrr?DataFrame | Series)NF)rrDrr=rrr?rE rrErDataFrame | Series | Nonerr<rzFCallable[[DataFrame | Series, DataFrame | Series], DataFrame | Series]rrr?rEF)rCallable[..., Any]rr>rrrtuple[Any, ...])rrJr.dict[str, bool] | None)"rv __module__ __qualname____doc__rM__annotations__ frozensetrNrfrcrrrrrrrrrrrrpropertyrrrrr rrr&r2r:r7rIrgrerKrKxseAK&/kJ#1 J "&##!%!++ + +  +  ++ ++++ +Z)6V  &0 ? ?  "hht}}228hD ::f  )%&HI I .t.v.rgc t|||||fi|}|jj}g|j}t j |j j} | |z} |j jD cgc](} | |jjjvs| | *} } t| t| k7r|j| d}|j j} t j |j j}|j jj}|rtjt|}n%tj gtj"}| Dcgc]}|j%|} }||j%|}t'|t(st)j*|g}| j-t|j|j-t|jt)|| | d}||_|j.s-|j1tt3t| }|Scc} wcc}w)NrrXrFrr)level)r]r&rRr^rrrUr{r[codeslevelsindicesrr concatenatelistarrayintprr`r& from_arraysextendrV reset_indexrange)rdrrrrrrgrouped_object_indexgrouped_index_name groupby_keysresult_index_namesr drop_columnsrbrc group_indicesrcidx result_indexr^s rer&zBaseWindowGroupby._applys         $xx~~:399:yy!4!45 ),>>}}** $((.....#+   | L 1 1[[h[GF ##4==//0 --446 nnT-%89Ghhr1G*/0Q00 +&++G4Cc:. ,,cU3 LLcii ) MM$szz* +! E!3e $ ~~''d5\9J3K.L'MF I $1s ?-I1I6c|j|jjd}t|||||}It fd|jj jDst|}t|jj jDcgc],}|j|j|j.c}}d|jj jD} g} g} ttt!| D][} t#j$t#j&| |} t)| \}}| j+|| j+|]n|jj,} |jj.} |jj j}|rt#j0t|}n%t#j&gt"j2}|j4dk(rd}nt|j6}| Dcgc]'}t#j$|j||)} }t9|jt:r^t|jj,}t|jj.}t|jj}n5t)|j\}}|g}|g}|jj<g}| |z}| |z}|jj|z}t;|||d}||_ |Scc}wcc}w) rrrXc3LK|]}t|tk(ywr)r{)rgrouprs rerz4BaseWindowGroupby._apply_pairwise..s#) ).CJ#e* $) s!$c3FK|]}tj|ywr)commaybe_make_list)rpairs rerz4BaseWindowGroupby._apply_pairwise..&s .2##D)s!rrzFr`)r[rUrr]rr!rdrr{r)rrr^rumaprfrrrepeatrgrrrbrcrerhrr_r`r&r)rdrrrrrrold_result_len gb_indicesgb_pairs groupby_codesgroupby_levels gb_level_pairlabelsrbrcrrr repeat_byrs result_codes result_levels result_names idx_codes idx_levelsrur^s ` rerz!BaseWindowGroupby._apply_pairwisesT]]%8%8J($ U  S) 26--2G2G2N2N2P) & ![N'+mm&;&;&B&B&D"KK +33FLLAF6:mm6K6K6P6P6RHMN!$T3>!: . 288M#:NK )& 1 v$$U+%%f-  .!MM//M"]]11N MM1188:M..m)<=((2RWW5{{a / ?L:; !&&/95M fllJ / 2 23L !4!45M 2 23L$-fll$; !Iz%;L'LM"LL--.L%|3 &6 }}**\9 ! <|e $  uFs -1M  ,M%c|jsntjt|jj j jtj}|j|}t|-||S)r) emptyrrerfrUrdrrrrr]r)rdrRr groupby_orderr^s rerzBaseWindowGroupby._create_data\sfyyNN4 0E0E0L0L0N+OPWWM((=)Cw#C66rgc|j%|jj|j}t||||S)N)r)rSrR set_indexrOr]r)rdrrrr^s rerzBaseWindowGroupby._gotitemjs> 77 XX''1FwT&99rg)rRrErUrHrVrr?r@rH) rrJrr>rrrrKr?rErFrBrCr) rvrMrNrOrPrMrfr&rrr __classcell__r^s@rerTrTsO(\K) / / /  / /6#&( ; ;; ; $ ; ;zR"R)R R U R  R Rh 7::rgrTcneZdZdZgdZfdZd#dZ d$ d%dZee de de dd d d Z e Z ee ed eeedeedeede dddd d&d'dZee ed eeedeedeede dddd d&d'dZee ed eeedeedeede dddd d(d)dZee ed eeedeedeede ddd d! d(d)d"ZxZS)*Windowa Provide rolling window calculations. Parameters ---------- window : int, timedelta, str, offset, or BaseIndexer subclass Size of the moving window. If an integer, the fixed number of observations used for each window. If a timedelta, str, or 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``, ``closed`` and ``step`` 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. For `Series` this parameter is unused and defaults to 0. .. deprecated:: 2.1.0 The axis keyword is deprecated. For ``axis=1``, transpose the DataFrame first instead. 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'``). step : int, default None .. versionadded:: 1.5.0 Evaluate the window at every ``step`` result, equivalent to slicing as ``[::step]``. ``window`` must be an integer. Using a step argument other than None or 1 will produce a result with a different shape than the input. 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 ------- pandas.api.typing.Window or pandas.api.typing.Rolling An instance of Window is returned if ``win_type`` is passed. Otherwise, an instance of Rolling is returned. 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 **step** Rolling sum with a window length of 2 observations, minimum of 1 observation to calculate a value, and a step of 2. >>> df.rolling(2, min_periods=1, step=2).sum() B 0 0.0 2 3.0 4 4.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 **on** Rolling sum with a window length of 2 days. >>> df = pd.DataFrame({ ... 'A': [pd.to_datetime('2020-01-01'), ... pd.to_datetime('2020-01-01'), ... pd.to_datetime('2020-01-02'),], ... 'B': [1, 2, 3], }, ... index=pd.date_range('2020', periods=3)) >>> df A B 2020-01-01 2020-01-01 1 2020-01-02 2020-01-01 2 2020-01-03 2020-01-02 3 >>> df.rolling('2D', on='A').sum() A B 2020-01-01 2020-01-01 1.0 2020-01-02 2020-01-01 3.0 2020-01-03 2020-01-02 6.0 rVrWrXrYr[rSrTrUr\ct|t|jtst d|jt dd}t||jd|_|jt d|jt|jtr tdt|jr|jdkr t d|jdk7r td y) NzInvalid win_type zscipy.signal.windowsz,Scipy is required to generate window weight.)extraz6BaseIndexer subclasses not implemented with win_types.r&window must be an integer 0 or greaterrnz+'single' is the only supported method type.)r]rcr`rYr>rarr_scipy_weight_generatorrVr rrr\)rdsignalr^s rerczWindow._validate|s $---0@A A+ "*X (/vt}}d'K$  ' ' /0@A A dkk; /%H $++&$++/EF F ;;( "%&ST T #rgcl|dkDr.t|dg}tj|t|}|S)zT Center the result in the window for weighted rolling aggregations. rN)rrrtuple)rdroffset lead_indexers re_center_windowzWindow._center_windows7 A:!&$/0LWWVE,$789F rgc jjfi|jrtdz dznddfd }j |||ddj 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, numeric_only : bool, default False Whether to only operate on bool, int, and float columns numba_args : tuple unused **kwargs additional arguments for scipy windows if necessary Returns ------- y : type of input rzrrc|jdk(r|jSfd}tjd5tj||}dddj rj }S#1swY)xYw)Nrctjtjgz}tj||f}|jjSt Sr)rrgrrerWr{)radditional_nansrrrdrVs rerz5Window._apply..homogeneous_func..calcsk"$((BFF8f+<"=NNA#78(,(8(8(DD$$KNf+rgrr )r"rrr#asarrayrXr)rrrrrrdrVs rerz'Window._apply..homogeneous_funcsw{{a{{}$ * 2DL1 2{{,,VV<M 2 2s BB Nr$)rrVrXr{r rU) rdrrrrrrrrVs `` @@rer&z Window._applysv:.-- KK ! ,0;;#f+/a'A  0%%&6lK tyyL  rgr:z 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/DataFramesee_alsoexamplesklassr[cTt||||j}|||}|S)Nr4)rr7r9s rer:zWindow.aggregates1@&dDtFKOOQ >$ZF rg ParametersReturnsSee AlsoExamplesa >>> ser = pd.Series([0, 1, 5, 2, 8]) To get an instance of :class:`~pandas.core.window.rolling.Window` we need to pass the parameter `win_type`. >>> type(ser.rolling(2, win_type='gaussian')) In order to use the `SciPy` Gaussian window we need to provide the parameters `M` and `std`. The parameter `M` corresponds to 2 in our example. We pass the second parameter `std` as a parameter of the following method (`sum` in this case): >>> ser.rolling(2, win_type='gaussian').sum(std=3) 0 NaN 1 0.986207 2 5.917243 3 6.903450 4 9.862071 dtype: float64 rollingzweighted window sumsum window_methodaggregation_description agg_methodc Ntj}|j|fd|d|S)Nrrr)window_aggregationsroll_weighted_sumr&rdrr window_funcs rerz Window.sums=N*;; t{{  %    rga >>> ser = pd.Series([0, 1, 5, 2, 8]) To get an instance of :class:`~pandas.core.window.rolling.Window` we need to pass the parameter `win_type`. >>> type(ser.rolling(2, win_type='gaussian')) In order to use the `SciPy` Gaussian window we need to provide the parameters `M` and `std`. The parameter `M` corresponds to 2 in our example. We pass the second parameter `std` as a parameter of the following method: >>> ser.rolling(2, win_type='gaussian').mean(std=3) 0 NaN 1 0.5 2 3.0 3 3.5 4 5.0 dtype: float64 zweighted window meanmeanc Ntj}|j|fd|d|S)Nrr)rroll_weighted_meanr&rs rerz Window.mean4s=L*<< t{{  %    rga >>> ser = pd.Series([0, 1, 5, 2, 8]) To get an instance of :class:`~pandas.core.window.rolling.Window` we need to pass the parameter `win_type`. >>> type(ser.rolling(2, win_type='gaussian')) In order to use the `SciPy` Gaussian window we need to provide the parameters `M` and `std`. The parameter `M` corresponds to 2 in our example. We pass the second parameter `std` as a parameter of the following method: >>> ser.rolling(2, win_type='gaussian').var(std=3) 0 NaN 1 0.5 2 8.0 3 4.5 4 18.0 dtype: float64 zweighted window variancevarc ttj|}|jdd|j|fd|d|S)Nddofrrr)rrroll_weighted_varpopr&)rdrrrrs rerz Window.varesDL1CC$O  64 t{{;XUXQWXXrga >>> ser = pd.Series([0, 1, 5, 2, 8]) To get an instance of :class:`~pandas.core.window.rolling.Window` we need to pass the parameter `win_type`. >>> type(ser.rolling(2, win_type='gaussian')) In order to use the `SciPy` Gaussian window we need to provide the parameters `M` and `std`. The parameter `M` corresponds to 2 in our example. We pass the second parameter `std` as a parameter of the following method: >>> ser.rolling(2, win_type='gaussian').std(std=3) 0 NaN 1 0.707107 2 2.828427 3 2.121320 4 4.242641 dtype: float64 z"weighted window standard deviationstdc @t|jd|d|d|S)Nr)rrrrI)r-r)rdrrrs rerz Window.stds,L DHH P$U P P  rg)rr%rrr?r%rH)rz,Callable[[np.ndarray, int, int], np.ndarray]rr>rrrrKrBrrrzFrrrr)rvrMrNrOrMrcrr&rr.rr:r7r3r/r0r1r4r5rrrrrrs@rerrts,yv KU,#&( < :< <  < $ < | [!    $! ;>?> Cl+i(j)j)  0 5I%L  M%L   l+i(j)j)  . 6G$J  K$J   l+i(j)j)  . :G$JYK$JY  l+i(j)j)  . DG$J K$J rgrceZdZdddZ d ddZ ddZ d ddZ d ddZ d ddZ d ddZ d dd Z d dd Z d dd Z ddd Z ddd ZdddZ d ddZ d d!dZ d" d#dZ d" d#dZy)$RollingAndExpandingMixincJtj}|j|d|S)Nrr)rroll_sumr&rdrrs rerzRollingAndExpandingMixin.counts")22 {{;W<{PPrgNc~|d}|i}t|s tdd}t|rN|dur td|}|jdk(rt |fit ||}nHt |fit ||}n1|dvr"| td|j||||}n td|j|d | S) NrIz'raw parameter must be `True` or `False`Fz.raw must be `True` when using the numba enginern)cythonNz+cython engine does not accept engine_kwargsz)engine must be either 'numba' or 'cython'r8)rr) rrar+r\r9r*r:_generate_cython_apply_funcr&) rdrr6enginer.r5rr apply_funcs rer8zRollingAndExpandingMixin.applys <D >Fs|FG G&( 6 "e| !QRRJ{{h&6-mVD 7-mVD ' '( !NOO99$TRJHI I{{ !  rgcfddlmttj|||||ffd }|S)Nrr)r5rr6functioncH|s|jd}||||S)NF)r^r)rO)rbeginr}rWr6rErdrs rerzHRollingAndExpandingMixin._generate_cython_apply_func..apply_funcs)dhhUCvuc;? ?rg)rrErr roll_apply)rdr5rr6rrrErs` @@rerz4RollingAndExpandingMixin._generate_cython_apply_funcs; "  * *  =@ @ rgc t|rU|jdk(r.ttj}|j |d||Sddlm}|j||Stj}|j|d|S)NrmTr6rr.r) sliding_sumrr) r+r\r8rnansumr8pandas.core._numba.kernelsrr2rrr&)rdrrr.rrrs rerzRollingAndExpandingMixin.sums 6 "{{g%>ryyIzz!"/ "C((mDD)22 {{;U{NNrgct|rW|jdk(r.ttj}|j |d||Sddlm}|j||dStj}|j|d|S) NrmTrrsliding_min_maxis_maxmaxr) r+r\r8rnanmaxr8rrr2rroll_maxr&rdrrr.rrrs rerzRollingAndExpandingMixin.maxs 6 "{{g%>ryyIzz!"/ "G((-PT(UU)22 {{;U{NNrgct|rW|jdk(r.ttj}|j |d||Sddlm}|j||dStj}|j|d| S) NrmTrrrFrminr) r+r\r8rnanminr8rrr2rroll_minr&rs rerzRollingAndExpandingMixin.min/s 6 "{{g%>ryyIzz!"/ "G((-PU(VV)22 {{;U{NNrgc t|rU|jdk(r.ttj}|j |d||Sddlm}|j||Stj}|j|d|S)NrmTrr) sliding_meanrr) r+r\r8rnanmeanr8rrr2r roll_meanr&)rdrrr.rrrs rerzRollingAndExpandingMixin.meanEs 6 "{{g%>rzzJzz!"/ "D((}EE)33 {{;V,{OOrgct|rN|jdk(rttj}ntj}|j |d||St j}|j|d|S)NrmTrmedianr) r+r\r8r nanmedianr8r roll_median_cr&)rdrrr.rrs rerzRollingAndExpandingMixin.median[ss 6 "{{g%>r||L||::+   *77 {{;XL{QQrgct|r=|jdk(r tdddlm}t |j ||Stjfd}|j|d|S) Nrmz%std not supported with method='table'r sliding_varrc 0t||||S)Nr)r-)rrr}rWrrs re zsqrt_funcz0RollingAndExpandingMixin.std..zsqrt_funcsVUC4PQ Qrgrr) r+r\rrrr-r2rroll_varr&)rdrrrr.rrrs ` @rerzRollingAndExpandingMixin.stdpsw 6 "{{g%)*QRR >**; D*QR R)22  R{{ %  rgct|r4|jdk(r tdddlm}|j |||St tj|}|j|d|S)Nrmz%var not supported with method='table'rrrrr) r+r\rrrr2rrrr&)rdrrrr.rrs rerzRollingAndExpandingMixin.varsq 6 "{{g%)*QRR >$$[-d$K K1::F {{ %  rgcJtj}|j|d|S)Nskewr)r roll_skewr&rs rerzRollingAndExpandingMixin.skew,)33 {{ %  rgc|jd||j||j||z jdz SNsemr?rrrpowrdrrs rerzRollingAndExpandingMixin.semsF ##E<8xx\x2 JJLJ 1D 8 #c( rgcJtj}|j|d|S)Nkurtr)r roll_kurtr&rs rerzRollingAndExpandingMixin.kurtrrgc|dk(rtj}n2|dk(rtj}nttj||}|j |d|S)Ng?g)quantile interpolationr r)rrrr roll_quantiler&)rdqr rrs rer z!RollingAndExpandingMixin.quantilesX 8-66K #X-66K!#11+K {{;Zl{SSrgcdttj|||}|j|d|S)N)r\ ascending percentilerankr)rr roll_rankr&)rdr\rpctrrs rerzRollingAndExpandingMixin.ranks7  ) )  {{;V,{OOrgcj tdjd|ddlmfd}j j ||||S)Nzstep not implemented for covcovrrc8j|}j|}j}j jn |j}|j t ||j jj\}}j||t |tjd5tj||z|||}tj||||} tj||||} tjt||zj!tj"||d} || | zz | | z z z} ddd  |j$|j&dS#1swY)xYw)Nrrr rFr)rrrWrrsr{rXrTrUrrr#rrrrrrr^r)ryx_arrayy_arrayrrWr|r}mean_x_ymean_xmean_y count_x_yrrErrds recov_funcz.RollingAndExpandingMixin.cov..cov_funcs''*G''*G!557N##/  #//  (99w<'{{{{YY :JE3  % %eS#g, ?* Y.88g%uc;-66wsKX,66wsKX/88'G+,33BJJ?Q #Vf_4iRVFV9WX Y&aff5I I Y Ys BFFrUrrrrErr)rdrrrrrrEs` ` @rerzRollingAndExpandingMixin.covsZ 99 %&DE E ##E<8! J<##   x<  rgcj tdjd|ddlmfd}j j ||||S)Nzstep not implemented for corrcorrrrcj|}j|}j}j jn |j}|j t ||j jj\}}j||t |tjd5tj||z|||}tj||||} tj||||} tjt||zj!tj"||d} tj$||||} tj$||||} || | zz | | z z z}| | zdz}||z }ddd|j&|j(dS#1swY)xYw)Nrrr rrFr)rrrWrrsr{rXrTrUrrr#rrrrrrrr^r)rrrrrrWr|r}rrrrx_vary_var numerator denominatorrrErrds re corr_funcz0RollingAndExpandingMixin.corr..corr_funcs''*G''*G!557N##/  #//  (99w<'{{{{YY :JE3  % %eS#g, ?* 1.88g%uc;-66wsKX,66wsKX/88'G+,33BJJ?Q ,44UCd,44UCd&7T!12  %u}4 "[0' 1(&aff5I I) 1 1s CGGr)rdrrrrr&rEs` ` @rer zRollingAndExpandingMixin.corrs[ 99 %&EF F ##FL9!& JP##   xL  rgrBrFNNNN rrJr6rr!Literal['cython', 'numba'] | Noner.rLr5ztuple[Any, ...] | Nonerzdict[str, Any] | None) r5rKrzdict[str, Any]r6zbool | np.bool_rrJr?z?Callable[[np.ndarray, np.ndarray, np.ndarray, int], np.ndarray]FNNrrrr)r.rLrzFNNrrrrrr)r.rLrrlinearFr floatr rArraverageTFFr\rBrrrrrrNNrzFrrGrr<rrrr)rvrMrNrr8rrrrrrrrrrrr rrr rIrgrerrsQ4804'+(,)  ) ) 2 ) . ) % ) &) V  %  I 6#4804 OO2O. O0#4804 OO2O. O0#4804 OO2O. O0#4804 PP2P. P0#4804 RR2R. R."4804    2  .  4"4804    2  .  (  08" T T-T T*%." P!PP P  P$,0 $" - (- -  -  - b,0 $" 7 (7 7  7  7 rgrc eZdZUgdZded<fdZdgdZdhdZee de de d d d fd Z e Z ee edeedeedeede dj%dd dddd didjfd Zee edeedeedeede dddd dk dlfd Zee edeeedeedeedeede d j%dd ddd!d! dm dnfd" Zee edeeedeedeedeede d#dd$d% diddd& dnfd'Zee edeeedeedeedeede d(j%dd ddd)d* dm dnfd+ Zee edeeedeedeedeede d,j%dd ddd-d- dm dnfd. Zee edeeedeedeedeede d/j%dd ddd0d0 dm dnfd1 Zee ede d2j%dd deed3edeedd4eede d5j%dd dede d6j%dd ddd7d8 do dpfd9 Zee ede d2j%dd deed3edeedd:eede d;j%dd dede d<j%dd ddd=d> do dpfd? Zee edeedeedd@eede dAede dBddCdDdidjfdE Zee ede d2j%dd deedeedeeddFede dGj%dd dddHdIdqdrdJZ ee edeedeeddKeeddLede dMj%dd dddNdOdidjfdP Z!ee ede dQj%dd deedeedeede dRj%dd dddSdS e"dSdTU ds dtfdV Z#ee dWede dXj%dd deedeedeede dYj%dd dddZdZ du dvfd[ Z$ee ede d\j%dd deedeedeede d]dd^d_ dw dxfd` Z%ee ede d\j%dd deedeede daj%dd deede dbj%dd dede dcj%dd ddddde dw dxfdf Z&xZ'S)yRollingrrLrMct||jjsmt |j t ttfsHt |j jtr[|j jjdvr8t |jtttfr|j! t#|j}t |j trT|j(|j j*j(|j j*j,z z |_nS t1|j j}t3|j(j5|j6|_|j8d|_|j: t=dyt |jt>rytA|jr|jdkr t'dy#t$t&f$r}t'd|jd|d}~wwxYw#t$$rd}YwxYw) Nrzpassed window z, is not compatible with a datetimelike indexnsrzz,step is not supported with frequency windowsrr)!r]rcrRrr`rOr$r(r'rrrrVr>r r _validate_datetimelike_monotonicr rorananosfreqnr]rIr as_unit_valuerWrUrr r)rdr=runitr^s rerczRolling._validateLs  HHNN$((]NK$PQ488>>:6488>>;N;NRV;VsJ &BC  1 1 3  - $((K0%)JJHHMM''$((--//9%! (8D%.djj$9$A$A$$G$N$N!'#$ yy$)B%  [ 1 DKK(DKK!OEF F->> 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/Dataframerrc*t||g|i|Sr)r]r:)rdrr5rr^s rer:zRolling.aggregates Lw 7777rgrrrra >>> s = pd.Series([2, 3, np.nan, 10]) >>> s.rolling(2).count() 0 NaN 1 2.0 2 1.0 3 1.0 dtype: float64 >>> s.rolling(3).count() 0 NaN 1 NaN 2 2.0 3 2.0 dtype: float64 >>> s.rolling(4).count() 0 NaN 1 NaN 2 NaN 3 3.0 dtype: float64  rzrzcount of non NaN observationsrrc"t||Sr)r]rrdrr^s rerz Rolling.countsJw}\**rgz >>> ser = pd.Series([1, 6, 5, 4]) >>> ser.rolling(2).apply(lambda s: s.sum() - s.min()) 0 NaN 1 6.0 2 6.0 3 5.0 dtype: float64 zcustom aggregation functionr8Nc.t|||||||S)N)r6rr.r5r)r]r8)rdrr6rr.r5rr^s rer8z Rolling.applys.Bw} '   rgNotesa] >>> 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 rc(t||||SN)rrr.)r]rrdrrr.r^s rerz Rolling.sum s%Jw{%'  rgz >>> ser = pd.Series([1, 2, 3, 4]) >>> ser.rolling(2).max() 0 NaN 1 2.0 2 3.0 3 4.0 dtype: float64 maximumr)rr.c(t||||SrS)r]r)rdrrr.r5rr^s rerz Rolling.maxUs%Fw{%'  rgz 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 minimumrc(t||||SrS)r]rrTs rerz Rolling.min~s%Hw{%'  rga 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 rc(t||||SrS)r]rrTs rerz Rolling.means%Vw|%'  rga  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 rc(t||||SrS)r]rrTs rerzRolling.medians%Hw~%'  rgz 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. z 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. a  >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5]) >>> s.rolling(3).std() 0 NaN 1 NaN 2 0.577350 3 1.000000 4 1.000000 5 1.154701 6 0.000000 dtype: float64 zstandard deviationrc*t|||||SN)rrrr.)r]rrdrrrr.r^s rerz Rolling.std (hw{%'   rgz/numpy.var : Equivalent method for NumPy array. z 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. a  >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5]) >>> s.rolling(3).var() 0 NaN 1 NaN 2 0.333333 3 1.000000 4 1.000000 5 1.333333 6 0.000000 dtype: float64 variancerc*t|||||Sr\)r]rr]s rerz Rolling.var> r^rgz:scipy.stats.skew : Third moment of a probability density. zV A minimum of three periods is required for the rolling calculation. z >>> ser = pd.Series([1, 5, 2, 7, 15, 6]) >>> ser.rolling(3).skew().round(6) 0 NaN 1 NaN 2 1.293343 3 -0.585583 4 0.670284 5 1.652317 dtype: float64 zunbiased skewnessrc$t||SNr)r]rrOs rerz Rolling.skewy sDw||66rgz: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 meanrc|jd||j||j||z jdz Srrrs rerz Rolling.sem sGF ##E<8xx\x2 JJ| $t + #c( rgz/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$t||Srb)r]rrOs rerz Rolling.kurt sLw||66rga quantile : float Quantile to compute. 0 <= quantile <= 1. .. deprecated:: 2.1.0 This will be renamed to 'q' in a future version. 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 r r ) old_arg_name new_arg_namec(t||||S)N)r r r)r]r )rdr r rr^s rer zRolling.quantile s&rw'%   rgz.. 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 rc*t|||||S)N)r\rrr)r]r)rdr\rrrr^s rerz Rolling.rank, s(Hw|%   rga 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. z >>> ser1 = pd.Series([1, 2, 3, 4]) >>> ser2 = pd.Series([1, 4, 5, 8]) >>> ser1.rolling(2).cov(ser2) 0 NaN 1 1.5 2 0.5 3 1.5 dtype: float64 zsample covariancerc*t|||||SN)rrrr)r]rrdrrrrr^s rerz Rolling.covw s(bw{%   rgz 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. ax 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] >>> np.corrcoef(v1[:-1], v2[:-1]) array([[1. , 0.33333333], [0.33333333, 1. ]]) >>> np.corrcoef(v1[1:], v2[1:]) array([[1. , 0.9169493], [0.9169493, 1. ]]) >>> 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.]]) >>> np.corrcoef(matrix[:-1, 0], matrix[:-1, 1]) array([[1. , 0.6263001], [0.6263001, 1. ]]) >>> np.corrcoef(matrix[1:, 0], matrix[1:, 1]) array([[1. , 0.55536811], [0.55536811, 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 correlationr c*t|||||Srj)r]r rks rer z Rolling.corr s(|w|%   rgrA)rKr>rBrr'r(r*r+r,r-rrr.r0r2r4r5r6)(rvrMrNrMrPrcr;rErr.rr:r7r3r/r0r4r5replacerr7r8r6r2rrrrrrrrrrrr rrr rrs@rer8r8?sd  K .G`D( [!    0! G$J8K$J8 Cl+i(j)j)  , '$A  ?E#H+I#H+ l+i(j)j)   =-64804'+(,    2  .  %  & 10 $ l+#%i(j)g&j), . \ '$A  %{>B#4804    2  .  >~   l+#%i(j)g&j)   )3:#  5904    2  .  76   l+#%i(j)g&j)   '$A  )9@#4804    2  .  =<   l+#%i(j)g&j)  ( '$A  &G$N#4804    2  .  K$J   l+#%i(j)g&j)   '$A  (9@#4804    2  .  =<   l+  '$A #E*i(j):g&   '$A j)   '$A  4W,^"4804      2  .  [,Z   l+  '$A #E*i(j):g&   '$A j)   '$A  *W,^"4804      2  .  [,Z   l+i(j)Eg&  j)   3? B7C B7 l+  '$A i(j)g&Fj)   '$A  8? BC B l+i(j):g&Hj)  ( '$A  NG$J7K$J7 l+  $ '$A i(j)j)  " '$A  *a1d*3?08"    -    @e1f   &l+   '$A i(j)j)  < '$A  &w<~%."  !        {<z   l+  '$A i(j)j)   3Q)X,0 $"  (        U)T   l+  '$A i(j)  '$A g&  , '$A j)8 : t '$A  -kvr,0 $"  (        ovn  rgr8cPeZdZdZej ej zZddZdZy)RollingGroupbyz3 Provide a rolling groupby implementation. cd}|j}t|jtrjt |j}|jj j }t|tsJ|jdd|j}n1|jt}|j}nt}|j}t|||jj||}|S)z Return an indexer class that will compute the window start and end bounds Returns ------- GroupbyIndexer Nr)rrgroupby_indicesrindexer_kwargs)rr`rVr rp__dict__rdictrr]r#r!r"rUrd)rdrsrrolling_indexerrVrs rerz"RollingGroupby._get_window_indexer? s15'' dkk; /"4;;/O![[11668Nnd3 33   }d 3[[F    *3O&&F0O[[F'# MM11*)  rgcd|jjr|jd|jjj D]b}|jj |}|jr+|jr8|jdn |j}td|d|dy)zC Validate that each group in self._on is monotonic rCNr^zEach group within z' must be monotonic. Sort the values in z first.) rOrDrErUrdrrrFrGrSra)rdrrgroup_onrSs rer;z/RollingGroupby._validate_datetimelike_monotonicb s 88    ' '(B C!]]2299; Mxx}}]3H00H4T4T $WTWW (-**,W6 rgN)r?r") rvrMrNrOr8rMrTrr;rIrgrerprp8 s+%%(9(E(EEK!Frgrp)yrO __future__rrdatetimer functoolsrrqtextwraprtypingrrr r numpyrpandas._libs.tslibsr r r pandas._libs.window.aggregations_libsrV aggregationsrpandas.compat._optionalr pandas.errorsrpandas.util._decoratorsrrpandas.core.dtypes.commonrrrrrpandas.core.dtypes.dtypesrpandas.core.dtypes.genericrrpandas.core.dtypes.missingrpandas.core._numbarpandas.core.algorithmsrpandas.core.applyrpandas.core.arraysrpandas.core.baserpandas.core.commoncorecommonrzpandas.core.indexers.objectsr r!r"r#pandas.core.indexes.apir$r%r&r'r(pandas.core.reshape.concatr)pandas.core.util.numba_r*r+pandas.core.window.commonr,r-pandas.core.window.docr.r/r0r1r2r3r4r5r6r7pandas.core.window.numba_r8r9r:collections.abcr;r<r=pandas._typingr>r?r@rArBrCrrDrEpandas.core.genericrFrZrHpandas.core.arrays.datetimelikerIrKrTrrr8rprIrgrersE#  ?>># 1-',2-+  .     ,39ppfF: F:RC  ZC  LB zB J s &s l..:&:rg