uj>dZddlmZddlZddlmZddlmZddlZddl 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(m)Z)dd l*m+Z+dd l,m-Z-m.Z.ddl/m0Z0ddl1m2Z2ddl3m4Z4ddl5m6Z6m7Z7ddl8m9Z9ddl:m;Z;ddlZ?ddl@mAZAmBZBmCZCmDZDddlEmFZFmGZGmHZHmIZImJZJddlKmLZLddlMmNZNmOZOmPZPddlQmRZRmSZSddlTmUZUmVZVmWZWe r8ddlXmYZYddlXmZZZm[Z[m\Z\ddl]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZeddlfmgZgmhZhddlimjZjddlkmlZldd lmmnZnGd!d"e;d#ZoGd$d%eoZpe"d&Gd'd(eoZqGd)d*eoZre"d&Gd+d,erZseqjes_e"d&Gd-d.epesZty)/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_arrow_temporal_dtypeis_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_unitceZdZUdZgZded<eZded<ded< d"dd  d#d Zd$d Z d%d Z d&d'd Z d(dZ d)dZ d*d+dZd&dZd,dZdZd-dZd.dZd/dZd0dZed1dZd2dZd3dZ d& d4dZ d* d5dZ d6 d7dZ d8dZ d9 d:dZ d& d;d Zd&d!Z e Z!y)< BaseWindowz7Provides utilities for performing windowing operations. list[str] _attributeszfrozenset[Hashable] exclusionsr)_onN) selectionc `||_||_||_||_||_||_||_||_| |_d|_ |j|jj|_ nt|jtr|j|_ n}t|jtrJ|j|jjvr(t|j|j|_ nt!d|jd| |_|j%y)Nzinvalid on specified as z3, must be a column (of DataFrame), an Index or None)objonclosedstepwindow min_periodscenterwin_typemethod _win_freq_i8indexrM isinstancer)rcolumns ValueError _selection _validate) selfrPrTrUrVrWrQrRrSrXrNs e/var/www/html/python-recuperauto-other/env/lib/python3.12/site-packages/pandas/core/window/rolling.py__init__zBaseWindow.__init__|s   &    (, 77?xx~~DH  'wwDH , /DGGtxx?O?O4OTXXdgg./DH*477)4DD  $ c|j t|js td|jt |js td|jdkr tdt |j r>|j|j kDr%td|jd|j |j |j dvr tdt|jttfstd t|t|j trtj|j j j"j%}tjtj j"j%}||k7r+tt|j j&d |j(d vr td |j*;t |j*s td |j*dkr tdyy)Nzcenter must be a booleanzmin_periods must be an integerrzmin_periods must be >= 0z min_periods z must be <= window )rightbothleftneitherz3closed must be 'right', 'left', 'both' or 'neither'zinvalid type: z? does not implement the correct signature for get_window_bounds)tablesinglez!method must be 'table' or 'singlezstep must be an integerzstep must be >= 0)rVrr]rUrrTrRr[rPrr TypeErrortyper$inspect signatureget_window_bounds parameterskeys__name__rXrS)r`get_window_bounds_signatureexpected_signatures rar_zBaseWindow._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 !rcc 0t|t|k7r$tdt|dt|dt|||jxsdzdz |jxsdzk7r(tdt|d|d|jdy) Nzstart (z ) and end (z ) bounds must be the same lengthzstart and end bounds (z)) must be the same length as the object (z) divided by the step (z) if given and rounded up)lenr]rS)r`startendnum_valss ra_check_window_boundszBaseWindow._check_window_boundss u:S !#e*[S ;  u:(diin159tyy~AN N(U 5""*+B499+N*+  Orcc\|t|t|k(r|S|dd|jS)zJ Slices the index for a given result and the preset step. N)rwrS)r`rZresults ra_slice_axis_for_stepzBaseWindow._slice_axis_for_steps9 ~VE !:  |$))|$ rcc|jjdk(rG|rDt|jjs$t t |j d|dyyy)z Validate numeric_only argument, raising if invalid for the input. Parameters ---------- name : str Name of the operator (kernel). numeric_only : bool Value passed by user. rv.z does not implement numeric_onlyN) _selected_objndimrdtypeNotImplementedErrorrlrr)r`name numeric_onlys ra_validate_numeric_onlyz!BaseWindow._validate_numeric_onlysg    # #q ($T%7%7%=%=>%:&&'q.NO ? )rcc0|jdgdg}|S)zSubset DataFrame to numeric columns. Parameters ---------- obj : DataFrame Returns ------- obj subset to numeric-only columns. numberr)includeexclude) select_dtypes)r`rPr}s ra_make_numeric_onlyzBaseWindow._make_numeric_onlys"""H: }"M rcc$|jat|jtsG|jdk(r8|j |j j |jgd}|jdkDr|r|j|}|S)A Split data into blocks & return conformed data. F)sort)r\rv)rQr[r)rreindexr\ differencer)r`rPrs ra _create_datazBaseWindow._create_data sr 77 z$''5'AchhRSm++ckk&<&XXF9=8H8HI$d++II))#v6 $t*VCyCFC JsAc||jvrtj||S||jvr||St dt |j d|d)N'z' object has no attribute ')_internal_names_setobject__getattribute__rPAttributeErrorrlrr)r`rs ra __getattr__zBaseWindow.__getattr__,sd 4++ +**46 6 488 : T ##$$?vQ G  rcc6|jjSN)rP_dir_additionsr`s rarzBaseWindow._dir_additions6sxx&&((rccfdjD}dj|}tjd|dS)z@ Provide a nice str repr of our rolling object. c3jK|]*}t|d|ddk7r|dt|,yw)Nr_=)r).0 attr_namer`s ra z&BaseWindow.__repr__..=sF tY-9ilc>Qk7434 5 s03,z [])rKjoinrlrr)r` attrs_listattrss` ra__repr__zBaseWindow.__repr__9sF !-- $t*%%&bq11rcc#K|jj|j}|j|}|j }|j t ||j|j|j|j\}}|j||t |t||dD]"\}}|jt||}|$yw)N num_valuesrUrVrRrST)strict)rset_axisrMr_get_window_indexerrorwrUrVrRrSr{zipilocslice)r`rPindexerrxryser}s ra__iter__zBaseWindow.__iter__Es  ))$((3$**,..3x((;;;; / s !!%c#h7s40 DAqXXeAqk*FL sC!C#cDt|jst|jr/tdt |j d|jd t |tr0|jtjtj}n t|}tj|}|j!r%tj"|tj|}|S#ttf$r}td|j|d}~wwxYw)z1Convert input to numpy arrays for Cython routineszops for z for this dtype z is not implemented)na_valuezcannot handle this type -> N)rrrrrlrrr[r"to_numpynpfloat64nanrr]rkisinfanywhere)r`valueserrinfs ra _prep_valueszBaseWindow._prep_valuesWs v|| ,0G 0U &4:../0&9;   S&.1bffE'/ hhv 779XXc26662F I& S9&,,HIs R SsA C22DDDcXddlm}|j|jj |j s|jj }||j|jj |d}||jvr|||<y||j jvry||jjvrf|jj}|j}|j|}|j|d|} t| } |j| ||y|||<yyy)NrrCFrZrcopy)pandasrCrQrMequalsrZrrPr\namesrget_loc intersectionrwinsert) r`r}rPrCr extra_colold_colsnew_colsold_locoverlapnew_locs ra_insert_on_columnzBaseWindow._insert_on_columnss " 77 txxsyy'A88==Dtxxtxx~~DuUIv~~%(t +++++333--55!>>"**40"//'0BCg, gtY7 )t %(B rccZt|jtttfr|jj St|jj trL|jj jdvr*|jjtjSy)NmMr) r[rMr+r(r,asi8rrkindrrint64rs ra _index_arrayzBaseWindow._index_arraysm dhhm^ L M88==  38K8Kt8S88$$288$4 4rcc|jddk(r|jddkDr td|jddk(r|jdS|j|||S)zValidate and finalize result.rvrNo numeric types to aggregater)shaperastyper)r`outrPs ra_resolve_outputzBaseWindow._resolve_outputsa 99Q<1 1!1;< < 99Q<1 ::i( ( sC( rcct|jtr |jS|j,t |j |j|j St|jS)z[ Return an indexer class that will compute the window start and end bounds ) index_array window_sizerV)r)r[rTr$rYr'rrVr%rs rarzBaseWindow._get_window_indexers_ dkk; /;;     (( -- --{{  "dkk::rcc|j|j}|dk(rt|jt} |j |j }||}|j|j|}|j|||jS#ttf$r}td|d}~wwxYw)z5 Series version of _apply_columnwise countrNrZr)rrrrintr_valuesrkrrr~rZ _constructorr)r`homogeneous_funcrrPrrr}rZs ra _apply_serieszBaseWindow._apply_seriess  2 23 7?*##C(C F&&s{{3F"&)))#))V<e#((CC ./ F;<# E FsBB=, B88B=cJ|j|||jjdk(r|j||S|j |j|}|dk(r=t |j t}|jj|_g}g}t|jD]A\}} |j|}||} |j#| |j#|C|j%|j&t)|dkDr|dnd} t+|j-|| |j.j1|d} |j3| |S#ttf$r} td|j | d} ~ wwxYw)zl Apply the given function to the DataFrame broken down into homogeneous sub-frames. rvrz#Cannot aggregate non-numeric type: NrF)rZr\verify_integrity)rrrrrrrr_mgr consolidate enumerate_iter_column_arraysrrkrrrappendr~rZrwrl _from_arraysr\taker) r`rrrrPtaker res_valuesiarrrresrZdfs ra_apply_columnwisezBaseWindow._apply_columnwises ##D,7    " "a '%%&6= = 2 2LA 7?*##C(Cxx++-CH  7 7 9: FAs '', #3'C   c " LLO )) IIJ!(;z!} #Y # # KK$$U+" $ ##B,,%23 9#))E sE55F"FF"c|jjdk(r td|j|j|}|j |j }||}|j |j|}|jdt|jk(r |jn|jdd|j}|j|||} |j| |S)zT Apply the given function to the DataFrame across the entire object rvz1method='table' not applicable for Series objects.NrZr\)rrr]rrrr~rZrrwr\rSrr) r`rrrrPrr}rZr\rs ra_apply_tablewisezBaseWindow._apply_tablewises    " "a 'PQ Q 2 2LA""3<<>2!&)))#))V<||A#ckk"22 KK\ \*  vUGD##C--rcc|j||}| |}|dn|}nCt|ttfs t d|j dk(r|r|j |}t|||t|S)] Apply the given pairwise function given 2 pandas objects (DataFrame/Series) Tz#other must be a DataFrame or Seriesr)pairwise) rr[rrr]rrr1bool)r`targetotherrfuncrs ra_apply_pairwisezBaseWindow._apply_pairwisesy""6<8 =E'/tXHEL)#<=BC C ZZ1_++E2E!&%XOOrcc jj jn jdfd }jdk(rj |||Sj |||S)a Rolling statistical measure using supplied function. Designed to be used with passed-in Cython array-based functions. Parameters ---------- func : callable function to apply name : str, numba_args : tuple args to be passed when func is a numba func **kwargs additional arguments for rolling function and window function Returns ------- y : type of input c|jdk(r|jSfd}tjd5||}ddd|S#1swYSxYw)Nrcjt|jjj\}}j ||t||||gS)Nr)rorwrVrRrSr{)xrxryrrU numba_argsr`window_indexers racalcz9BaseWindow._apply..homogeneous_func..calcFsi+=="1v +;;;; > s))%c!f=Auc;DDDrcignoreall)sizerrerrstate)rrr}rrUrr`rs rarz+BaseWindow._apply..homogeneous_func@s^{{a{{}$ E E* &f &M &Ms AArjr np.ndarray)rrUrrXrr ) r`rrrrrrrUrs `` ` @@ra_applyzBaseWindow._applys~4113+   ++    . ;;( "))*:D,O O(()94N Nrcc |j}|j |jn |j}|j|j}|j |j }|jdk(r|jdd}|jt|||j|j|j\}} |j|| t|tj } tj"|| fddit%|} | |j&f|| |d|j&} |j)|j*| } |jdk(r0| j-} |j/| | |j0}|S|j)|j2| j&}|j/| | |}|j5||S) Nrvris_grouped_kernelF)rxryrUrr )rrUrrrrrrreshaperorwrVrRrSr{rfloat_dtype_mappinggenerate_shared_aggregatorr.r?r~rZsqueezerrr\r)r`r engine_kwargs func_kwargsrrUrPrrxry dtype_mapping aggregatorr}rZrr\s ra _numba_applyzBaseWindow._numba_apply\s 113+   ++   2 23""3<<>2 ;;! ^^B*F#556{#;;;; 6 s !!%c&k: !44 88   $  .   HH !s  GR ! ))#))V< 88q=^^%F""6SXX"FCJ// VXXFG""6"HC''S1 1rcct|fi|\}}}}t||||j}t|tr|r|j dd|f}||_||j|d||S|S)NargsrF)rawr1r)r!r aggr[rrr\apply)r`rr1r relabelingr\orderr}s ra aggregatezBaseWindow.aggregatesy+;D+KF+K( D'5%dDtFKOOQ fl + [[E*F$FN >::dD:H H rc)NNFNNNNrj)rPrDrU int | NonerV bool | NonerW str | NonerQzstr | Index | NonerRr:rSr8rXstrreturnNoner<r=)rxr!ryr!rzrr<r=r)rZr)r}z Sized | Noner<r))rr;rrr<r=)rPr;r<r;FrPr;rrr<r;)rr;)r<r;)r<z Iterator[Any])rr:r<r!)r}rBrPrBr<r=)r<znpt.NDArray[np.int64] | None)rrBrPrBr<rB)r<r$)rCallable[..., ArrayLike]rr:r<rC)rrArr;rrr<DataFrame | Series)NF)rrArr:rrr<rB rrBrDataFrame | Series | Nonerr9rzFCallable[[DataFrame | Series, DataFrame | Series], DataFrame | Series]rrr<rBF)rCallable[..., Any]rr;rrrtuple[Any, ...])rrGr*dict[str, bool] | None)"rr __module__ __qualname____doc__rK__annotations__ frozensetrLrbr_r{r~rrrrrrrrrrpropertyrrrrrr rr"r.r7r3rFrcrarIrIusXAK&/kJ#1 J "&##!%!%% % %  %  % %%%% %N)6V  &0 ? ?  "hht}}228hD ::f  )%&HI I .t.v.rcc t|||||fi|}|jj}g|j}t j |j j} | |z} |j jD cgc](} | |jjjvs| | *} } t| t| k7r|j| d}|j j} t j |j j}|j jj}|rtjt|}n%tj gtj"}| Dcgc]}|j%|} }||j%|}t'|t(st)j*|g}| j-t|j|j-t|jt)|| | d}||_|j.s-|j1tt3t| }|Scc} wcc}w)NrrUrFrr)level)rZr"rPrZrrrRrwrXcodeslevelsindicesrr concatenatelistarrayintprr[r* from_arraysextendrS reset_indexrange)r`rrrrrr}grouped_object_indexgrouped_index_name groupby_keysresult_index_namesr drop_columnsr_r` group_indicesrcidx result_indexr[s rar"zBaseWindowGroupBy._applys         $xx~~:399:yy!4!45 ),>>}}** $((.....#+   | L 1 1[[h[GF ##4==//0 --446 nnT-%89Ghhr1G*/0Q00 +&++G4Cc:. ,,cU3 LLcii ) MM$szz* +! E!3e $ ~~''d5\9J3K.L'MF I $1s ?-I1I6c|j|jjd}t|||||}Lt fd|jj jDst|}t|jj jDcgc],}|j|j|j.c}}d|jj jD} g} g} ttt!| ddiD][} t#j$t#j&| |} t)| \}}| j+|| j+|]n|jj,} |jj.} |jj j}|rt#j0t|}n%t#j&gt"j2}|j4dk(rd}nt|j6}| Dcgc]'}t#j$|j||)} }t9|jt:r^t|jj,}t|jj.}t|jj}n5t)|j\}}|g}|g}|jj<g}| |z}| |z}|jj|z}t;|||d }||_ |Scc}wcc}w) r rrUc3LK|]}t|tk(ywr)rw)rgrouprs rarz4BaseWindowGroupBy._apply_pairwise..s#) ).CJ#e* $) s!$c3FK|]}tj|ywr)commaybe_make_list)rpairs rarz4BaseWindowGroupBy._apply_pairwise..s .2##D)s!rTrrvFr])rXrRrrZrrrarrwr-rrrZrqmaprcrrrepeatrdrrr_r`rbrerr\r[r*r)r`rrrrrr}old_result_len gb_indicesgb_pairs groupby_codesgroupby_levels gb_level_pairlabelsr_r`ror repeat_byrp result_codes result_levels result_names idx_codes idx_levelsrrr[s ` rarz!BaseWindowGroupBy._apply_pairwisesT]]%8%8J($ U  S) 26--2G2G2N2N2P) & ![N'+mm&;&;&B&B&D"KK +33FLLAF6:mm6K6K6P6P6RHMN!$T3+F+F!G . 288M#:NK )& 1 v$$U+%%f-  .!MM//M"]]11N MM1188:M..m)<=((2RWW5{{a / ?L:; !&&/95M fllJ / 2 23L !4!45M 2 23L$-fll$; !Iz%;L'LM"LL--.L%|3 &6 }}**\9 ! <|e $  uFs -1M# ,M(c|jsntjt|jj j jtj}|j|}t|-||S)r) emptyrrbrcrRrarrrrrZr)r`rPr groupby_orderr[s rarzBaseWindowGroupBy._create_dataJsfyyNN4 0E0E0L0L0N+OPWWM((=)Cw#C66rcc|j%|jj|j}t||||S)N)r)rQrP set_indexrMrZr)r`rrrr[s rarzBaseWindowGroupBy._gotitemXs> 77 XX''1FwT&99rc)rPrBrRrFrSrr<r=rE) rrGrr;rrrrHr<rBrCr?r@r) rrrJrKrLrMrKrbr"rrr __classcell__r[s@rarQrQsO(\K) / / /  / /6#&( ; ;; ; $ ; ;zR"R)R R U R  R Rh 7::rcrQzpandas.api.typingceZdZdZgdZd fd Zd dZ d ddZddZeZ dddZ dddZ ddd Z ddd Z xZS)WindowaE 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. For integer ``window`` values, the window bounds are based on the number of observations and are not calculated using the values of the ``on`` column. The ``on`` column is excluded from the aggregation, but is included in the result when its values differ from the object's index. 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 rTrUrVrWrQrRrSrXct|t|jtst d|jt dd}t||jd|_|jt d|jt|jtr tdt|jr|jdkr t d|jdk7r td y) NzInvalid win_type zscipy.signal.windowsz,Scipy is required to generate window weight.)extraz6BaseIndexer subclasses not implemented with win_types.r&window must be an integer 0 or greaterrjz+'single' is the only supported method type.)rZr_r[rWr;r]rr_scipy_weight_generatorrTr$rrrX)r`signalr[s rar_zWindow._validatems $---0@A A+ "*X (/vt}}d'K$  ' ' /0@A A dkk; /%H $++&$++/EF F ;;( "%&ST T #rccl|dkDr.t|dg}tj|t|}|S)zT Center the result in the window for weighted rolling aggregations. rN)rrrtuple)r`r}offset lead_indexers ra_center_windowzWindow._center_windows7 A:!&$/0LWWVE,$789F rcc jjfi|jrtdz dznddfd }j |||ddj S)a+ Rolling with weights statistical measure using supplied function. Designed to be used with passed-in Cython array-based functions. Parameters ---------- func : callable function to apply name : str, numeric_only : bool, default False Whether to only operate on bool, int, and float columns numba_args : tuple unused **kwargs additional arguments for scipy windows if necessary Returns ------- y : type of input rvrrc|jdk(r|jSfd}tjd5tj||}dddj rj }S#1swY)xYw)Nrctjtj}tj||f}|jjSt Sr)rfullrrbrUrw)radditional_nansrrr`rTs rarz5Window._apply..homogeneous_func..calcsf"$''&"&&"9NNA#78(,(8(8(DD$$KNf+rcrr)rrrrasarrayrVr)rrr}rrr`rTs rarz'Window._apply..homogeneous_funcsw{{a{{}$ * 2DL1 2{{,,VV<M 2 2s BB Nr )rrTrVrwrrS) r`rrrrrrrrTs `` @@rar"z Window._applysv:.-- KK ! ,0;;#f+/a'A  0%%&6lK tyyL  rccTt||||j}|||}|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 r0)r r3)r`rr1rr}s rar7zWindow.aggregates1P&dDtFKOOQ >$ZF rcc Ntj}|j|fd|d|S)a Calculate the rolling weighted window sum. The window type is determined by the ``win_type`` parameter specified in :meth:`DataFrame.rolling` or :meth:`Series.rolling`. Additional keyword arguments are passed to the SciPy window function. 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_sumr"r`rr window_funcs rarz Window.sums=f*;; t{{  %    rcc Ntj}|j|fd|d|S)ai Calculate the rolling weighted window mean. The window type is determined by the ``win_type`` parameter specified in :meth:`DataFrame.rolling` or :meth:`Series.rolling`. Additional keyword arguments are passed to the SciPy window function. 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_meanr"rs rarz Window.meanYs=d*<< t{{  %    rcc ttj|}|jdd|j|fd|d|S)a Calculate the rolling weighted window variance. The window type is determined by the ``win_type`` parameter specified in :meth:`DataFrame.rolling` or :meth:`Series.rolling`. Additional keyword arguments are passed to the SciPy window function. 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 ddofrNvarr)rrroll_weighted_varpopr")r`rrrrs rarz Window.varsDj1CC$O  64 t{{;XUXQWXXrcc @t|jd|d|d|S)a= Calculate the rolling weighted window standard deviation. The window type is determined by the ``win_type`` parameter specified in :meth:`DataFrame.rolling` or :meth:`Series.rolling`. Additional keyword arguments are passed to the SciPy window function. 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)rrrrF)r2r)r`rrrs rarz Window.stds,j DHH P$U P P  rcr>)r}r!rrr<r!rE)rz,Callable[[np.ndarray, int, int], np.ndarray]rr;rrrrHrr?rrrvFrrrr)rrrJrKrLrKr_rr"r7r3rrrrrrs@rarrbs{|| KU,#&( < :< <  < $ < |M^ C< |; z7Yr7 7 rcrc2eZdZdddZ d ddZ ddZe ddZe ddZ d dZ d! d"dZ d! d"d Z d! d"d Z d! d"d Z d! d"d Z d# d$d Z d# d$dZdddZd%d&dZdddZdddZdddZ d' d(dZ d) d*dZ d ddZ d+ d,dZ d+ d,dZy)-RollingAndExpandingMixincJtj}|j|d|S)Nrr)rroll_sumr"r`rrs rarzRollingAndExpandingMixin.count s")22 {{;W<{PPrcNc|d}|i}t|s tdd}t|r\|dur tdt|||d\}}|jdk(rt |fit |}nGt|fit |}n1|dvr"| td |j||||}n td |j|d | S) NrFz'raw parameter must be `True` or `False`Fz.raw must be `True` when using the numba enginerv)num_required_argsrj)cythonNz+cython engine does not accept engine_kwargsz)engine must be either 'numba' or 'cython'r4)rr) rr]r/r0rXr4r.r5_generate_cython_apply_funcr") r`rr2enginer*r1rr apply_funcs rar4zRollingAndExpandingMixin.applys <D >Fs|FG G&( 6 "e| !QRR!;dFa" J{{h&6-m< 7-m< ' '( !NOO99$TRJHI I{{ !  rccxddlmttj||t |||ffd }|S)Nrr)r1rr2functioncH|s|jd}||||S)NF)rZr)rM)rbeginryrUr2rCr`rs rarzHRollingAndExpandingMixin._generate_cython_apply_func..apply_funcLs)dhhUCvuc;? ?rc)rrCrr roll_applyr)r`r1rr2rrrCrs` @@rarz4RollingAndExpandingMixin._generate_cython_apply_func;s? "  * *S   =@ @ rccyrrFr`rr1rs rapipezRollingAndExpandingMixin.pipeT rccyrrFrs rarzRollingAndExpandingMixin.pipe\rrcc6tj||g|i|Sr)rwrrs rarzRollingAndExpandingMixin.pipeds xxd4T4V44rcc t|rU|jdk(r.ttj}|j |d||Sddlm}|j||Stj}|j|d|S)NriTr2rr*r) sliding_sumrr) r/rXr3rnansumr4pandas.core._numba.kernelsrr.rrr")r`rrr*rrrs rarzRollingAndExpandingMixin.sumls 6 "{{g%>ryyIzz!"/ "C((mDD)22 {{;U{NNrcct|rW|jdk(r.ttj}|j |d||Sddlm}|j||dStj}|j|d|S) NriTrrsliding_min_maxis_maxmaxr) r/rXr3rnanmaxr4rrr.rroll_maxr"r`rrr*rrrs rarzRollingAndExpandingMixin.maxs 6 "{{g%>ryyIzz!"/ "G((-PT(UU)22 {{;U{NNrcct|rW|jdk(r.ttj}|j |d||Sddlm}|j||dStj}|j|d| S) NriTrrrFrminr) r/rXr3rnanminr4rrr.rroll_minr"rs rarzRollingAndExpandingMixin.mins 6 "{{g%>ryyIzz!"/ "G((-PU(VV)22 {{;U{NNrcc t|rU|jdk(r.ttj}|j |d||Sddlm}|j||Stj}|j|d|S)NriTrr) sliding_meanrr) r/rXr3rnanmeanr4rrr.r roll_meanr")r`rrr*rrrs rarzRollingAndExpandingMixin.means 6 "{{g%>rzzJzz!"/ "D((}EE)33 {{;V,{OOrcct|rN|jdk(rttj}ntj}|j |d||St j}|j|d|S)NriTrmedianr) r/rXr3r nanmedianr4r roll_median_cr")r`rrr*rrs rarzRollingAndExpandingMixin.medianss 6 "{{g%>r||L||::+   *77 {{;XL{QQrcct|r=|jdk(r tdddlm}t |j ||Stjfd}|j|d|S) Nriz%std not supported with method='table'r sliding_varrc 0t||||S)Nr)r2)rrryrUrrs ra zsqrt_funcz0RollingAndExpandingMixin.std..zsqrt_funcsVUC4PQ Qrcrr) r/rXrrrr2r.rroll_varr")r`rrrr*rrrs ` @rarzRollingAndExpandingMixin.stdsw 6 "{{g%)*QRR >**; D*QR R)22  R{{ %  rcct|r4|jdk(r tdddlm}|j |||St tj|}|j|d|S)Nriz%var not supported with method='table'rrrrr) r/rXrrrr.rrrr")r`rrrr*rrs rarzRollingAndExpandingMixin.varsq 6 "{{g%)*QRR >$$[-d$K K1::F {{ %  rccJtj}|j|d|S)Nskewr)r roll_skewr"rs rarzRollingAndExpandingMixin.skew,)33 {{ %  rcc|jd||j|||j|jdz S)Nsemrrr?rrrpowr`rrs rarzRollingAndExpandingMixin.sem sC ##E<8xx\x= JJLJ 1 #c( rccJtj}|j|d|S)Nkurtr)r roll_kurtr"rs rarzRollingAndExpandingMixin.kurtrrccJtj}|j|d|S)Nfirstr)r roll_firstr"rs rarzRollingAndExpandingMixin.firsts,)44 {{ %  rccJtj}|j|d|S)Nlastr)r roll_lastr"rs rarzRollingAndExpandingMixin.last$rrcc|dk(rtj}n2|dk(rtj}nttj||}|j |d|S)Ng?g)quantile interpolationrr)rrrr roll_quantiler")r`qrrrs rarz!RollingAndExpandingMixin.quantile,sX 8-66K #X-66K!#11+K {{;Zl{SSrccdttj|||}|j|d|S)N)rX ascending percentilerankr)rr roll_rankr")r`rXr pctrrs rar zRollingAndExpandingMixin.rank?s7  ) )  {{;V,{OOrcc\ttj}|j|d|S)Nnuniquer)rr roll_nuniquer"rs rarz RollingAndExpandingMixin.nuniqueOs.  , , {{;Y\{RRrccj tdjd|ddlmfd}j j ||||S)Nzstep not implemented for covcovrrc j|} j|} j} j jn |j}|j t || j j j\}} j||t |tj||||| } ||j|jdSNrFr)rrrUrrorwrVrRrSr{rroll_covrZr) ryx_arrayy_arrayrrUrxryr}rCrr`s racov_funcz.RollingAndExpandingMixin.cov..cov_funcfs''*G''*G!557N##/  #//  (99w<'{{{{YY :JE3  % %eS#g, ?(11%k4F&aff5I IrcrSrrrrCrr)r`rrrrrrCs` ` @rarzRollingAndExpandingMixin.covYsZ 99 %&DE E ##E<8! J.##   x<  rccj tdjd|ddlmfd}j j ||||S)Nzstep not implemented for corrcorrrrc j|} j|} j} j jn |j}|j t || j j j\}} j||t |tj|||||} ||j|jdSr)rrrUrrorwrVrRrSr{r roll_corrrZr) rrrrrrUrxryr}rCr`s ra corr_funcz0RollingAndExpandingMixin.corr..corr_funcs''*G''*G!557N##/  #//  (99w<'{{{{YY :JE3  % %eS#g, ?(22%kF&aff5I Ircr)r`rrrrr!rCs` @rarzRollingAndExpandingMixin.corrsZ 99 %&EF F ##FL9! J.##   xL  rcr?rFNNNN rrGr2rr!Literal['cython', 'numba'] | Noner*rIr1ztuple[Any, ...] | Nonerzdict[str, Any] | None) r1rHrzdict[str, Any]r2zbool | np.bool_rrGr<z?Callable[[np.ndarray, np.ndarray, np.ndarray, int], np.ndarray]rz!Callable[Concatenate[Self, P], T]r1zP.argsrzP.kwargsr<r?rztuple[Callable[..., T], str]r1rrrr<r?rz@Callable[Concatenate[Self, P], T] | tuple[Callable[..., T], str]r1rrrr<r?FNNrrrr$r*rIrvFNNrrrrrr$r*rIrrlinearFr floatrr<rraverageTFFrXr@r rrrrrNNrvFrrDrr9rrrr)rrrJrKrr4rr rrrrrrrrrrrrrrr rrrrFrcrarr sQ4804'+(,+  + + 2 + . + % + &+ Z  %  I 2/  *  5N55 5 5#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$#SS,0 $" & (& &  &  & T,0 $" & (& &  &  & rcrceZdZUgdZded<d fd Zd dZd!dZd"fd ZeZ d#d$fd Z d% d&fd Z e d'd Z e d(d Z e d)fd Z d* d+fd Z d#ddd d+fdZ d* d+fd Z d* d+fd Z d* d+fd Z d, d-fd Z d, d-fd Zd#d$fd Zd.d/dZd#d$fd Zd#d$fd Zd#d$fd Z d0 d1fd Z d2 d3fd Z d# d$fd Z d4 d5fd Z d4 d5fd ZxZ S)6RollingrrJrKct||jjsmt |j t ttfsHt |j jtrg|j jjdvrDt |jtttfr|j! t#|j}t |j trT|j(|j j*j(|j j*j,z z |_n_ t1|j j}t3d|}t5|j(j7|j8|_|j:d|_|j< t?dyt |jt@rytC|jr|jdkr t'd y#t$t&f$r}t'd|jd|d}~wwxYw#t$$rd}YwxYw) Nrzpassed window z, is not compatible with a datetimelike indexnsr>rvz,step is not supported with frequency windowsrr)"rZr_rPrr[rMr(r,r+rrrrTr;rr _validate_datetimelike_monotonicrrkr]nanosfreqnrYrGr ras_unit_valuerUrSrr$r)r`r;runitr[s rar_zRolling._validates  HHNN$((]NK$PQ488>>:6488>>;N;NRV;VsJ &BC  1 1 3  - $((K0%)JJHHMM''$((--//9%! (8DJ-$-djj$9$A$A$$G$N$N!'#$ yy$)B%  [ 1 DKK(DKK!OEF F- 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 )rZr7r`rr1rr[s rar7zRolling.aggregates dw 7777rcc"t||S)a Calculate the rolling count of non NaN observations. This is useful for identifying windows with missing data, as it counts only non-NaN entries within each 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 -------- 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 )rZrr`rr[s rarz Rolling.countNs\w}\**rcc.t|||||||S)a Calculate the rolling custom aggregation function. Applies an arbitrary function to each rolling window. This is useful when the built-in rolling methods do not cover the desired computation. 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. Pandas-only attributes such as ``.iloc`` or ``.index`` are not available on ndarrays and will raise ``AttributeError`` if used inside ``func``. 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 ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'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. Notes ----- When ``raw=False``, the :class:`Series` passed to ``func`` is indexed by the column or :class:`Index` used to compute the rolling window. If :meth:`DataFrame.rolling` was called with ``on=col``, the index of the passed :class:`Series` will be the values of ``col`` rather than the original :class:`DataFrame` index. When ``on`` is not specified, the index of the passed :class:`Series` is the original index of the input. 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 By default ``func`` is applied to each column independently. Use ``method="table"`` (which requires ``engine="numba"`` and ``raw=True``) to instead pass the whole :class:`DataFrame` window to ``func`` as a single 2D ndarray, so the function can combine multiple columns. Here a rolling dot product of columns ``A`` and ``B`` is computed; the scalar result is broadcast across the columns. >>> df = pd.DataFrame({"A": [1, 2, 3, 4, 5], "B": [5, 4, 3, 2, 1]}) >>> def dot(window): ... return (window[:, 0] * window[:, 1]).sum() >>> df.rolling(3, method="table").apply( ... dot, engine="numba", raw=True ... ) # doctest: +SKIP A B 0 NaN NaN 1 NaN NaN 2 22.0 22.0 3 25.0 25.0 4 22.0 22.0 )r2rr*r1r)rZr4)r`rr2rr*r1rr[s rar4z Rolling.apply~s.Vw} '   rccyrrFrs rarz Rolling.piperrccyrrFrs rarz Rolling.piperrcc*t||g|i|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 )rZrrJs rarz Rolling.pipe sjw|D242622rcc(t||||S)a Calculate the rolling sum. This is equivalent to applying ``numpy.sum`` over each rolling window. Missing values (NaN) are excluded from the calculation. 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 ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'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 rrr*)rZrr`rrr*r[s rarz Rolling.sumY s%|w{%'  rc)rr*c(t||||S)a Calculate the rolling maximum. This is equivalent to applying ``numpy.max`` over each rolling window. 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 ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'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 rR)rZr)r`rrr*r1rr[s rarz Rolling.max s%Fw{%'  rcc(t||||S)a] Calculate the rolling minimum. This is equivalent to applying ``numpy.min`` over each rolling window. 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 ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'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 rR)rZrrSs rarz Rolling.min s%|w{%'  rcc(t||||S)a Calculate the rolling mean. This is equivalent to applying ``numpy.mean`` over each rolling window. 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 ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'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 rR)rZrrSs rarz Rolling.meanJ s%Jw|%'  rcc(t||||S)a Calculate the rolling median. This is equivalent to applying ``numpy.median`` over each rolling window. 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 ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'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 rR)rZrrSs rarzRolling.median s%~w~%'  rcc*t|||||S)a Calculate the rolling standard deviation. This is equivalent to applying ``numpy.std`` (with the specified ``ddof``) over each rolling window. 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 ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'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 rrrr*)rZrr`rrrr*r[s rarz Rolling.std (Lw{%'   rcc*t|||||S)a Calculate the rolling variance. This is equivalent to applying ``numpy.var`` (with the specified ``ddof``) over each rolling window. 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 ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'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 rY)rZrrZs rarz Rolling.var' r[rcc$t||S)a Calculate the rolling unbiased skewness. This is equivalent to applying ``scipy.stats.skew`` over each rolling window. A minimum of three periods is required. 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)rZrrLs rarz Rolling.skewt sTw||66rcc|jd||j|||j|jdz S)a Calculate the rolling standard error of mean. This is computed as the rolling standard deviation divided by the square root of the rolling count. A minimum of one period is required. 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 rrrrrs rarz Rolling.sem sDV ##E<8xx\x= JJ| $ #c( rcc$t||S)a) Calculate the rolling Fisher's definition of kurtosis without bias. This is equivalent to applying ``scipy.stats.kurtosis`` (with ``bias=False``) over each rolling window. A minimum of four periods is required. 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)rZrrLs rarz Rolling.kurt sdw||66rcc$t||S)a Calculate the rolling First (left-most) element of the window. Return the first observed value in each rolling window. This is useful for tracking the starting value of a window as it slides forward. 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)rZrrLs rarz Rolling.first sHw},}77rcc$t||S)a Calculate the rolling Last (right-most) element of the window. Return the last observed value in each rolling window. This is useful for tracking the most recent value of a window as it slides forward. 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)rZrrLs rarz Rolling.last* sHw||66rcc(t||||S)a Calculate the rolling quantile. Return the ``q``-th quantile of the values in each rolling window. The ``interpolation`` parameter controls how quantiles falling between two data points are handled. 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 )r rr)rZr)r`r rrr[s rarzRolling.quantileP s&zw'%   rcc*t|||||S)a  Calculate the rolling rank. Compute the rank of each value within each rolling window. Ties are resolved using the ``method`` parameter. 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 )rXr rr)rZr )r`rXr rrr[s rar z Rolling.rank s(Tw|%   rcc$t||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)rZrrLs rarzRolling.nunique sPw%  rcc*t|||||S)a Calculate the rolling sample covariance. Compute the sample covariance between the calling object and ``other`` over each rolling window. If ``other`` is not supplied, pairwise covariances of the columns are computed. 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)rZrr`rrrrr[s rarz Rolling.cov s(tw{%   rcc*t|||||S)a_ Calculate the rolling correlation. Compute the Pearson correlation coefficient between the calling object and ``other`` over each rolling window. If ``other`` is not supplied, pairwise correlations of the columns are computed. 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 rf)rZrrgs rarz Rolling.corrQ s(~w|%   rcr>)rHr;rr?rr"r#r%r&r'r(r)r*r+rrr,r.r0r2r3r4)!rrrJrKrKrMr_r9rCr7r3rr4r rr rrrrrrrrrrrrrr rrrrrs@rar6r6s K /GbD( R8h C.+f4804'+(,r  r r 2 r . r % r &r h/  *   T3NT3T3 T3 T3 T3p#4804 b b 2b . b L#G 5904 G G 2 G . G V#4804 B B 2B . B L#4804 I I 2I . I Z#4804 C C 2C . C N"4804 K K K 2 K . K ^"4804 K K K 2 K . K Z*7X.`27h$8L$7R08" A A -A  A J%." O !O O  O  O f#* * \,0 $" ? (? ?  ?  ? F,0 $" D (D D  D  D D rcr6cReZdZdZej ej zZddZddZy)RollingGroupByz3 Provide a rolling groupby implementation. cd}|j}t|jtrjt |j}|jj j }t|tsJ|jdd|j}n1|jt}|j}nt}|j}t|||jj||}|S)z Return an indexer class that will compute the window start and end bounds Returns ------- GroupByIndexer Nr)rrgroupby_indicesrindexer_kwargs)rr[rTr$rl__dict__rdictrrYr'r%r&rRra)r`rmrrolling_indexerrTrs rarz"RollingGroupBy._get_window_indexer s15'' dkk; /"4;;/O![[11668Nnd3 33   }d 3[[F    *3O&&F0O[[F'# MM11*)  rccd|jjr|jd|jjj D]b}|jj |}|jr+|jr8|jdn |j}td|d|dy)zC Validate that each group in self._on is monotonic rANrZzEach group within z' must be monotonic. Sort the values in z first.) rMrBrCrRrarrrDrErQr])r`rogroup_onrQs rar9z/RollingGroupBy._validate_datetimelike_monotonics 88    ' '(B C!]]2299; Mxx}}]3H00H4T4T $WTWW (-**,W6 rcN)r<r&r>) rrrJrKrLr6rKrQrr9rFrcrarjrj s+%%(9(E(EEK!Frcrj)urL __future__rrdatetimer functoolsrrmtypingrrrr r r r r numpyrpandas._libs.tslibsrrr pandas._libs.window.aggregations_libsrT aggregationsrpandas.compat._optionalr pandas.errorsrpandas.util._decoratorsrpandas.core.dtypes.commonrrrrrrpandas.core.dtypes.dtypesrpandas.core.dtypes.genericrrpandas.core.dtypes.missingrpandas.core._numbarpandas.core.algorithmsrpandas.core.applyr r!pandas.core.arraysr"pandas.core.baser#pandas.core.commoncorecommonrwpandas.core.indexers.objectsr$r%r&r'pandas.core.indexes.apir(r)r*r+r,pandas.core.reshape.concatr-pandas.core.util.numba_r.r/r0pandas.core.window.commonr1r2pandas.core.window.numba_r3r4r5collections.abcr6r7r8r9pandas._typingr:r;r<r=r>r?r@rArrBrCpandas.core.genericrDrWrFpandas.core.arrays.datetimelikerGrIrQrrr6rjrFrcrars #     ?>>#.1-',.+  .  (   ,39a *aHF: F:R  c  Zc  !c  L^ z^ B   j &j !j Z1..  :&:!:rc