MhuSrSSKJr SSKrSSKJr SSKJr SSKrSSK J r SSK J r J r JrJr SSKrSSKJrJrJr SSKJs Js Jr SS KJr SS KJr SS KJ r J!r! SS K"J#r#J$r$J%r%J&r&J'r' SS K(J)r) SSK*J+r+J,r, SSK-J.r. SSK/J0r0 SSK1J2r2 SSK3J4r4 SSK5J6r6 SSK7J8r8 SSK9J:s J;r< SSK=J>r>J?r?J@r@JArA SSKBJCrCJDrDJErEJFrFJGrG SSKHJIrI SSKJJKrKJLrL SSKMJNrNJOrO SSKPJQrQJRrRJSrSJTrTJUrUJVrVJWrWJXrXJYrYJZrZ SSK[J\r\J]r]J^r^ \ (a.SSK_J`r`JaraJbrb SSKcJdrdJereJfrfJgrgJhrhJiri SSKjJkrkJlrl SSKmJnrn SS KoJprp SS!KqJrrr "S"S#\85rs"S$S%\s5rt"S&S'\s5ru"S(S)\s5rv"S*S+\v5rw\uR\wl"S,S-\t\w5rxg).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_unitc\rSrSr%Sr/rS\S'\"5rS\S'S\S'S$S S .S%S jjjr S&S jr S'S jr S(S)Sjjr S*Sjr S+SjrS,S-SjjrS(SjrS.SjrSrS/SjrS0SjrS1SjrS2Sjr\S3Sj5rS4SjrS5SjrS(S6SjjrS,S7SjjrS8S9SjjrS:SjrS;S BaseWindowxz7Provides utilities for performing windowing operations. list[str] _attributeszfrozenset[Hashable] exclusionsr%_onN) selectionc XlXplXlXlX lX0lX@lXPlUbURU5OSUl Xl SUl URcHURS:XaURRUl OURRUl O[UR[ 5(aURUl O[UR["5(aLURURR;a([!URUR5Ul O[%SURS35eXlUR)5 g)Nrzinvalid on specified as z3, must be a column (of DataFrame), an Index or None)objonclosedstepwindow min_periodscenterwin_type_get_axis_numberaxismethod _win_freq_i8indexrPcolumns isinstancer%r ValueError _selection _validate) selfrSrWrXrYrZr\rTrUrVr]rQs L/var/www/html/env/lib/python3.13/site-packages/pandas/core/window/rolling.py__init__BaseWindow.__init__s   &  262BC((.  (, 77?yyA~88>> 88++  ' 'wwDH , / /DGGtxx?O?O4OTXXdgg./DH*477)4DD  $ cURb%[UR5(d [S5eURb[ UR5(d [S5eURS:a [S5e[ UR 5(a?URUR :a%[SURSUR 35eUR bUR S;a [S5e[UR[[45(d[S [U535e[UR [5(a[R"UR R 5R"R%5n[R"[5R 5R"R%5nX:wa+[[UR 5R&S 35eUR(S ;a [S 5eUR*bA[ UR*5(d [S 5eUR*S:a [S5egg)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)rYrrbrXrrWrUrarSrr TypeErrortyper inspect signatureget_window_bounds parameterskeys__name__r]rV)reget_window_bounds_signatureexpected_signatures rfrdBaseWindow._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 !ric F[U5[U5:wa$[S[U5S[U5S35e[U5X0R=(d S-S- UR=(d S-:wa([S[U5SUSURS35eg) 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)lenrbrV)restartendnum_valss rf_check_window_boundsBaseWindow._check_window_boundss u:S !#e*[S ;  u:(iin159tyy~AN N(U 5""*+B499+N*+  Oric`Ub[U5[U5:XaU$USSUR2$)z: Slices the index for a given result and the preset step. N)r~rV)rer_results rf_slice_axis_for_stepBaseWindow._slice_axis_for_steps9 ~VE !:  |$))|$ ricURRS:XaQU(aI[URR5(d$[ [ U5R SUS35eggg)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. r}.z does not implement numeric_onlyN) _selected_objndimrdtypeNotImplementedErrorrrrx)rename numeric_onlys rf_validate_numeric_only!BaseWindow._validate_numeric_onlysj    # #q ($T%7%7%=%=>>%:&&'q.NO ? )ric*URS/S/S9nU$)zSubset DataFrame to numeric columns. Parameters ---------- obj : DataFrame Returns ------- obj subset to numeric-only columns. numberr)includeexclude) select_dtypes)rerSrs rf_make_numeric_onlyBaseWindow._make_numeric_onlys"""H: }"M ricURbc[UR[5(dDURS:Xa4UR UR R UR/5SS9nURS:a(U(dURS:XaURU5nURS:Xa/URSSS9nURR5Ul U$)1 Split data into blocks & return conformed data. F)r`copyr}float64)r) rTrar%rreindexr` differencer\rastype_mgr consolidate)rerSrs rf _create_dataBaseWindow._create_datas 77 z$''5'A'AchhRSm++ckk&<&**YU*3Cxx++-CH ricUc URnURVs0sHoD[X5_M nnURX5n[ U5"U4SU0UD6nU$s snf)z 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 rQ)rSrNgetattr_infer_selectionrr)rekeyrsubsetattrkwargsrQnew_wins rf_gotitemBaseWindow._gotitem#sk >XXF9=8H8HI8H++8HI))#6 t*VCyCFC JsAcXR;a[RX5$XR;aX$[ S[ U5R SUS35e)N'z' object has no attribute ')_internal_names_setobject__getattribute__rSAttributeErrorrrrx)rers rf __getattr__BaseWindow.__getattr__;s\ ++ +**46 6 88 : T ##$$?vQ G  ric6URR5$N)rS_dir_additionsres rfrBaseWindow._dir_additionsEsxx&&((ric^U4SjTR5nSRU5n[T5RSUS3$)z0 Provide a nice str repr of our rolling object. c3|># UH1n[TUS5cMUSS:wdMUS[TU53v M3 g7f)Nr_=)r).0 attr_nameres rf &BaseWindow.__repr__..LsJ - tY- 6>Glc>Q 6yk7434 5-s <<<,z [])rNjoinrrrx)re attrs_listattrss` rf__repr__BaseWindow.__repr__HsF !-- $t*%%&bq11ric## URRUR5nURU5nUR 5nUR [ U5URURURURS9up4URX4[ U55 [X45H!upVUR[XV5nUv M# g7fN num_valuesrXrYrUrV)rset_axisrPr_get_window_indexerrur~rXrYrUrVrzipilocslice)rerSindexerrrsers rf__iter__BaseWindow.__iter__Ts  ))$((3$**,..3x((;;;; /  !!%c#h7ODAXXeAk*FL$sCCc:[UR5(a/[S[U5RSURS35e[ U[ 5(a-UR[R[RS9nO [U5n[R"U5nUR5(a&[R "U[RU5nU$![[4an[SUR35UeSnAff=f)z1Convert input to numpy arrays for Cython routineszops for z for this dtype z are not implemented)na_valuezcannot handle this type -> N)rrrrrrxrarto_numpynprnanrrbrqisinfanywhere)revalueserrinfs rf _prep_valuesBaseWindow._prep_valuesfs v|| , ,%4:../0&:<   S&.11bffE'/ hhv 7799XXc26662F I& S9&,,HIs R Ss AC, C,,D<DDc^SSKJn URGbURR UR 5(dURR nU"URURR USS9nXAR;aXQU'gXAR R;agX@RR;aeURRnURnURU5nURUSU5n [U 5n URXU5 gXQU'ggg)NrrEFr_rr)pandasrErTrPequalsr_rrSr`namesrget_loc intersectionr~insert) rerrSrEr extra_colold_colsnew_colsold_locoverlapnew_locs rf_insert_on_columnBaseWindow._insert_on_column~s " 77 txxsyy'A'A88==Dtxxtxx~~DuUI~~%(t +++++333--55!>>"**40"//'0BCg, gY7 )t %(B ricl[UR[[[45(aURR $[URR [5(aKURR RS;a'URR[RS9$g)NmMr) rarPr'r$r(asi8rrkindrrint64rs rf _index_arrayBaseWindow._index_arrayss dhhm^ L M M88==  3 38K8Kt8S88$$288$4 4ricURSS:XaURSS:a [S5eURSS:XaURS5$URX5 U$)zValidate and finalize result.r}rNo numeric types to aggregater)shaperrr)reoutrSs rf_resolve_outputBaseWindow._resolve_outputs_ 99Q<1 1!1;< < 99Q<1 ::i( ( s( ric[UR[5(a UR$URb)[ UR URUR S9$[URS9$)zK Return an indexer class that will compute the window start and end bounds ) index_array window_sizerY)r)rarWr r^r#rrYr!rs rfrBaseWindow._get_window_indexersb dkk; / /;;     (( -- --{{  "dkk::ric|URUR5nUS:Xa[U5R[5nUR UR 5nU"U5nURURU5nURXgURS9$![[4an[S5UeSnAff=f)z% Series version of _apply_columnwise countrNr_r)rrrrintr_valuesrqrrrr_ _constructorr)rehomogeneous_funcrrSrrrr_s rf _apply_seriesBaseWindow._apply_seriess  2 23 7?*##C(C F&&s{{3F"&)))#))V<#((CC ./ F;<# E FsBB;* B66B;cURX#5 URRS:XaURX5$UR URU5nUS:Xa=[ U5R [5nURR5UlURS:Xa URn/n/n[UR55HAupxURU5nU"U5n UR'U 5 UR'U5 MC UR)UR*[-U5S:aUSOS5n [/U5R1UU UR2R5U5SS9n URS:Xa U Rn UR7X5$![[ 4an [#SUR$35U eSn A ff=f)zT Apply the given function to the DataFrame broken down into homogeneous sub-frames. r}r z#Cannot aggregate non-numeric type: NrF)r_r`verify_integrity)rrrrrrrr rrr\T enumerate_iter_column_arraysrrqrrrappendrr_r~rr _from_arraysr`taker) rerrrrStaker res_valuesiarrrresr_dfs rf_apply_columnwiseBaseWindow._apply_columnwises ##D7    " "a '%%&6= = 2 2LA 7?*##C(Cxx++-CH 99>%%C  7 7 9:FA '', #3'C   c " LLO;)) IIJ!(;z!} #Y # # KK$$U+" $  99>B##B,,+23 9#))E sF++G;GGc`URRS:Xa [S5eURURU5nUR UR 55nUR S:Xa UROUnU"U5nUR S:Xa UROUnURURU5nURS[UR5:Xa UROURSSUR2nURXgUS9n URX5$)zD Apply the given function to the DataFrame across the entire object r}z1method='table' not applicable for Series objects.Nr_r`)rrrbrrrr\rrr_rr~r`rVrr) rerrrrSrrr_r`rs rf_apply_tablewiseBaseWindow._apply_tablewises    " "a 'PQ Q 2 2LA""3<<>2!YY!^!&)!YY!^))#))V<||A#ckk"22 KK\ \*  vGD##C--ricURX5nUc UnUcSOUnON[U[[45(d [ S5eUR S:XaU(aUR U5n[XU[U5S9$)M Apply the given pairwise function given 2 pandas objects (DataFrame/Series) Tz#other must be a DataFrame or Seriesr)pairwise) rrarrrbrrr,bool)retargetotherr(funcrs rf_apply_pairwiseBaseWindow._apply_pairwisesx""68 =E'/tXHEL)#<==BC C ZZ1_++E2E!&XOOric ^^^^^TR5mTRb TRO TRmSUUUUU4SjjnTRS:XaTR XbU5$TR XbU5$)an 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>URS:XaUR5$UUUUU4Sjn[R"SS9 U"U5nSSS5 U$!,(df  W$=f)Nrc>TR[U5TTRTRTRS9upTR X[U55 T"XUT/TQ76$r)rur~rYrUrVr)xrrr,rX numba_argsrewindow_indexers rfcalc9BaseWindow._apply..homogeneous_func..calcYsc+=="1v +;;;; > ))%c!f=Ac;DDDriignoreall)sizerrerrstate)rr5rr,rXr3rer4s rfr+BaseWindow._apply..homogeneous_funcSs\{{a{{}$ E E*f+M+*Ms A A"rpr np.ndarray)rrXrr]r r$) rer,rrr3rrrXr4s `` ` @@rf_applyBaseWindow._apply2sz4113+   ++    . ;;( "))*:,O O(()9N Nric *UR5nURb URO URnURUR5nUR S:Xa UR nURUR55nURS:XaURSS5nUR[U5UURURURS9upUR!X[U55 ["R$n ["R&"UU 4SS0[)U5D6n U "UR 4XUS.UD6R n UR S:Xa U R OU n UR+UR,U 5n URS:Xa,U R/5n UR1XUR2S9nU$UR+UR4U R 5nUR1XUS9nUR7X5$) Nr}ris_grouped_kernelF)rrrXr r#)rrXrrrr\rrrrreshaperur~rYrUrVrrfloat_dtype_mappinggenerate_shared_aggregatorr*rr_squeezerrr`r)rer, engine_kwargs func_kwargsr4rXrSrrr dtype_mapping aggregatorrr_rr`s rf _numba_applyBaseWindow._numba_applyos 113+   ++   2 23 99>%%C""3<<>2 ;;! ^^B*F#556{#;;;; 6  !!%c&k: !44 88   $  .   HH !  GR ! "YY!^))#))V< 88q=^^%F""6SXX"FCJ// VXXFG""6"HC''1 1ric^[XX#S9R5nUcURUSX#S9$U$)NargsrF)rawrPr)raggapplyrer,rPrrs rf aggregateBaseWindow.aggregates6%dtKOOQ >::dD:H H ri) rPrcr^r\rYrUr]rXrSrTrVrZrW) NNFNrNNNrp)rSrFrX int | NonerY bool | NonerZ str | Noner\r?rTzstr | Index | NonerUrYrVrWr]strreturnNoner[r\)rr>rr>rr r[r\r)r_r%rz Sized | Noner[r%)rrZrr)r[r\)rSr@r[r@FrSr@rr)r[r@)rrZ)r[rZ)r[r<)rr>r[r>)rrDrSrDr[r\)r[znpt.NDArray[np.int64] | None)rrDrSrDr[rD)r[r )rCallable[..., ArrayLike]rrYr[rE)rr`rrZrr)r[DataFrame | Series)NF)rr`rrYrr)r[ra r*rar+DataFrame | Series | Noner(rXr,zFCallable[[DataFrame | Series, DataFrame | Series], DataFrame | Series]rr)r[raF)r,Callable[..., Any]rrZrr)r3tuple[Any, ...])r,rfrHdict[str, bool] | None)$rx __module__ __qualname____firstlineno____doc__rN__annotations__ frozensetrOrgrdrrrrrrrrrrrrpropertyrrrrr r$r-r?rLrUrR__static_attributes__rerirfrKrKxseAK&/kJ#1 J "&##!%!++ + +  +  ++ ++++ +Z)6V  &0 SSKJn [X&5(d [S5eX lX0lUR URRSS9nURS5b [S5e[TU],"U/UQ70UD6 g)NrrGzMust pass a BaseGrouper object.r7r`errorsrVz step not implemented for groupby) pandas.core.groupby.opsrHrarbrsrtdroprgetrsuperrg)rerSrsrtrPrrH __class__s rfrgBaseWindowGroupby.__init__sy 8(00>? ? "hht}}228hD ::f  )%&HI I .t.v.ric >[TU]"UUUU40UD6nURRn/URQn[ R "UR R5n X-n UR RV s/sH-n XRRR;dU bM+U PM/ n n [U 5[U 5:waURU SS9nUR Rn [ R "UR R5nUR RR5nU(a [R"[U55nO#[R "/[R"S9nU Vs/sHnUR%U5PM n nUbUR%U5n['U[(5(d[(R*"U/5nU R-[UR55 UR-[UR55 [)XU SS9nUUlUR.(d*UR1[[3[U 555S9nU$s sn fs snf)Nr7rvrFrr)level)r{r?rSr_rrrsr~rycodeslevelsindicesrr concatenatelistarrayintprrar& from_arraysextendrt reset_indexrange)rer,rrr3rrgrouped_object_indexgrouped_index_name groupby_keysresult_index_namesr drop_columnsrr group_indicesrcidx result_indexr|s rfr?BaseWindowGroupby._applys          $xx~~:399:yy!4!45 )>}}** *((.....# *  | L 1 1[[h[GF ##4==//0 --446 nnT-%89Ghhr1G*/0%Q%0 +&++G4Cc:.. ,,cU3 LLcii ) MM$szz* +! !3e $ ~~''d5\9J3K.L'MF I $1s*J.JJ c>^URURRSS9n[TU]UTX4U5nTGbU[ U4SjURR R555(Gd[U5n[URR R5Vs/sH-nURU5RUR5PM/ sn5nSURR R55n /n /n [[[!U 65H]n ["R$"["R&"U 5U5n [)U 5upU R+U5 U R+U5 M_ OURR,n URR.n URR R5nU(a ["R0"[U55nO#["R&"/["R2S9nUR4S:XaSnO[UR65nU Vs/sH)n["R$"URU5U5PM+ n n[9UR[:5(a^[URR,5n[URR.5n[URR5nO5[)UR5unnU/nU/nURR</nU U-nU U-nURRU-n[;UUUSS9nUUl U$s snfs snf) r'r7rvc3R># UHn[U5[T5:Hv M g7fr)r~)rgroupr+s rfr4BaseWindowGroupby._apply_pairwise..s") 2PCJ#e* $2Ps$'c3N# UHn[R"U5v M g7fr)commaybe_make_list)rpairs rfrr&s"6Rd##D))6Rs#%rr}Fr)ryrsrr{r-r9rrr~r)rrr_rwmaprrrrepeatrrrrrrrrr`rar&r)rer*r+r(r,rrold_result_len gb_indicesgb_pairs groupby_codesgroupby_levels gb_level_pairlabelsrrrr repeat_byr result_codes result_levels result_names idx_codes idx_levelsrr|s ` rfr-!BaseWindowGroupby._apply_pairwisesT]]%8%8J( U  S) 26--2G2G2N2N2P) & & ![N'+mm&;&;&B&B&D&D KK +33FLLA&DF6:mm6K6K6P6P6RHMN!$T3>!: 288M#:NK )& 1 $$U+%%f- ";!MM//M"]]11N MM1188:M..m)<=((2RWW5{{a / ?L?L! !&&/95}  fllJ / / 2 23L !4!45M 2 23L$-fll$; !Iz%;L'LM"LL--.L%|3 &6 }}**\9 ! <|e $  uFs 04M40M9c">UR(do[R"[URR R 555R[R5nURU5n[TU]-X5$)r) emptyrrrrsrrrrrr{r)rerSr groupby_orderr|s rfrBaseWindowGroupby._create_data\sdyyNN4 0E0E0L0L0N+OPWWM((=)Cw#C66ric>URb%URRUR5n[TU]XUS9$)N)r)rTrS set_indexrPr{r)rerrrr|s rfrBaseWindowGroupby._gotitemjs< 77 XX''1Fw&99ri)rtrs)rSrarsrHrtr)r[r\rd) r,rfrrZrr)r3rgr[rarbr^r_r)rxrirjrkrlrmrNrgr?r-rrrp __classcell__r|s@rfrrrrsO(\K) / / /  / //6#&( ; ;; ; $ ; ;;zR"R)R R U R  R Rh 7 7::rirrcp^\rSrSrSr/SQrU4SjrS%SjrS&S'Sjjr\ "\ S\ "S5\ "S 5S S S 9S 5r \ r \ "\\"S5\\\"S5\\"S5\\"S5\ "S5SSSS9 S(S)Sjj5r\ "\\"S5\\\"S5\\"S5\\"S5\ "S5SSSS9 S(S)Sjj5r\ "\\"S5\\\"S5\\"S5\\"S5\ "S5SSSS9 S*S+Sjj5r\ "\\"S5\\\"S5\\"S5\\"S5\ "S 5SS!S"S9 S*S+S#jj5rS$rU=r$),Windowita 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 rWrXrYrZr\rTrUrVr]c>[TU]5 [UR[5(d[ SUR35e[ SSS9n[XRS5UlURc[ SUR35e[UR[5(a [S5e[UR5(aURS:a [ S5eURS:wa [S 5eg) 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 greaterrpz+'single' is the only supported method type.)r{rdrarZrZrbrr_scipy_weight_generatorrWr rrr])resignalr|s rfrdWindow._validate|s $----0@A A+ "*X (/v}}d'K$  ' ' /0@A A dkk; / /%H $++&&$++/EF F ;;( "%&ST T #ricpUS:a/[US5/n[R"U[U55nU$)zD Center the result in the window for weighted rolling aggregations. rN)rrrtuple)reroffset lead_indexers rf_center_windowWindow._center_windows7 A:!&$/0LWWVE,$789F ric ^^^^TR"TR40UD6mTR(a[T5S- S-OSmSUUUU4SjjnTR XbU5SSTR 2$)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 r}rrc4>URS:XaUR5$UUUU4Sjn[R"SS9 [R"U"U55nSSS5 TR (aTR WT5nW$!,(df  N3=f)Nrc>[R"[R/T-5n[R"X45nT"UTTRbTR5$[ T55$r)rrrrrXr~)r2additional_nansr,rrerWs rfr55Window._apply..homogeneous_func..calcsi"$((BFF8f+<"=NNA#78(,(8(8(DD$$KNf+rir7r8)r:rrr;asarrayrYr)rr5rr,rrerWs rfr'Window._apply..homogeneous_funcsu{{a{{}$  *DL1+{{,,VV<M+*s B  BNr=)rrWrYr~r rV) rer,rrr3rrrrWs `` @@rfr? Window._applysr:-- KK ! ,0;;#f+/a'A  0%%&6lK tyyL  rirUz 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\cL[XX#S9R5nUcU"U5nU$)NrO)rrRrTs rfrUWindow.aggregates-@&dtKOOQ >$ZF ri 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 N[RnUR"U4SUS.UD6$)Nrrr)window_aggregationsroll_weighted_sumr?rerr window_funcs rfr Window.sums;N*;; {{  %    ria >>> 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 N[RnUR"U4SUS.UD6$)Nrr)rroll_weighted_meanr?rs rfr Window.mean4s;L*<< {{  %    ria >>> 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 [[RUS9nURSS5 UR"U4SUS.UD6$)Nddofrrr)rrroll_weighted_varpopr?)rerrrrs rfr Window.varesBL1CC$O  64 {{;XUXQWXXria >>> 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 @[UR"SUSUS.UD65$)Nr)rrrre)r-r)rerrrs rfr Window.stds*L HH P$U P P  ri)r)rr>rr r[r>rd)r,z,Callable[[np.ndarray, int, int], np.ndarray]rrZrr)r3rgr^rr)r}Frr rr))rxrirjrkrlrNrdrr?rr.rrUrRr3r/r0r1r4r5rrrrrprrs@rfrrts,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 rirc\rSrSrSSSjjrSSSjjrSSjrSSSjjrSSSjjrSSSjjr SSS jjr SSS jjr SSS jjr SSS jjr SSS jjrSSSjjrSSSjjrS S!SjjrS"S#SjjrS$S%SjjrS$S%SjjrSrg)&RollingAndExpandingMixinicD[RnURUSUS9$)Nr r)rroll_sumr?rerrs rfr RollingAndExpandingMixin.counts")22 {{;W<{PPriNcUcSnUc0n[U5(d [S5eSn[U5(aNUSLa [S5eUnURS:Xa[ U40[ XF5D6nOH[ U40[ XF5D6nO2US;a!Ub [S5eURXVX!5nO [S5eURUS US 9$) Nrez'raw parameter must be `True` or `False`Fz.raw must be `True` when using the numba enginerp)cythonNz+cython engine does not accept engine_kwargsz)engine must be either 'numba' or 'cython'rS)rr3) rrbr+r]r9r*r:_generate_cython_apply_funcr?) rer,rQenginerHrPrr3 apply_funcs rfrSRollingAndExpandingMixin.applys <D >Fs||FG G&( 6 " "e| !QRRJ{{h&6-mD 7-mD ' '( !NOO99$RJHI I{{ !  ricd^^^SSKJm [[RUUUUS9mU4UUU4SjjnU$)Nrr)rPrrQfunctioncH>U(dT"UTRSS9nT"XX#5$)NF)r_r)rP)rbeginrrXrQrErers rfrHRollingAndExpandingMixin._generate_cython_apply_func..apply_funcs%dhhUCvc? ?ri)rrErr roll_apply)rerPrrQrrrErs` @@rfr4RollingAndExpandingMixin._generate_cython_apply_funcsA "  * *  =@ @ @ ric[U5(aRURS:Xa+[[R5nUR USUUS9$SSKJn URXS5$[RnURUSUS9$)NroTrQrrHr) sliding_sumrr) r+r]r8rnansumrSpandas.core._numba.kernelsr rLrrr?)rerrrHr,r rs rfrRollingAndExpandingMixin.sums 6 " "{{g%>ryyIzz!"/ "C((DD)22 {{;U{NNric[U5(aQURS:Xa+[[R5nUR USUUS9$SSKJn URXSSS9$[RnURUSUS9$) NroTr rsliding_min_maxis_maxmaxr) r+r]r8rnanmaxrSrrrLrroll_maxr?rerrrHr,rrs rfrRollingAndExpandingMixin.maxs 6 " "{{g%>ryyIzz!"/ "G((PT(UU)22 {{;U{NNric[U5(aQURS:Xa+[[R5nUR USUUS9$SSKJn URXSSS9$[RnURUSUS 9$) NroTr rrFrminr) r+r]r8rnanminrSrrrLrroll_minr?rs rfrRollingAndExpandingMixin.min/s 6 " "{{g%>ryyIzz!"/ "G((PU(VV)22 {{;U{NNric[U5(aRURS:Xa+[[R5nUR USUUS9$SSKJn URXS5$[RnURUSUS9$)NroTr r) sliding_meanrr) r+r]r8rnanmeanrSrr rLr roll_meanr?)rerrrHr,r rs rfrRollingAndExpandingMixin.meanEs 6 " "{{g%>rzzJzz!"/ "D((EE)33 {{;V,{OOric[U5(aLURS:Xa[[R5nO[RnUR USUUS9$[ RnURUSUS9$)NroTr medianr) r+r]r8r nanmedianrSr roll_median_cr?)rerrrHr,rs rfr%RollingAndExpandingMixin.median[sv 6 " "{{g%>r||L||::+   *77 {{;XL{QQric^^[U5(a:URS:Xa [S5eSSKJn [ UR XTTS95$[RmUU4SjnURUSUS9$) Nroz%std not supported with method='table'r sliding_varrc &>[T"XX#TS95$)Nr)r-)rrrrXrrs rf zsqrt_func0RollingAndExpandingMixin.std..zsqrt_funcsVC4PQ Qrirr) r+r]rrr+r-rLrroll_varr?)rerrrrHr+r-rs ` @rfrRollingAndExpandingMixin.stdpsx 6 " "{{g%)*QRR >**;D*QR R)22  R{{ %  ric[U5(a1URS:Xa [S5eSSKJn UR XTUS9$[ [RUS9nURUSUS9$)Nroz%var not supported with method='table'rr*rrr) r+r]rrr+rLrrr/r?)rerrrrHr+rs rfrRollingAndExpandingMixin.varsr 6 " "{{g%)*QRR >$$[d$K K1::F {{ %  ricD[RnURUSUS9$)Nskewr)r roll_skewr?rs rfr4RollingAndExpandingMixin.skew,)33 {{ %  ricURSU5 URUS9URUS9U- RS5- $Nsemr?rrr powrerrs rfr:RollingAndExpandingMixin.semsF ##E<8xx\x2 JJLJ 1D 8 #c( ricD[RnURUSUS9$)Nkurtr)r roll_kurtr?rs rfrBRollingAndExpandingMixin.kurtr7ricUS:Xa[RnO0US:Xa[RnO[[RUUS9nUR USUS9$)Ng?g)quantile interpolationrFr)rrrr roll_quantiler?)reqrGrrs rfrF!RollingAndExpandingMixin.quantilesX 8-66K #X-66K!#11+K {{;Zl{SSricX[[RUUUS9nURUSUS9$)N)r] ascending percentilerankr)rr roll_rankr?)rer]rLpctrrs rfrNRollingAndExpandingMixin.ranks7  ) )  {{;V,{OOric^^^TRb [S5eTRSU5 SSKJm UUU4SjnTR TR XXT5$)Nzstep not implemented for covcovrrc$>TRU5nTRU5nTR5nTRb TRO URnUR [ U5UTR TRTRS9upgTRXg[ U55 [R"SS9 [R"X#-XgU5n[R"X&Xu5n [R"X6Xu5n [R"[X#-5R![R"5XgS5n XU -- XT- - -n SSS5 T "W UR$UR&SS9$!,(df  N+=f)Nrr7r8rFr)rrrXrrur~rYrUrVrrr;rr"rrrrr_r)r2yx_arrayy_arrayr4rXrrmean_x_ymean_xmean_y count_x_yrrErres rfcov_func.RollingAndExpandingMixin.cov..cov_funcse''*G''*G!557N##/  #//  (99w<'{{{{YY :JE  % %e#g, ?*.88%u;-66wsX,66wsX/88'+,33BJJ?Q #f_4RVFV9WX+&aff5I I+*s BF FrVrrrrEr-r)rer+r(rrr\rEs` ` @rfrSRollingAndExpandingMixin.covsV 99 %&DE E ##E<8! J<##     ric^^^TRb [S5eTRSU5 SSKJm UUU4SjnTR TR XXT5$)Nzstep not implemented for corrcorrrrc>TRU5nTRU5nTR5nTRb TRO URnUR [ U5UTR TRTRS9upgTRXg[ U55 [R"SS9 [R"X#-XgU5n[R"X&Xu5n [R"X6Xu5n [R"[X#-5R![R"5XgS5n [R$"X&XuT5n [R$"X6XuT5n XU -- XT- - -nX-S-nX- nSSS5 T"WUR&UR(SS9$!,(df  N+=f)Nrr7r8rr<Fr)rrrXrrur~rYrUrVrrr;rr"rrrrr/r_r)r2rUrVrWr4rXrrrXrYrZr[x_vary_var numerator denominatorrrErres rf corr_func0RollingAndExpandingMixin.corr..corr_funcs''*G''*G!557N##/  #//  (99w<'{{{{YY :JE  % %e#g, ?*.88%u;-66wsX,66wsX/88'+,33BJJ?Q ,44Cd,44Cd&7T!12  %}4 "0'+(&aff5I I)+*s CF<< G r^)rer+r(rrrgrEs` ` @rfraRollingAndExpandingMixin.corrsW 99 %&EF F ##FL9!& JP##     rirer^rFNNNN r,rfrQr)r!Literal['cython', 'numba'] | NonerHrhrPztuple[Any, ...] | Nonerzdict[str, Any] | None) rPrgrzdict[str, Any]rQzbool | np.bool_rrfr[z?Callable[[np.ndarray, np.ndarray, np.ndarray, int], np.ndarray]FNNrr)rrlrHrhr}FNNrr rr)rrlrHrhrrlinearFrIfloatrGrArr)averageTFFr]rBrLr)rPr)rr)NNr}Fr+rcr(rXrr rr))rxrirjrkr rSrrrrrr%rrr4r:rBrFrNrSrarprerirfrrsQ4804'+(,)  ) ) 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 7 rirc ^\rSrSr%/SQrS\S'U4SjrSiSjrSjSjr\ "\ S\ "S 5\ "S 5S S S 9U4Sj5r \ r \ "\\"S5\\"S5\\"S5\\"S5\ "S5R'SS S5SSSS9 SkSlU4Sjjj5r\ "\\"S5\\"S5\\"S5\\"S5\ "S5SSSS9 SmSnU4Sjjj5r\ "\\"S5\\"5\"S5\\"S5\\"S 5\\"S5\ "S!5R'SS S5SS"S"S9SoSpU4S#jjj5r\ "\\"S5\\"5\"S5\\"S5\\"S 5\\"S5\ "S$5SS%S&S9SkSSS'.SpU4S(jjjj5r\ "\\"S5\\"5\"S5\\"S5\\"S 5\\"S5\ "S)5R'SS S5SS*S+S9SoSpU4S,jjj5r\ "\\"S5\\"5\"S5\\"S5\\"S 5\\"S5\ "S-5R'SS S5SS.S.S9SoSpU4S/jjj5r\ "\\"S5\\"5\"S5\\"S5\\"S 5\\"S5\ "S05R'SS S5SS1S1S9SoSpU4S2jjj5r\ "\\"S5\ "S35R'SS S5\\"S45\"S5\\"S5S5\\"S 5\ "S65R'SS S5\"S5\ "S75R'SS S5SS8S9S9SqSrU4S:jjj5r\ "\\"S5\ "S35R'SS S5\\"S45\"S5\\"S5S;\\"S 5\ "S<5R'SS S5\"S5\ "S=5R'SS S5SS>S?S9SqSrU4S@jjj5r\ "\\"S5\\"S5\\"S5SA\\"S 5\ "SB5\"S5\ "SC5SSDSES9SkSlU4SFjjj5r \ "\\"S5\ "S35R'SS S5\\"S5\\"S5\\"S 5SG\"S5\ "SH5R'SS S5SSISJS9SsStSKjj5r!\ "\\"S5\\"S5\\"S5SL\\"S 5SM\"S5\ "SN5R'SS S5SSOSPS9SkSlU4SQjjj5r"\ "\\"S5\ "SR5R'SS S5\\"S5\\"S5\\"S5\ "SS5R'SS S5SSTSTS9 \#"STSUSV9SuSvU4SWjjj55r$\ "\SX\"S5\ "SY5R'SS S5\\"S5\\"S5\\"S5\ "SZ5R'SS S5SS[S[S9SwSxU4S\jjj5r%\ "\\"S5\ "S]5R'SS S5\\"S5\\"S5\\"S5\ "S^5SS_S`S9 SySzU4Sajjj5r&\ "\\"S5\ "S]5R'SS S5\\"S5\\"S5\ "Sb5R'SS S5\\"S 5\ "Sc5R'SS S5\"S5\ "Sd5R'SS S5SSeSfS9SySzU4Sgjjj5r'Shr(U=r)$){Rollingi?rrMrNc>[TU]5 URR(dy[ UR [ [[45(dO[ UR R[5(GaiUR RRS;GaD[ UR[[[45(GaUR!5 [#UR5n[ UR [5(aTUR(UR R*R(UR R*R,- - UlOS[1UR R5n[3UR(5R5U5R6UlUR8cSUlUR:b [=S5eg[ UR[>5(ag[AUR5(aURS:a ['S5eg![$[&4an['SURS35UeSnAff=f![$a SnNf=f) Nrzpassed window z, is not compatible with a datetimelike indexnsr}z,step is not supported with frequency windowsrr)!r{rdrSrrarPr$r(r'rrrrWrZr r _validate_datetimelike_monotonicr rqrbnanosfreqnr^rIr as_unit_valuerXrVrr r)rerrunitr|s rfrdRolling._validateLs  HHNN$((]NK$PQQ488>>:66488>>;N;NRV;VsJ &BCC  1 1 3  - $((K00%)JJHHMM''$((--//9%! (8D%.djj$9$A$A$$G$N$N!'#$ yy$)B%  [ 1 1 DKK((DKK!OEF F-)I0>I-I((I-0 I?>I?cURR(aURS5 URR(d.URR(dURS5 ggg)zh Validate self._on is monotonic (increasing or decreasing) and has no NaT values for frequency windows. values must not have NaTzvalues must be monotonicN)rPhasnans_raise_monotonic_erroris_monotonic_increasingis_monotonic_decreasingrs rfr~(Rolling._validate_datetimelike_monotonic|sQ 88    ' '(B C00DHH4T4T  ' '(B C5U0ricjURnUcURS:XaSnOSn[USU35e)Nrr_column )rTr\rb)remsgrTs rfrRolling._raise_monotonic_errors: WW :yyA~B4q''rirUz 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/Dataframerrc,>[TU]"U/UQ70UD6$r)r{rU)rer,rPrr|s rfrURolling.aggregates Lw 7777rirrrra >>> 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  r}rzcount of non NaN observationsr rc">[TU]U5$r)r{r rerr|s rfr  Rolling.countsJw}\**riz >>> 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 functionrSNc (>[TU]UUUUUUS9$)N)rQrrHrPr)r{rS)rer,rQrrHrPrr|s rfrS Rolling.applys.Bw} '   riNotesa] >>> 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">[TU]UUUS9$N)rrrH)r{rrerrrHr|s rfr Rolling.sum s%Jw{%'  riz >>> 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)rrHc">[TU]UUUS9$r)r{r)rerrrHrPrr|s rfr Rolling.maxUs%Fw{%'  riz 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">[TU]UUUS9$r)r{rrs rfr Rolling.min~s%Hw{%'  ria 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">[TU]UUUS9$r)r{rrs rfr Rolling.means%Vw|%'  ria  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 r%c">[TU]UUUS9$r)r{r%rs rfr%Rolling.medians%Hw~%'  riz 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$>[TU]UUUUS9$N)rrrrH)r{rrerrrrHr|s rfr Rolling.std (hw{%'   riz/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$>[TU]UUUUS9$r)r{rrs rfr Rolling.var> rriz: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 skewnessr4c>[TU]US9$Nr;)r{r4rs rfr4 Rolling.skewy sDw||66riz: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 meanr:cURSU5 URUS9URU5U- RS5- $r9r=r?s rfr: Rolling.sem sGF ##E<8xx\x2 JJ| $t + #c( riz/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 biasrBc>[TU]US9$r)r{rBrs rfrB Rolling.kurt sLw||66ria 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 rFrI) old_arg_name new_arg_namec">[TU]UUUS9$)N)rIrGr)r{rF)rerIrGrr|s rfrFRolling.quantile s&rw'%   riz.. 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 rNc$>[TU]UUUUS9$)N)r]rLrPr)r{rN)rer]rLrPrr|s rfrN Rolling.rank, s(Hw|%   ria 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 covariancerSc$>[TU]UUUUS9$N)r+r(rr)r{rSrer+r(rrr|s rfrS Rolling.covw s(bw{%   riz 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 correlationrac$>[TU]UUUUS9$r)r{rars rfra Rolling.corr s(|w|%   ri)r^rXr])rrZr^rrjrkrmrnrorprrrqrsrurwrxry)*rxrirjrkrNrmrdr~rrr.rrUrRr3r/r0r4r5replacer r7rSr6r2rrrrr%rrr4r:rBrrFrNrSrarprrs@rfr{r{?sx  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? B77C B7 l+  '$A i(j)g&Fj)   '$A  8? BC B l+i(j):g&Hj)  ( '$A  NG$J77K$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  rir{cZ\rSrSrSr\R \R -rSSjrSr Sr g)RollingGroupbyi8 z+ Provide a rolling groupby implementation. cSnURn[UR[5(ao[ UR5nURR R 5n[U[5(deURSS5 URnO2URb[nURnO[nURn[UUURRUUS9nU$)zk Return an indexer class that will compute the window start and end bounds Returns ------- GroupbyIndexer Nr)rrgroupby_indicesr4indexer_kwargs)rrarWr rr__dict__rdictrr^r#r!r"rsr)rerrrolling_indexerrWr4s rfr"RollingGroupby._get_window_indexer? s15'' dkk; / /"4;;/O![[11668Nnd33 33   }d 3[[F    *3O&&F0O[[F'# MM11*)  ricURR(aURS5 URRR 5HonURR U5nUR(aM1UR(aMDURcSO URn[SUSUS35e g)z3 Validate that each group in self._on is monotonic rNr_zEach group within z' must be monotonic. Sort the values in z first.) rPrrrsrrrrrrTrb)rergroup_onrTs rfr~/RollingGroupby._validate_datetimelike_monotonicb s 88    ' '(B C!]]2299;Mxx}}]3H000H4T4T4T $WTWW (-**,W6 r?r@rArBrCrrDrEpandas.core.genericrFrxrHpandas.core.arrays.datetimelikerIrKrrrrr{rrerirfrsE#  ?>># 1-',2-+  .     ,39ppfF: F:RC  ZC  LB zB J s &s l..:&:ri