PitdZddlmZddlZddlmZddlmZddlZddl m Z m Z m Z m Z mZmZmZmZddlZddlmZmZmZddlmcmcmZddlmZdd lm Z dd l!m"Z"dd l#m$Z$m%Z%m&Z&m'Z'm(Z(dd l)m*Z*dd l+m,Z,m-Z-ddl.m/Z/ddl0m1Z1ddl2m3Z3ddl4m5Z5m6Z6ddl7m8Z8ddl9m:Z:ddl;mddl?m@Z@mAZAmBZBmCZCddlDmEZEmFZFmGZGmHZHmIZIddlJmKZKddlLmMZMmNZNmOZOddlPmQZQmRZRddlSmTZTmUZUmVZVe r8ddlWmXZXddlWmYZYmZZZm[Z[ddl\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdddlemfZfmgZgddlhmiZiddljmkZkdd llmmZmGd!d"e:ZnGd#d$enZoe"d%Gd&d'enZpGd(d)enZqe"d%Gd*d+eqZrepjer_e"d%Gd,d-eoerZsdS).zc Provide a generic structure to support window functions, similar to how we have a Groupby object. ) annotationsN) timedelta)partial) TYPE_CHECKINGAny ConcatenateLiteralSelfcastfinaloverload) BaseOffset Timedelta to_offset)import_optional_dependency) DataError) set_module)ensure_float64is_bool is_integeris_numeric_dtypeneeds_i8_conversion) ArrowDtype) ABCDataFrame ABCSeries)notna)executor) factorize)ResamplerWindowApplyreconstruct_func)ExtensionArray)SelectionMixin) BaseIndexerFixedWindowIndexerGroupbyIndexerVariableWindowIndexer) DatetimeIndexIndex MultiIndex PeriodIndexTimedeltaIndex)concat)get_jit_argumentsmaybe_use_numbaprepare_function_arguments)flex_binary_momentzsqrt)'generate_manual_numpy_nan_agg_with_axisgenerate_numba_apply_funcgenerate_numba_table_func)Callable)HashableIteratorSized) ArrayLikeNDFrameTQuantileInterpolationPTimeUnitTWindowingRankTypenpt) DataFrameSeries)NDFrame BaseGrouper) dtype_to_unitcPeZdZUdZgZded<eZded<ded< dXdd dYdZdZdZ d[d#Z d\d]d'Z d^d+Z d_d-Z d`dad.Zd\d/Zdbd1Zd2Zdcd3Zddd5Zded8Zdfd:Zedgd<Zdhd>Zdid@Z d\djdDZ d`dkdFZ dldmdGZdndNZ dodpdSZ d\dqdVZd\dWZ e Z!dS)r BaseWindowz7Provides utilities for performing windowing operations. list[str] _attributeszfrozenset[Hashable] exclusionsr(_onNFsingle) selectionobjrC min_periods int | Nonecenter bool | Nonewin_type str | Noneonstr | Index | NoneclosedstepmethodstrreturnNonec ||_||_||_||_||_||_||_||_| |_d|_ |j|jj |_ nt|jtr |j|_ njt|jtr8|j|jjvr%t|j|j|_ nt!d|jd| |_|dS)Nzinvalid on specified as z3, must be a column (of DataFrame), an Index or None)rOrVrXrYwindowrPrRrTrZ _win_freq_i8indexrL isinstancer(rcolumns ValueError _selection _validate) selfrOr_rPrRrTrVrXrYrZrNs n/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/pandas/core/window/rolling.py__init__zBaseWindow.__init__{s    &    (, 7?x~DHH  ' ' wDHH , / / DGtx?O4O4OTXdg.//DHHD47DDD  $ cV|j#t|jstd|jt |jstd|jdkrtdt |jr/|j|jkrtd|jd|j|j|jdvrtdt|jttfstd t|t|jtrtj|jjj}tjtjj}||kr)tt|jjd |jd vrtd |j=t |jstd |jdkrtddSdS)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)tablerMz!method must be 'table' or 'singlezstep must be an integerzstep must be >= 0)rRrrdrPrr_rXrbrOrr TypeErrortyper#inspect signatureget_window_bounds parameterskeys__name__rZrY)rgget_window_bounds_signatureexpected_signatures rhrfzBaseWindow._validates= ; "74;+?+? "788 8   'd.// C !ABBB!## !;<<<$+&& 4+;dk+I+I U4#3UU UU ; "t{; ( ( RSS S$(Y $=>> ;9T$ZZ99:: : dk; / / +2*; -++ (")!2 /"" +.@@@ DK((1CCC ;1 1 1@AA A 9 di(( < !:;;;y1}} !4555 ! }rjstart np.ndarrayendnum_valsintc Pt|t|kr0tdt|dt|dt|||jpdzdz |jpdzkr+tdt|d|d|jddS) 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)lenrdrY)rgr{r}r~s rh_check_window_boundszBaseWindow._check_window_boundss u::S ! !#e**S  u::(din159ty~AN N N+U++"*++CG9+++  O Nrjraresult Sized | Nonecj| t|t|kr|n|dd|jS)zJ Slices the index for a given result and the preset step. N)rrY)rgrars rh_slice_axis_for_stepzBaseWindow._slice_axis_for_steps; ~VE !:!: E||$)|$ rjname numeric_onlyboolc|jjdkrB|rBt|jjs+t t |jd|ddSdSdS)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)rgrrs rh_validate_numeric_onlyz!BaseWindow._validate_numeric_onlysx   #q ( ( )$T%7%=>> )&::&OOOOO  ) ( ( ( ( (rjr:c8|dgdg}|S)zSubset DataFrame to numeric columns. Parameters ---------- obj : DataFrame Returns ------- obj subset to numeric-only columns. numberr)includeexclude) select_dtypes)rgrOrs rh_make_numeric_onlyzBaseWindow._make_numeric_onlys%""H: }"MM rjc|j[t|jtsA|jdkr6||j|jgd}|jdkr|r||}|S)A Split data into blocks & return conformed data. NF)sort)rcr)rVrbr(rreindexrc differencer)rgrOrs rh _create_datazBaseWindow._create_datas{ 7 z$'5'A'A chRSmm++ck&<&z'BaseWindow._gotitem..%s%III$d++IIIrjrN)rOrJ_infer_selectionrr)rgkeyrsubsetkwargsrNnew_wins` rh_gotitemzBaseWindow._gotitemsl >XFJIII8HIII))#v66 $t**VCCyCFCCrjrc||jvrt||S||jvr||St dt |jd|d)N'z' object has no attribute ')_internal_names_setobject__getattribute__rOAttributeErrorrrrx)rgrs rh __getattr__zBaseWindow.__getattr__+sn 4+ + +**466 6 48  :  GT # G G G G G   rjc4|jSN)rO_dir_additionsrgs rhrzBaseWindow._dir_additions5sx&&(((rjcfdjD}d|}tjd|dS)z@ Provide a nice str repr of our rolling object. c3|K|]6}t|d|ddk|dt|V7dS)Nr_=r)r attr_namergs rh z&BaseWindow.__repr__..<sg  tY--9ilc>Q>Q 5 57433 5 5>Q>Q>Q>Q  rj,z [])rJjoinrrrx)rg attrs_listattrss` rh__repr__zBaseWindow.__repr__8sa    !-   $$t**%111111rjr7c#K|j|j}||}|}|t ||j|j|j |j \}}| ||t |t||dD]$\}}|j t||}|V%dS)N num_valuesrPrRrXrYT)strict)rset_axisrLr_get_window_indexerrurrPrRrXrYrzipilocslice)rgrOindexerr{r}sers rh__iter__zBaseWindow.__iter__Ds ))$(33$$**,,..3xx(;; /  s !!%c#hh777s4000  DAqXeAqkk*FLLLL  rjvaluesr9ct|jr-tdt|jd|jd t |t r,|tj tj }nt|}n1#ttf$r}td|j|d}~wwxYwtj|}|r tj|tj |}|S)z1Convert input to numpy arrays for Cython routineszops for z for this dtype z are not implemented)na_valuezcannot handle this type -> N)rrrrrrxrbr!to_numpynpfloat64nanrrdrqisinfanywhere)rgrerrinfs rh _prep_valueszBaseWindow._prep_valuesVs v| , , %<4::.<<<<<   S&.11 0bfEE'//I& S S SH&,HHIIs R Shv 7799 3Xc26622F sABC%B==CrAcddlm}|j|j|js|jj}||j|jj|d}||jvr|||<dS||jj vrdS||j jvrm|j j}|j}| |}| |d|} t| } || ||dS|||<dSdSdS)NrrBFrarcopy)pandasrBrVrLequalsrarrOrcnamesrget_loc intersectionrinsert) rgrrOrBr extra_colold_colsnew_colsold_locoverlapnew_locs rh_insert_on_columnzBaseWindow._insert_on_columnns "!!!!! 7 txsy'A'A 8=Dtxtx~DuUUUIv~%%(t ++++333-5!>"**400"//'0BCCg,, gtY77777 )t %    rjnpt.NDArray[np.int64] | Nonect|jtttfr |jjSt|jjtr8|jjjdvr%|j tj SdS)NmMr) rbrLr*r'r+asi8rrkindrrint64rs rh _index_arrayzBaseWindow._index_arraysp dhm^ L M M 58=  3 3 58Kt8S8S8$$28$44 4trjoutc|jddkr |jddkrtd|jddkr|dS||||S)zValidate and finalize result.rrNo numeric types to aggregater)shaperastyper)rgrrOs rh_resolve_outputzBaseWindow._resolve_outputsp 9Q<1  1!1!1;<< < 9Q<1  ::i(( ( sC((( rjr#ct|jtr|jS|j!t |j|j|jSt|jS)z[ Return an indexer class that will compute the window start and end bounds N) index_array window_sizerR)r)rbr_r#r`r&rrRr$rs rhrzBaseWindow._get_window_indexersf dk; / / ;    (( - -{  "dk::::rjhomogeneous_funcCallable[..., ArrayLike]rBc||j}|dkr't|t} ||j}n)#ttf$r}td|d}~wwxYw||}| |j |}| |||j S)z5 Series version of _apply_columnwise countrNrar)rrrrrr_valuesrqrrrra _constructorr)rgrrrOrrrras rh _apply_serieszBaseWindow._apply_seriess  233 7??**##C((C F&&s{33FF./ F F F;<<# E F"!&))))#)V<<e#(CCCs A$$B 5BB DataFrame | Seriesc||||jjdkr|||S||j|}|dkrEt |t}|j |_g}g}t| D]\}} | |}n1#ttf$r} td|j| d} ~ wwxYw||} || ||||jt)|dkr|dnd} t+||| |j|d} || |S)zl Apply the given function to the DataFrame broken down into homogeneous sub-frames. rrz#Cannot aggregate non-numeric type: NrF)rarcverify_integrity)rrrrrrrr_mgr consolidate enumerate_iter_column_arraysrrqrrrappendrrarrr _from_arraysrctaker) rgrrrrOtaker res_valuesiarrrresradfs rh_apply_columnwisezBaseWindow._apply_columnwises ##D,777   "a ' '%%&6== = 2LAA 7??**##C((Cx++--CH  7 7 9 9::  FAs '',,23   E#)EE #"3''C   c " " " LLOOOO)) IJ!(;(;z!}}  #YY # # K$$U++" $  ##B,,,sC$$D5D  Dc|jjdkrtd||j|}||}||}||j|}|jdt|j kr|j n|j dd|j }| |||} | | |S)zT Apply the given function to the DataFrame across the entire object rz1method='table' not applicable for Series objects.Nrarc)rrrdrrrrrarrrcrYrr) rgrrrrOrrrarcrs rh_apply_tablewisezBaseWindow._apply_tablewises   "a ' 'PQQ Q 2LAA""3<<>>22!!&))))#)V<<|A#ck"2"222 KK\\ \*  vUGDD##C---rjtargetotherDataFrame | Series | NonepairwisefuncFCallable[[DataFrame | Series, DataFrame | Series], DataFrame | Series]c|||}| |}|dn|}nMt|ttfst d|jdkr|r||}t|||t|S)] Apply the given pairwise function given 2 pandas objects (DataFrame/Series) NTz#other must be a DataFrame or Seriesr)r) rrbrrrdrrr0r)rgrrrr rs rh_apply_pairwisezBaseWindow._apply_pairwises""6<88 =E'/ttXHHEL)#<== 3BCC C Z1___++E22E!&%XOOOOrjrCallable[..., Any] numba_argstuple[Any, ...]c jjnjdfd }jdkr|||S|||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 Nrr|c|jdkr|Sfd}tjd5||}dddn #1swxYwY|S)Nrct|jjj\}}||t||||gRS)Nr)rurrRrXrYr)xr{r}r rPr&rgwindow_indexers rhcalcz9BaseWindow._apply..homogeneous_func..calcAsz+=="1vv +;; > s))%c!ff===tAuc;DDDDDrjignoreall)sizerrerrstate)rr-rr rPr&rgr,s rhrz+BaseWindow._apply..homogeneous_func;s{a{{}}$ E E E E E E E E E*** & &f & & & & & & & & & & & & & & &Ms AAArMrr|)rrPrrZrr) rgr rrr&rrrPr,s `` ` @@rh_applyzBaseWindow._applys41133+   +            . ;( " "))*:D,OO O(()94NN Nrj engine_kwargsdict[str, bool] | Nonec |}|j|jn|j}||j}||}|jdkr|dd}| t|||j |j |j \}} ||| t|tj} tj|| fddit%|} | |jf|| |d|j} ||j| } |jdkr3| } || | |j}|S||j| j}|| | |}|||S) Nrris_grouped_kernelF)r{r}rPrr)rrPrrrrrrreshaperurrRrXrYrrfloat_dtype_mappinggenerate_shared_aggregatorr-r>rrasqueezerrrcr)rgr r5 func_kwargsr,rPrOrr{r} dtype_mapping aggregatorrrarrcs rh _numba_applyzBaseWindow._numba_applyWs 1133+   +   233""3<<>>22 ;!  ^^B**F#556{{#;; 6  s !!%c&kk::: !4 8    $  ..    H !s   GR   ))#)V<< 8q==^^%%F""6SX"FFCJ// VXFFG""6"HHC''S11 1rjct|fi|\}}}}t||||}t|tr|r|jdd|f}||_|||d||S|S)NargsrF)rawrDr)r raggrbrrrcapply)rgr rDr relabelingrcorderrs rh aggregatezBaseWindow.aggregates+;D+K+KF+K+K( D'5%dDtFKKKOOQQ fl + + %  %[E*F$FN >::dD:HH H rj)NNFNNNNrM)rOrCrPrQrRrSrTrUrVrWrXrUrYrQrZr[r\r]r\r])r{r|r}r|r~rr\r]r)rar(rrr\r()rr[rrr\r])rOr:r\r:FrOr:rrr\r:)rr[)r\r[)r\r7)rr9r\r|)rrArOrAr\r])r\r)rrArOrAr\rA)r\r#)rrrrUr\rB)rrrr[rrr\r)NF)rrrrUrrr\r rrrrrrSr r!rrr\rFr)r r%rr[rrr&r')r r%r5r6)"rx __module__ __qualname____doc__rJ__annotations__ frozensetrKrirfrrrrrrrrrrrrpropertyrrrrrrr$r4rArJrFrrjrhrHrHtsAAK&/ikkJ1111JJJ "&##!%!%%%%%%%N)6)6)6)6V         (         0    ))) 2 2 2 2$0))))2X ; ; ; ;NRDDDDD0# ----------d " .....0PPPP6#&( ;O;O;O;O;O@15.2.2.2.2.2` CCCrjrHceZdZUdZded<ded<dgZded<dd d$fdZ d%d&fd Zd'fd Zd(d)fd! Z d*fd# Z xZ S)+BaseWindowGroupbyz3 Provide the groupby windowing facilities. rE_grouperr _as_indexrIrJT)rYrOrr\r]c2ddlm}t||std||_||_||jjd}|dtdtj |g|Ri|dS)NrrDzMust pass a BaseGrouper object.r.rcerrorsrYz step not implemented for groupby) pandas.core.groupby.opsrErbrdrXrYdroprgetrsuperri)rgrOrXrYrDrrE __class__s rhrizBaseWindowGroupby.__init__s 877777(K00 @>?? ?  "hht}28hDD ::f   )%&HII I.t...v.....rjFrr r%rr[rr&r'c btj||||fi|}jj}g|j}t jjj} | |z} fdjjD} t| t| kr|| d}jj } t jjj } jj }|r"tjt|n tjgtjfd| D} ||}t'|t(st)j|g}| t|j | t|j t)| | | d}||_js=|tt3t| }|S) Nc>g|]}|jjjvs||Sr)rOrar)rrrgs rh z,BaseWindowGroupby._apply..s7   $(....#+ 2=++rjr.r[rc:g|]}|Sr)r)rcrs rhrdz,BaseWindowGroupby._apply..s#000Q000rjFrr )level)r`r4rOrarrrXrr^codeslevelsindicesrr concatenatelistarrayintprrbr) from_arraysextendrY reset_indexrange)rgr rrr&rrgrouped_object_indexgrouped_index_name groupby_keysresult_index_names drop_columnsrirj group_indicesidx result_indexrras` @rhr4zBaseWindowGroupby._applys1            $x~:39:y!455 ),>>    }*   |  L 1 1 1 1[[h[GGF #4=/00 -4466  2nT-%8%899GGhr111G0000%000 +&++G44Cc:.. 4 ,cU33 LLci ) ) ) MM$sz** + + +! E!3e   $ ~ N''d5\9J9J3K3K.L.L'MMF rjrrrrrSr!c||jjd}t||||/t fd|jjDst}tfd|jjDd|jj D}g}g} ttt|ddiD]e} tjtj| |} t#| \} } || | | fn|jj}|jj} |jj}|r"tjt|n tjgtj |jd krd nt|jfd |D}t3jt6rLtjj}tjj}tjj}n*t#j\}}|g}|g}jjg}||z}| |z}|jj|z}t7|||d }|_S)r#r.r[Nc3XK|]$}t|tkV%dSr)r)rgrouprs rhrz4BaseWindowGroupby._apply_pairwise..sE) ) ).CJJ#e** $) ) ) ) ) ) rjcjg|]/}|j0Sr)rrra)r gb_indicesrs rhrdz5BaseWindowGroupby._apply_pairwise.. sE"KK ++33FLAArjc3>K|]}tj|VdSr)commaybe_make_list)rpairs rhrz4BaseWindowGroupby._apply_pairwise..s>.2#D))rjrTrrc`g|]*}tj|+Sr)rrepeatr)rrfr repeat_bys rhrdz5BaseWindowGroupby._apply_pairwise..,s<:; !&&//955rjFrg)r^rXrr`r$r0rkrrr,rwmaprmrrrrnrrrirjrlrorrcrbrar)r)rgrrrr rold_result_lengb_pairs groupby_codesgroupby_levels gb_level_pairlabelsrirjry result_codes result_levels result_names idx_codes idx_levelsr{rrrras ` @@@rhr$z!BaseWindowGroupby._apply_pairwises T]%8JJ(($ UU  S) ) ) ) 26-2G2N2N2P2P) ) ) & & ![[N&*m&;&B&B&D&DF6:m6K6P6P6R6RHMN!$T3+F+F+F!G!G . . 28M#:#:NKK )& 1 1 v$$U+++%%f----  .!M/M"]1N M188::M 6.m)<)<==(2RW555{a // ?LM flJ / / / 233L !455M 233LL$-fl$;$; !Iz%;L'LM"L-.L%|3 &6 }*\9 ! <|e   $  rjr:c4|jsotjt|jjtj}| |}t ||S)r) emptyrrlrmrXrkrrrrr`r)rgrOr groupby_orderras rhrzBaseWindowGroupby._create_dataEsyy *N4 0E0L0L0N0N+O+OPPWWM((=))Cww##C666rjNc|j|j|j}t |||S)N)r)rVrO set_indexrLr`r)rgrrrras rhrzBaseWindowGroupby._gotitemSsC 7 X''11FwwT&999rj)rOrrXrErYrr\r]rO) r r%rr[rrr&r'r\rrNrLrMr) rxrPrQrRrSrJrir4r$rr __classcell__ras@rhrWrWsOOO(\K)))) ////////6#&( ;;;;;;;zRRRRRRh 7 7 7 7 7 7 7::::::::::rjrWzpandas.api.typingcveZdZdZgdZdfd Zdd Z d d!dZd"dZeZ d#d$dZ d#d$dZ d%d&dZ d%d&dZ xZS)'Windowa Provide rolling window calculations. Parameters ---------- window : int, timedelta, str, offset, or BaseIndexer subclass Interval of the moving window. If an integer, the delta between the start and end of each window. The number of points in the window depends on the ``closed`` argument. 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 :ref:`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. closed : str, default None Determines the inclusivity of points in the window If ``'right'``, uses the window (first, last] meaning the last point is included in the calculations. If ``'left'``, uses the window [first, last) meaning the first point is included in the calculations. If ``'both'``, uses the window [first, last] meaning all points in the window are included in the calculations. If ``'neither'``, uses the window (first, last) meaning the first and last points in the window are excluded from calculations. () and [] are referencing open and closed set notation respetively. Default ``None`` (``'right'``). step : int, default None 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' 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 r_rPrRrTrVrXrYrZr\r]c tt|jtst d|jt dd}t||jd|_|jt d|jt|j trtdt|j r |j dkrt d|j dkrtd dS) 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 greaterrMz+'single' is the only supported method type.)r`rfrbrTr[rdrr_scipy_weight_generatorr_r#rrrZ)rgsignalras rhrfzWindow._validatees $--- B@@@AA A+ "*X   (/vt}d'K'K$  ' /@@@AA A dk; / / %H $+&& G$+//EFF F ;( " "%&STT T # "rjrr|offsetrc|dkr8t|dg}tj|t|}|S)zT Center the result in the window for weighted rolling aggregations. rN)rrrtuple)rgrr lead_indexers rh_center_windowzWindow._center_window{s@ A::!&$//0LWVE,$7$7899F rjFrr ,Callable[[np.ndarray, int, int], np.ndarray]rr[rrr&r'c jjfi|jrtdz dznddfd }|||ddjS) 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 rrrrr|c$|jdkr|Sfd}tjd5tj||}dddn #1swxYwYjr|}|S)Nrctjtj}tj||f}|jjnt Sr)rfullrrlrPr)r+additional_nansr rrgr_s rhr-z5Window._apply..homogeneous_func..calcs]"$'&"&"9"9NA#788t(,(8(DD$$#f++rjr.r/)r1rrr2asarrayrRr)rr-rr rrgr_s rhrz'Window._apply..homogeneous_funcs{a{{}}$        *** 2 2DDLL11 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2{ =,,VV<<MsA((A,/A,Nr3)rr_rRrrrY) rgr rrr&rrrr_s `` @@rhr4z Window._applys:.- K  !  ,0;=#f++/a''A         0%%&6lKK LtyL  rjNcjt||||}| ||}|S)ao Aggregate using one or more operations over the specified axis. Parameters ---------- func : function, str, list or dict Function to use for aggregating the data. If a function, must either work when passed a Series/DataFrame or when passed to Series/DataFrame.apply. Accepted combinations are: - function - string function name - list of functions and/or function names, e.g. ``[np.sum, 'mean']`` - dict of axis labels -> functions, function names or list of such. *args Positional arguments to pass to `func`. **kwargs Keyword arguments to pass to `func`. Returns ------- scalar, Series or DataFrame The return can be: * scalar : when Series.agg is called with single function * Series : when DataFrame.agg is called with a single function * DataFrame : when DataFrame.agg is called with several functions See Also -------- DataFrame.aggregate : Similar DataFrame method. Series.aggregate : Similar Series method. Notes ----- The aggregation operations are always performed over an axis, either the index (default) or the column axis. This behavior is different from `numpy` aggregation functions (`mean`, `median`, `prod`, `sum`, `std`, `var`), where the default is to compute the aggregation of the flattened array, e.g., ``numpy.mean(arr_2d)`` as opposed to ``numpy.mean(arr_2d, axis=0)``. `agg` is an alias for `aggregate`. Use the alias. Functions that mutate the passed object can produce unexpected behavior or errors and are not supported. See :ref:`gotchas.udf-mutation` for more details. A passed user-defined-function will be passed a Series for evaluation. If ``func`` defines an index relabeling, ``axis`` must be ``0`` or ``index``. 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 rC)rrF)rgr rDrrs rhrJzWindow.aggregates>P&dDtFKKKOOQQ >T$ZZF rjc <tj}|j|fd|d|S)a Calculate the rolling weighted window sum. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. **kwargs Keyword arguments to configure the ``SciPy`` weighted window type. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.rolling : Calling rolling with Series data. DataFrame.rolling : Calling rolling with DataFrames. Series.sum : Aggregating sum for Series. DataFrame.sum : Aggregating sum for DataFrame. Examples -------- >>> 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 sumrr)window_aggregationsroll_weighted_sumr4rgrr window_funcs rhrz Window.sumsB^*; t{  %      rjc <tj}|j|fd|d|S)a Calculate the rolling weighted window mean. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. **kwargs Keyword arguments to configure the ``SciPy`` weighted window type. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.rolling : Calling rolling with Series data. DataFrame.rolling : Calling rolling with DataFrames. Series.mean : Aggregating mean for Series. DataFrame.mean : Aggregating mean for DataFrame. Examples -------- >>> 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 meanr)rroll_weighted_meanr4rs rhrz Window.meanMsB\*< t{  %      rjrddofc ttj|}|dd|j|fd|d|S)aB Calculate the rolling weighted window variance. Parameters ---------- ddof : int, default 1 Delta Degrees of Freedom. The divisor used in calculations is ``N - ddof``, where ``N`` represents the number of elements. numeric_only : bool, default False Include only float, int, boolean columns. **kwargs Keyword arguments to configure the ``SciPy`` weighted window type. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.rolling : Calling rolling with Series data. DataFrame.rolling : Calling rolling with DataFrames. Series.var : Aggregating var for Series. DataFrame.var : Aggregating var for DataFrame. Examples -------- >>> 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 rrNvarr)rrroll_weighted_varpopr4)rgrrrrs rhrz Window.varsQb1C$OOO  64   t{;XUXXQWXXXrjc >t|jd|d|d|S)a` Calculate the rolling weighted window standard deviation. Parameters ---------- ddof : int, default 1 Delta Degrees of Freedom. The divisor used in calculations is ``N - ddof``, where ``N`` represents the number of elements. numeric_only : bool, default False Include only float, int, boolean columns. **kwargs Keyword arguments to configure the ``SciPy`` weighted window type. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.rolling : Calling rolling with Series data. DataFrame.rolling : Calling rolling with DataFrames. Series.std : Aggregating std for Series. DataFrame.std : Aggregating std for DataFrame. Examples -------- >>> 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 std)rrrr)r1r)rgrrrs rhrz Window.stds5b DH P$U P P P P   rjrK)rr|rrr\r|rO)r rrr[rrr&r'rrLrrrFrrrr)rxrPrQrRrJrfrr4rJrFrrrrrrs@rhrr]s#yyv   KUUUUUU,#&( < < < < < |MMMM^ C8 8 8 8 8 t7 7 7 7 7 r3Y3Y3Y3Y3Yj3 3 3 3 3 3 3 3 3 rjrcbeZdZdFdGdZ dHdIdZdJdZedKdZedLd ZdMd"Z dNdOd#Z dNdOd$Z dNdOd%Z dNdOd&Z dNdOd'Z dPdQd+Z dPdQd,ZdFdGd-ZdRdSd.ZdFdGd/ZdFdGd0ZdFdGd1Z dTdUd7Z dVdWd>Z dFdGd?Z dXdYdDZ dXdYdEZdS)ZRollingAndExpandingMixinFrrcJtj}||d|S)Nrr)rroll_sumr4rgrrs rhrzRollingAndExpandingMixin.counts")2 {{;W<{PPPrjNr r%rEengine!Literal['cython', 'numba'] | Noner5r6rDtuple[Any, ...] | Nonerdict[str, Any] | Nonec|d}|i}t|stdd}t|rj|durtdt|||d\}}|jdkrt |fit |}nXt|fit |}n=|dvr*|td |||||}ntd | |d | S) Nrz'raw parameter must be `True` or `False`Fz.raw must be `True` when using the numba enginer)num_required_argsrM)cythonNz+cython engine does not accept engine_kwargsz)engine must be either 'numba' or 'cython'rG)rr&) rrdr.r/rZr3r-r4_generate_cython_apply_funcr4) rgr rErr5rDrr& apply_funcs rhrGzRollingAndExpandingMixin.applysZ <D >Fs|| HFGG G&( 6 " " Je|| !QRRR!;dFa""" J{h&&6-m<< 7-m<< ' ' '( !NOOO99$TRRJJHII I{{ !   rjr'dict[str, Any]bool | np.bool_functionr\?Callable[[np.ndarray, np.ndarray, np.ndarray, int], np.ndarray]cddlmttj||t |||ffd }|S)Nrr)rDrrErcJ|s|jd}||||S)NF)rar)rL)rbeginr}rPrErBrgrs rhrzHRollingAndExpandingMixin._generate_cython_apply_func..apply_func4s: DdhUCCC;vuc;?? ?rj)rrBrr roll_applyr)rgrDrrErrrBrs` @@rhrz4RollingAndExpandingMixin._generate_cython_apply_func#s "!!!!!  *S     =@ @ @ @ @ @ @ @ @ rj!Callable[Concatenate[Self, P], T]P.argsP.kwargsr>cdSrrrgr rDrs rhpipezRollingAndExpandingMixin.pipe< Crjtuple[Callable[..., T], str]rcdSrrrs rhrzRollingAndExpandingMixin.pipeDrrj@Callable[Concatenate[Self, P], T] | tuple[Callable[..., T], str]c.tj||g|Ri|Sr)rrrs rhrzRollingAndExpandingMixin.pipeLs& xd4T444V444rjct|rY|jdkr2ttj}||d||Sddlm}|||Stj }| |d|S)NrpTrErr5r) sliding_sumrr) r.rZr2rnansumrGpandas.core._numba.kernelsrrArrr4)rgrrr5r rrs rhrzRollingAndExpandingMixin.sumTs 6 " " E{g%%>ryIIzz!"/ "CBBBBB((mDDD)2 {{;U{NNNrjct|r[|jdkr2ttj}||d||Sddlm}|||dStj }| |d|S) NrpTrrsliding_min_maxis_maxmaxr) r.rZr2rnanmaxrGrrrArroll_maxr4rgrrr5r rrs rhrzRollingAndExpandingMixin.maxjs 6 " " V{g%%>ryIIzz!"/ "GFFFFF((-PT(UUU)2 {{;U{NNNrjct|r[|jdkr2ttj}||d||Sddlm}|||dStj }| |d| S) NrpTrrrFrminr) r.rZr2rnanminrGrrrArroll_minr4rs rhrzRollingAndExpandingMixin.mins 6 " " W{g%%>ryIIzz!"/ "GFFFFF((-PU(VVV)2 {{;U{NNNrjct|rY|jdkr2ttj}||d||Sddlm}|||Stj }| |d|S)NrpTrr) sliding_meanrr) r.rZr2rnanmeanrGrrrAr roll_meanr4)rgrrr5r rrs rhrzRollingAndExpandingMixin.means 6 " " F{g%%>rzJJzz!"/ "DCCCCC((}EEE)3 {{;V,{OOOrjct|rJ|jdkrttj}n tj}||d||St j}||d|S)NrpTrmedianr) r.rZr2r nanmedianrGr roll_median_cr4)rgrrr5r rs rhrzRollingAndExpandingMixin.medians 6 " " {g%%>r|LL|::+   *7 {{;XL{QQQrjrrrct|rE|jdkrtdddlm}t |||Stjfd}| |d|S) Nrpz%std not supported with method='table'r sliding_varrc >t||||S)Nr)r1)rrr}rPrrs rh zsqrt_funcz0RollingAndExpandingMixin.std..zsqrt_funcs&VUC4PPPQQ Qrjrr) r.rZrrrr1rArroll_varr4)rgrrrr5rrrs ` @rhrzRollingAndExpandingMixin.stds 6 " " S{g%%)*QRRR > > > > > >**; D*QQRR R)2  R R R R R R{{ %   rjct|r8|jdkrtdddlm}||||St tj|}| |d|S)Nrpz%var not supported with method='table'rrrrr) r.rZrrrrArrrr4)rgrrrr5rrs rhrzRollingAndExpandingMixin.vars 6 " " L{g%%)*QRRR > > > > > >$$[-d$KK K1:FFF {{ %   rjcJtj}||d|S)Nskewr)r roll_skewr4rs rhrzRollingAndExpandingMixin.skew.)3 {{ %   rjc|d||||||dz S)Nsemrrr?rrrpowrgrrs rhr zRollingAndExpandingMixin.semsQ ##E<888xx\x== JJLJ 1 1 #c(( rjcJtj}||d|S)Nkurtr)r roll_kurtr4rs rhrzRollingAndExpandingMixin.kurtr rjcJtj}||d|S)Nfirstr)r roll_firstr4rs rhrzRollingAndExpandingMixin.firsts.)4 {{ %   rjcJtj}||d|S)Nlastr)r roll_lastr4rs rhrzRollingAndExpandingMixin.last r rjlinearqfloat interpolationr;c|dkr tj}n/|dkr tj}nttj||}||d|S)Ng?g)quantilerr!r)rrrr roll_quantiler4)rgrrrrs rhr!z!RollingAndExpandingMixin.quantilesd 88-6KK #XX-6KK!#1+K {{;Zl{SSSrjaverageTrZr? ascendingpctclttj|||}||d|S)N)rZr$ percentilerankr)rr roll_rankr4)rgrZr$r%rrs rhr(zRollingAndExpandingMixin.rank'sA  )    {{;V,{OOOrjcdttj}||d|S)Nnuniquer)rr roll_nuniquer4rs rhr+z RollingAndExpandingMixin.nunique7s3  ,  {{;Y\{RRRrjrrrrScjtdd|ddlmfd}j||||S)Nzstep not implemented for covcovrrc*|}|}}jjn|j}|t ||jjj\}} ||t |tj d5tj ||z|||}tj ||||} tj ||||} tjt||ztj||d} || | zz | | z z z} dddn #1swxYwY | |j|jdS)Nrr.r/rFr)rrrPrrurrRrXrYrrr2rrrrrrrar)r+yx_arrayy_arrayr,rPr{r}mean_x_ymean_xmean_y count_x_yrrBrrgs rhcov_funcz.RollingAndExpandingMixin.cov..cov_funcNs''**G''**G!5577N#/  #/  (99w<<'{{Y :JE3  % %eS#g,, ? ? ?*** Y Y.8g%uc;-6wsKXX,6wsKXX/8'G+,,33BJ??Q #Vf_4iRVFV9WX Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y6&af5III IsBE11E58E5rYrrrrBr$r)rgrrrrr7rBs` ` @rhr.zRollingAndExpandingMixin.covAs 9 %&DEE E ##E<888!!!!!! J J J J J J J<##  x<   rjcjtdd|ddlmfd}j||||S)Nzstep not implemented for corrcorrrrc|}|}}jjn|j}|t ||jjj\}} ||t |tj d5tj ||z|||}tj ||||} tj ||||} tjt||ztj||d} tj||||} tj||||} || | zz | | z z z}| | zdz}||z }dddn #1swxYwY||j|jdS)Nrr.r/rrFr)rrrPrrurrRrXrYrrr2rrrrrrrrar)r+r0r1r2r,rPr{r}r3r4r5r6x_vary_var numerator denominatorrrBrrgs rh corr_funcz0RollingAndExpandingMixin.corr..corr_func}s=''**G''**G!5577N#/  #/  (99w<<'{{Y :JE3  % %eS#g,, ? ? ?*** 1 1.8g%uc;-6wsKXX,6wsKXX/8'G+,,33BJ??Q ,4UCd,4UCd&7T!12  %u}4 "[0' 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1(6&af5III IsCF..F25F2r8)rgrrrrr@rBs` ` @rhr:zRollingAndExpandingMixin.corrps 9 %&EFF F ##FL999!!!!!!& J& J& J& J& J& J& JP##  xL   rjrLrFNNNN r r%rErrrr5r6rDrrr) rDr'rrrErrr%r\rr rrDrrrr\r>r rrDrrrr\r>r rrDrrrr\r>FNNrrrrr5r6rFNNrrrrrrr5r6rrrFrrrr;rrr#TFFrZr?r$rr%rrrNNrFrrrrSrrrr)rxrPrQrrGrr rrrrrrrrrr rrrr!r(r+r.r:rrjrhrrs!QQQQQ4804'+(,+ + + + + Z2XX5555#4804 OOOOO0#4804 OOOOO0#4804 OOOOO0#4804 PPPPP0#4804 RRRRR."4804      4"4804      (                    08" TTTTT*%." PPPPP$#SSSSS,0 $" - - - - - b,0 $" 7 7 7 7 7 7 7 rjrceZdZUgdZded<dKfd ZdKdZdLd ZdMfd ZeZ dNdOfd Z dPdQfd Z e dRd!Z e dSd$Z edTfd& Z dUdVfd' Z dNd d d(dVfd)Z dUdVfd* Z dUdVfd+ Z dUdVfd, Z dWdXfd0 Z dWdXfd1 ZdNdOfd2 ZdYdZd3ZdNdOfd4 ZdNdOfd5 ZdNdOfd6 Z d[d\fd< Z d]d^fdC Z dNdOfdD Z d_d`fdI Z d_d`fdJ ZxZ S)aRollingrrIrJr\r]cpt|jjs[t |jt ttfs4t |jj trw|jj j dvrct |j tttfr;| t#|j }n2#t$t&f$r}t'd|j d|d}~wwxYwt |jtr1|j|jjj|jjjz z |_nn t1|jj }n#t$$rd}YnwxYwt3d|}t5|j|j|_|jd|_|jt?ddSt |j t@rdStC|j r |j dkrt'd dS) Nrzpassed window z, is not compatible with a datetimelike indexnsr=rz,step is not supported with frequency windowsrr)"r`rfrOrrbrLr'r+r*rrrr_r[rr _validate_datetimelike_monotonicrrqrdnanosfreqnr`rFr ras_unit_valuerPrYrr#r)rgrVrunitras rhrfzRolling._validatesA  HN+ G$(]NK$PQQ+ G48>:66+ G<@8>;NRV;V;VsJ &BCCtj|g|Ri|S)a Aggregate using one or more operations over the specified axis. Parameters ---------- func : function, str, list or dict Function to use for aggregating the data. If a function, must either work when passed a Series/Dataframe or when passed to Series/Dataframe.apply. Accepted combinations are: - function - string function name - list of functions and/or function names, e.g. ``[np.sum, 'mean']`` - dict of axis labels -> functions, function names or list of such. *args Positional arguments to pass to `func`. **kwargs Keyword arguments to pass to `func`. Returns ------- scalar, Series or DataFrame The return can be: * scalar : when Series.agg is called with single function * Series : when DataFrame.agg is called with a single function * DataFrame : when DataFrame.agg is called with several functions See Also -------- Series.rolling : Calling object with Series data. DataFrame.rolling : Calling object with DataFrame data. Notes ----- The aggregation operations are always performed over an axis, either the index (default) or the column axis. This behavior is different from `numpy` aggregation functions (`mean`, `median`, `prod`, `sum`, `std`, `var`), where the default is to compute the aggregation of the flattened array, e.g., ``numpy.mean(arr_2d)`` as opposed to ``numpy.mean(arr_2d, axis=0)``. `agg` is an alias for `aggregate`. Use the alias. Functions that mutate the passed object can produce unexpected behavior or errors and are not supported. See :ref:`gotchas.udf-mutation` for more details. A passed user-defined-function will be passed a Series for evaluation. If ``func`` defines an index relabeling, ``axis`` must be ``0`` or ``index``. 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 )r`rJrgr rDrras rhrJzRolling.aggregates-\!uww 7777777rjFrrcFt|S)a1 Calculate the rolling count of non NaN observations. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.rolling : Calling rolling with Series data. DataFrame.rolling : Calling rolling with DataFrames. Series.count : Aggregating count for Series. DataFrame.count : Aggregating count for DataFrame. Examples -------- >>> 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`rrgrras rhrz Rolling.countJsVww}}\***rjr r%rErrr5r6rDrrrcRt||||||S)a Calculate the rolling custom aggregation function. Parameters ---------- func : function Must produce a single value from an ndarray input if ``raw=True`` or a single value from a Series if ``raw=False``. Can also accept a Numba JIT function with ``engine='numba'`` specified. raw : bool, default False * ``False`` : passes each row or column as a Series to the function. * ``True`` : the passed function will receive ndarray objects instead. If you are just applying a NumPy reduction function this will achieve much better performance. engine : str, default None * ``'cython'`` : Runs rolling apply through C-extensions from cython. * ``'numba'`` : Runs rolling apply through JIT compiled code from numba. Only available when ``raw`` is set to ``True``. * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba``. engine_kwargs : dict, default None * For ``'cython'`` engine, there are no accepted ``engine_kwargs`` * For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'nopython': True, 'nogil': False, 'parallel': False}`` and will be applied to both the ``func`` and the ``apply`` rolling aggregation. args : tuple, default None Positional arguments to be passed into func. kwargs : dict, default None Keyword arguments to be passed into func. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.rolling : Calling rolling with Series data. DataFrame.rolling : Calling rolling with DataFrames. Series.apply : Aggregating apply for Series. DataFrame.apply : Aggregating apply for DataFrame. Examples -------- >>> 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 )rErr5rDr)r`rG)rgr rErr5rDrras rhrGz Rolling.applyws7Rww}} '    rjrrrr>cdSrrrs rhrz Rolling.piperrjrrcdSrrrs rhrz Rolling.piperrjrc>tj|g|Ri|S)a Apply a ``func`` with arguments to this Rolling object and return its result. Use `.pipe` when you want to improve readability by chaining together functions that expect Series, DataFrames, GroupBy, Rolling, Expanding or Resampler objects. Instead of writing >>> h = lambda x, arg2, arg3: x + 1 - arg2 * arg3 >>> g = lambda x, arg1: x * 5 / arg1 >>> f = lambda x: x**4 >>> df = pd.DataFrame( ... {"A": [1, 2, 3, 4]}, index=pd.date_range("2012-08-02", periods=4) ... ) >>> h(g(f(df.rolling("2D")), arg1=1), arg2=2, arg3=3) # doctest: +SKIP You can write >>> ( ... df.rolling("2D").pipe(f).pipe(g, arg1=1).pipe(h, arg2=2, arg3=3) ... ) # doctest: +SKIP which is much more readable. Parameters ---------- func : callable or tuple of (callable, str) Function to apply to this Rolling object or, alternatively, a `(callable, data_keyword)` tuple where `data_keyword` is a string indicating the keyword of `callable` that expects the Rolling object. *args : iterable, optional Positional arguments passed into `func`. **kwargs : dict, optional A dictionary of keyword arguments passed into `func`. Returns ------- Rolling The original object with the function `func` applied. See Also -------- Series.pipe : Apply a function with arguments to a series. DataFrame.pipe: Apply a function with arguments to a dataframe. apply : Apply function to each group instead of to the full Rolling object. Notes ----- See more `here `__. Examples -------- >>> df = pd.DataFrame( ... {"A": [1, 2, 3, 4]}, index=pd.date_range("2012-08-02", periods=4) ... ) >>> df A 2012-08-02 1 2012-08-03 2 2012-08-04 3 2012-08-05 4 To get the difference between each rolling 2-day window's maximum and minimum value in one pass, you can do >>> df.rolling("2D").pipe(lambda x: x.max() - x.min()) A 2012-08-02 0.0 2012-08-03 1.0 2012-08-04 1.0 2012-08-05 1.0 )r`rres rhrz Rolling.pipes,juww|D242226222rjcLt|||S)at Calculate the rolling sum. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. engine : str, default None * ``'cython'`` : Runs the operation through C-extensions from cython. * ``'numba'`` : Runs the operation through JIT compiled code from numba. * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba`` engine_kwargs : dict, default None * For ``'cython'`` engine, there are no accepted ``engine_kwargs`` * For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'nopython': True, 'nogil': False, 'parallel': False}``. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.rolling : Calling rolling with Series data. DataFrame.rolling : Calling rolling with DataFrames. Series.sum : Aggregating sum for Series. DataFrame.sum : Aggregating sum for DataFrame. Notes ----- See :ref:`window.numba_engine` and :ref:`enhancingperf.numba` for extended documentation and performance considerations for the Numba engine. Examples -------- >>> 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 rrr5)r`rrgrrr5ras rhrz Rolling.sum0 s.vww{{%'   rj)rr5cLt|||S)a Calculate the rolling maximum. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. *args : iterable, optional Positional arguments passed into ``func``. engine : str, default None * ``'cython'`` : Runs the operation through C-extensions from cython. * ``'numba'`` : Runs the operation through JIT compiled code from numba. * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba`` engine_kwargs : dict, default None * For ``'cython'`` engine, there are no accepted ``engine_kwargs`` * For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'nopython': True, 'nogil': False, 'parallel': False}``. **kwargs : mapping, optional A dictionary of keyword arguments passed into ``func``. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.rolling : Calling rolling with Series data. DataFrame.rolling : Calling rolling with DataFrames. Series.max : Aggregating max for Series. DataFrame.max : Aggregating max for DataFrame. Notes ----- See :ref:`window.numba_engine` and :ref:`enhancingperf.numba` for extended documentation and performance considerations for the Numba engine. Examples -------- >>> ser = pd.Series([1, 2, 3, 4]) >>> ser.rolling(2).max() 0 NaN 1 2.0 2 3.0 3 4.0 dtype: float64 rm)r`r)rgrrr5rDrras rhrz Rolling.max s.Bww{{%'   rjcLt|||S)a, Calculate the rolling minimum. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. engine : str, default None * ``'cython'`` : Runs the operation through C-extensions from cython. * ``'numba'`` : Runs the operation through JIT compiled code from numba. * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba`` engine_kwargs : dict, default None * For ``'cython'`` engine, there are no accepted ``engine_kwargs`` * For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'nopython': True, 'nogil': False, 'parallel': False}``. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.rolling : Calling rolling with Series data. DataFrame.rolling : Calling rolling with DataFrames. Series.min : Aggregating min for Series. DataFrame.min : Aggregating min for DataFrame. Notes ----- See :ref:`window.numba_engine` and :ref:`enhancingperf.numba` for extended documentation and performance considerations for the Numba engine. Examples -------- 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 rm)r`rrns rhrz Rolling.min s.xww{{%'   rjcLt|||S)a Calculate the rolling mean. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. engine : str, default None * ``'cython'`` : Runs the operation through C-extensions from cython. * ``'numba'`` : Runs the operation through JIT compiled code from numba. * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba`` engine_kwargs : dict, default None * For ``'cython'`` engine, there are no accepted ``engine_kwargs`` * For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'nopython': True, 'nogil': False, 'parallel': False}``. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.rolling : Calling rolling with Series data. DataFrame.rolling : Calling rolling with DataFrames. Series.mean : Aggregating mean for Series. DataFrame.mean : Aggregating mean for DataFrame. Notes ----- See :ref:`window.numba_engine` and :ref:`enhancingperf.numba` for extended documentation and performance considerations for the Numba engine. Examples -------- 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 rm)r`rrns rhrz Rolling.mean s.Fww||%'   rjcLt|||S)aD Calculate the rolling median. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. engine : str, default None * ``'cython'`` : Runs the operation through C-extensions from cython. * ``'numba'`` : Runs the operation through JIT compiled code from numba. * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba`` engine_kwargs : dict, default None * For ``'cython'`` engine, there are no accepted ``engine_kwargs`` * For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'nopython': True, 'nogil': False, 'parallel': False}``. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.rolling : Calling rolling with Series data. DataFrame.rolling : Calling rolling with DataFrames. Series.median : Aggregating median for Series. DataFrame.median : Aggregating median for DataFrame. Notes ----- See :ref:`window.numba_engine` and :ref:`enhancingperf.numba` for extended documentation and performance considerations for the Numba engine. Examples -------- 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 rm)r`rrns rhrzRolling.medianc s.xww~~%'   rjrrrcNt||||S)aX Calculate the rolling standard deviation. Parameters ---------- ddof : int, default 1 Delta Degrees of Freedom. The divisor used in calculations is ``N - ddof``, where ``N`` represents the number of elements. numeric_only : bool, default False Include only float, int, boolean columns. engine : str, default None * ``'cython'`` : Runs the operation through C-extensions from cython. * ``'numba'`` : Runs the operation through JIT compiled code from numba. * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba`` engine_kwargs : dict, default None * For ``'cython'`` engine, there are no accepted ``engine_kwargs`` * For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'nopython': True, 'nogil': False, 'parallel': False}``. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- numpy.std : Equivalent method for NumPy array. Series.rolling : Calling rolling with Series data. DataFrame.rolling : Calling rolling with DataFrames. Series.std : Aggregating std for Series. DataFrame.std : Aggregating std for DataFrame. Notes ----- 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. Examples -------- >>> 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 rrrr5)r`rrgrrrr5ras rhrz Rolling.std 1Fww{{%'    rjcNt||||S)aN Calculate the rolling variance. Parameters ---------- ddof : int, default 1 Delta Degrees of Freedom. The divisor used in calculations is ``N - ddof``, where ``N`` represents the number of elements. numeric_only : bool, default False Include only float, int, boolean columns. engine : str, default None * ``'cython'`` : Runs the operation through C-extensions from cython. * ``'numba'`` : Runs the operation through JIT compiled code from numba. * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba`` engine_kwargs : dict, default None * For ``'cython'`` engine, there are no accepted ``engine_kwargs`` * For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'nopython': True, 'nogil': False, 'parallel': False}``. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- numpy.var : Equivalent method for NumPy array. Series.rolling : Calling rolling with Series data. DataFrame.rolling : Calling rolling with DataFrames. Series.var : Aggregating var for Series. DataFrame.var : Aggregating var for DataFrame. Notes ----- 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. Examples -------- >>> 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 rt)r`rrus rhrz Rolling.var rvrjcHt|S)a" Calculate the rolling unbiased skewness. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- scipy.stats.skew : Third moment of a probability density. Series.rolling : Calling rolling with Series data. DataFrame.rolling : Calling rolling with DataFrames. Series.skew : Aggregating skew for Series. DataFrame.skew : Aggregating skew for DataFrame. Notes ----- A minimum of three periods is required for the rolling calculation. Examples -------- >>> 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 r)r`rrgs rhrz Rolling.skew9 sNww|||666rjc|d||||||dz S)aB Calculate the rolling standard error of mean. Parameters ---------- ddof : int, default 1 Delta Degrees of Freedom. The divisor used in calculations is ``N - ddof``, where ``N`` represents the number of elements. numeric_only : bool, default False Include only float, int, boolean columns. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.rolling : Calling rolling with Series data. DataFrame.rolling : Calling rolling with DataFrames. Series.sem : Aggregating sem for Series. DataFrame.sem : Aggregating sem for DataFrame. Notes ----- A minimum of one period is required for the calculation. Examples -------- >>> s = pd.Series([0, 1, 2, 3]) >>> s.rolling(2, min_periods=1).sem() 0 NaN 1 0.5 2 0.5 3 0.5 dtype: float64 r r rrrs rhr z Rolling.semb sRP ##E<888xx\x== JJ| $ $ #c(( rjcHt|S)a Calculate the rolling Fisher's definition of kurtosis without bias. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- scipy.stats.kurtosis : Reference SciPy method. Series.rolling : Calling rolling with Series data. DataFrame.rolling : Calling rolling with DataFrames. Series.kurt : Aggregating kurt for Series. DataFrame.kurt : Aggregating kurt for DataFrame. Notes ----- A minimum of four periods is required for the calculation. Examples -------- The example below will show a rolling calculation with a window size of four matching the equivalent function call using `scipy.stats`. >>> 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 r)r`rrgs rhrz Rolling.kurt s\ww|||666rjcHt|S)a] Calculate the rolling First (left-most) element of the window. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- GroupBy.first : Similar method for GroupBy objects. Rolling.last : Method to get the last element in each window. Examples -------- The example below will show a rolling calculation with a window size of three. >>> s = pd.Series(range(5)) >>> s.rolling(3).first() 0 NaN 1 NaN 2 0.0 3 1.0 4 2.0 dtype: float64 r)r`rrgs rhrz Rolling.first sBww}},}777rjcHt|S)a] Calculate the rolling Last (right-most) element of the window. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- GroupBy.last : Similar method for GroupBy objects. Rolling.first : Method to get the first element in each window. Examples -------- The example below will show a rolling calculation with a window size of three. >>> s = pd.Series(range(5)) >>> s.rolling(3).last() 0 NaN 1 NaN 2 2.0 3 3.0 4 4.0 dtype: float64 r)r`rrgs rhrz Rolling.last sBww|||666rjrrrrr;cLt|||S)aV Calculate the rolling quantile. Parameters ---------- q : 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. numeric_only : bool, default False Include only float, int, boolean columns. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.rolling : Calling rolling with Series data. DataFrame.rolling : Calling rolling with DataFrames. Series.quantile : Aggregating quantile for Series. DataFrame.quantile : Aggregating quantile for DataFrame. Examples -------- >>> s = pd.Series([1, 2, 3, 4]) >>> s.rolling(2).quantile(0.4, interpolation="lower") 0 NaN 1 1.0 2 2.0 3 3.0 dtype: float64 >>> s.rolling(2).quantile(0.4, interpolation="midpoint") 0 NaN 1 1.5 2 2.5 3 3.5 dtype: float64 )rrr)r`r!)rgrrrras rhr!zRolling.quantile s0rww'%    rjr#TrZr?r$r%cNt||||S)a Calculate the rolling rank. Parameters ---------- 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. numeric_only : bool, default False Include only float, int, boolean columns. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.rolling : Calling rolling with Series data. DataFrame.rolling : Calling rolling with DataFrames. Series.rank : Aggregating rank for Series. DataFrame.rank : Aggregating rank for DataFrame. Examples -------- >>> 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 )rZr$r%r)r`r()rgrZr$r%rras rhr(z Rolling.rankD s1Nww||%    rjcHt|S)a Calculate the rolling nunique. .. versionadded:: 3.0.0 Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.rolling : Calling rolling with Series data. DataFrame.rolling : Calling rolling with DataFrames. Series.nunique : Aggregating nunique for Series. DataFrame.nunique : Aggregating nunique for DataFrame. Examples -------- >>> s = pd.Series([1, 4, 2, np.nan, 3, 3, 4, 5]) >>> s.rolling(3).nunique() 0 NaN 1 NaN 2 3.0 3 NaN 4 NaN 5 NaN 6 2.0 7 3.0 dtype: float64 r)r`r+rgs rhr+zRolling.nunique s(Pww%   rjrrrrScNt||||S)aL Calculate the rolling sample covariance. Parameters ---------- 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. numeric_only : bool, default False Include only float, int, boolean columns. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.rolling : Calling rolling with Series data. DataFrame.rolling : Calling rolling with DataFrames. Series.cov : Aggregating cov for Series. DataFrame.cov : Aggregating cov for DataFrame. Examples -------- >>> 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 rrrr)r`r.rgrrrrras rhr.z Rolling.cov s1lww{{%    rjcNt||||S)a Calculate the rolling correlation. Parameters ---------- 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. numeric_only : bool, default False Include only float, int, boolean columns. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- cov : Similar method to calculate covariance. numpy.corrcoef : NumPy Pearson's correlation calculation. Series.rolling : Calling rolling with Series data. DataFrame.rolling : Calling rolling with DataFrames. Series.corr : Aggregating corr for Series. DataFrame.corr : Aggregating corr for DataFrame. Notes ----- 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. Examples -------- 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.0, 35.0], [49.0, 30.0], [47.0, 32.0], [46.0, 31.0], [50.0, 36.0]] ... ) >>> 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 r)r`r:rs rhr:z Rolling.corr s1vww||%    rjrK)rar[rrLrrArBrCrDrErFrGrHrIrrrJrKrLrMrNrO)!rxrPrQrJrSrfrTr^rJrFrrGr rr rrrrrrrrr rrrr!r(r+r.r:rrs@rhrQrQs   K    /G/G/G/G/G/GbDDDD(((( N8N8N8N8N8N8` C++++++++++++++`4804'+(,P P P P P P P dXX T3T3T3T3T3 UT3p#4804 _ _ _ _ _ _ _ F#E 5904 E E E E E E E E R#4804 @ @ @ @ @ @ @ H#4804 G G G G G G G V#4804 @ @ @ @ @ @ @ H"4804 H H H H H H H X"4804 H H H H H H H T'7'7'7'7'7'7'7R+++++Z.7.7.7.7.7.7.7`!8!8!8!8!8!8!8F!7!7!7!7!7!7!7L08" = = = = = = = B%." L L L L L L L `#* * * * * * * \,0 $" ; ; ; ; ; ; ; ~,0 $" @ @ @ @ @ @ @ @ @ @ @ rjrQc@eZdZdZejejzZddZd dZdS) RollingGroupbyz3 Provide a rolling groupby implementation. r\r%cd}|j}t|jtrgt |j}|jj}t|tsJ|dd|j}n$|j t}|j }nt}|j}t|||j j||}|S)z Return an indexer class that will compute the window start and end bounds Returns ------- GroupbyIndexer Nr)rrgroupby_indicesr,indexer_kwargs)rrbr_r#rr__dict__rdictrr`r&r$r%rXrk)rgrrrolling_indexerr_r,s rhrz"RollingGroupby._get_window_indexer s15' dk; / / !"4;//O![16688Nnd33 3 33   }d 3 3 3[FF   *3O&FF0O[F'# M1*)    rjr]c&|jjr|d|jjD]P}|j|}|js-|js&|j dn|j }td|d|dQdS)zC Validate that each group in self._on is monotonic r\NrazEach group within z' must be monotonic. Sort the values in z first.) rLr]r^rXrkrrr_r`rVrd)rgrygroup_onrVs rhrTz/RollingGroupby._validate_datetimelike_monotonic s 8  D  ' '(B C C C!]299;;  Mx}}]33H0 4<4T !%WWTW 666*,666  rjN)r\r%rK) rxrPrQrRrQrJrWrrTrrjrhrr sZ%(9(EEK!!!!Frjr)trR __future__rrdatetimer functoolsrrstypingrrrr r r r r numpyrpandas._libs.tslibsrrr pandas._libs.window.aggregations_libsr_ aggregationsrpandas.compat._optionalr pandas.errorsrpandas.util._decoratorsrpandas.core.dtypes.commonrrrrrpandas.core.dtypes.dtypesrpandas.core.dtypes.genericrrpandas.core.dtypes.missingrpandas.core._numbarpandas.core.algorithmsrpandas.core.applyrr pandas.core.arraysr!pandas.core.baser"pandas.core.commoncorecommonrpandas.core.indexers.objectsr#r$r%r&pandas.core.indexes.apir'r(r)r*r+pandas.core.reshape.concatr,pandas.core.util.numba_r-r.r/pandas.core.window.commonr0r1pandas.core.window.numba_r2r3r4collections.abcr5r6r7r8pandas._typingr9r:r;r<r=r>r?r@rrArBpandas.core.genericrCr]rEpandas.core.arrays.datetimelikerFrHrWrrrQrrrjrhrs: #"""""                      ?>>>>>>>>>>>>>>>>>######......100000-,,,,,'''''',,,,,,.-----++++++  .-----  4((((((                    ,+++++333333999999]]]]]]]]@F:F:F:F:F: F:F:F:R    P  P  P  P  P  ZP  P  ! P  fv v v v v zv v v r     P P P P P &P P ! P f..    :::::&::! :::rj