o ŀgu@sdZddlmZddlZddlmZddlmZddlZddl m Z ddl m Z m Z mZmZddlZddlmZmZmZddlmmmZdd lmZdd lmZdd lm Z m!Z!dd l"m#Z#m$Z$m%Z%m&Z&m'Z'dd l(m)Z)ddl*m+Z+m,Z,ddl-m.Z.ddl/m0Z0ddl1m2Z2ddl3m4Z4ddl5m6Z6ddl7m8Z8ddl9m:m;Z<ddl=m>Z>m?Z?m@Z@mAZAddlBmCZCmDZDmEZEmFZFmGZGddlHmIZIddlJmKZKmLZLddlMmNZNmOZOddlPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZddl[m\Z\m]Z]m^Z^e r(ddl_m`Z`maZambZbddlcmdZdmeZemfZfmgZgmhZhmiZiddljmkZkmlZlddlmmnZndd lompZpdd!lqmrZrGd"d#d#e8ZsGd$d%d%esZtGd&d'd'esZuGd(d)d)esZvGd*d+d+evZweujew_Gd,d-d-etewZxdS).zc Provide a generic structure to support window functions, similar to how we have a Groupby object. ) annotationsN) timedelta)partial)dedent) TYPE_CHECKINGAnyCallableLiteral) BaseOffset Timedelta to_offset)import_optional_dependency) DataError)deprecate_kwargdoc)ensure_float64is_bool is_integeris_numeric_dtypeneeds_i8_conversion) ArrowDtype) ABCDataFrame ABCSeries)notna)executor) factorize)ResamplerWindowApply)ExtensionArray)SelectionMixin) BaseIndexerFixedWindowIndexerGroupbyIndexerVariableWindowIndexer) DatetimeIndexIndex MultiIndex PeriodIndexTimedeltaIndex)concat)get_jit_argumentsmaybe_use_numba)flex_binary_momentzsqrt) _shared_docscreate_section_headerkwargs_numeric_only kwargs_scipy numba_notestemplate_headertemplate_returnstemplate_see_alsowindow_agg_numba_parameterswindow_apply_parameters)'generate_manual_numpy_nan_agg_with_axisgenerate_numba_apply_funcgenerate_numba_table_func)HashableIteratorSized) ArrayLikeAxisNDFrameTQuantileInterpolationWindowingRankTypenpt) DataFrameSeries)NDFrame BaseGrouper) dtype_to_unitc@s^eZdZUdZgZded<eZded<ded<       dsdd dtdd Zdud!d"Z dvd(d)Z dwdxd-d.Z dyd2d3Z dzd5d6Z d{d|d7d8Zdwd9d:Zd}dd?Zd~d@dAZddCdDZddGdHZddJdKZeddMdNZddPdQZddSdTZ dwddXdYZ d{dd[d\Z  ddd]d^ZddedfZ gdddkdlZ dwddodpZdqdrZ e Z!dS) BaseWindowz7Provides utilities for performing windowing operations. list[str] _attributeszfrozenset[Hashable] exclusionsr$_onNFrsingle) selectionobjrE min_periods int | Nonecenter bool | Nonewin_type str | Noneaxisr>onstr | Index | NoneclosedstepmethodstrreturnNonec  Cs||_||_||_| |_||_||_||_||_|dur!||nd|_ | |_ d|_ |jdur@|j dkr:|jj |_ n1|jj|_ n+t|jtrK|j|_ n t|jtrb|j|jjvrbt|j|j|_ n td|jd| |_|dS)Nrzinvalid on specified as z3, must be a column (of DataFrame), an Index or None)rPrXrZr[windowrQrSrU_get_axis_numberrWr\ _win_freq_i8indexrMcolumns isinstancer$r ValueError _selection _validate) selfrPr`rQrSrUrWrXrZr[r\rOrjN/var/www/html/myenv/lib/python3.10/site-packages/pandas/core/window/rolling.py__init__s0        zBaseWindow.__init__cCsP|jdurt|jstd|jdur= 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)tablerNz!method must be 'table' or 'singlezstep must be an integerzstep must be >= 0)rSrrfrQrr`rZrerPrr TypeErrortyperinspect signatureget_window_bounds parameterskeys__name__r\r[)riget_window_bounds_signatureexpected_signaturerjrjrkrhsN        zBaseWindow._validatestart np.ndarrayendnum_valsintcCsxt|t|krtdt|dt|dt|||jpdd|jp&dkr: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)lenrfr[)rir|r~rrjrjrk_check_window_boundss$ zBaseWindow._check_window_boundsrcresult Sized | NonecCs,|dus t|t|kr|S|dd|jS)zJ Slices the index for a given result and the preset step. N)rr[)rircrrjrjrk_slice_axis_for_steps zBaseWindow._slice_axis_for_stepname numeric_onlyboolcCsB|jjdkr|rt|jjstt|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_objndimrdtypeNotImplementedErrorrsry)rirrrjrjrk_validate_numeric_onlys   z!BaseWindow._validate_numeric_onlyr?cCs|jdgdgd}|S)zSubset DataFrame to numeric columns. Parameters ---------- obj : DataFrame Returns ------- obj subset to numeric-only columns. numberr)includeexclude) select_dtypes)rirPrrjrjrk_make_numeric_onlys zBaseWindow._make_numeric_onlycCs|jdurt|jts|jdkr|j|j|jgdd}|jdkr.|s)|jdkr.||}|jdkr@|j ddd}|j |_ |S)A Split data into blocks & return conformed data. NF)rdcopyrfloat64)r) rXrer$rreindexrd differencerWrastype_mgr consolidate)rirPrrjrjrk _create_datas    zBaseWindow._create_datacsJ|durj}fddjD}||}t|fd|i|}|S)a  Sub-classes to define. Return a sliced object. Parameters ---------- key : str / list of selections ndim : {1, 2} requested ndim of result subset : object, default None subset to act on Ncsi|]}|t|qSrjgetattr).0attrrirjrk 5sz'BaseWindow._gotitem..rO)rPrK_infer_selectionrs)rikeyrsubsetkwargsrOnew_winrjrrk_gotitem#s   zBaseWindow._gotitemrcCsD||jvr t||S||jvr||Stdt|jd|d)N'z' object has no attribute ')_internal_names_setobject__getattribute__rPAttributeErrorrsry)rirrjrjrk __getattr__;s   zBaseWindow.__getattr__cCs |jSN)rP_dir_additionsrrjrjrkrEs zBaseWindow._dir_additionscs4fddjD}d|}tjd|dS)z@ Provide a nice str repr of our rolling object. c3s@|]}t|ddur|ddkr|dt|VqdS)Nr_=r)r attr_namerrjrk Lsz&BaseWindow.__repr__..,z [])rKjoinrsry)ri attrs_listattrsrjrrk__repr__Hs  zBaseWindow.__repr__r;ccs|j|j}||}|}|jt||j|j|j |j d\}}| ||t|t ||D]\}}|j t||}|Vq1dSN num_valuesrQrSrZr[)rset_axisrMr_get_window_indexerrvrrQrSrZr[rzipilocslice)rirPindexerr|r~serrjrjrk__iter__Ts   zBaseWindow.__iter__valuesr=c Cst|jrtdt|jd|jdzt|tr$|jtj tj d}nt |}Wnt t fy@}z t d|j|d}~wwt|}|rRt|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)rrrrsryrerto_numpynprnanrrfrrisinfanywhere)rirerrinfrjrjrk _prep_valuesfs&   zBaseWindow._prep_valuesrCc Csddlm}|jdurb|j|jsd|jj}||j|jj|dd}||jvr,|||<dS||jj vr4dS||j jvr\|j j}|j}| |}| |d|} t | } || ||dS|||<dSdSdS)NrrDFrcrr)pandasrDrXrMequalsrcrrPrdnamesrget_loc intersectionrinsert) rirrPrDr extra_colold_colsnew_colsold_locoverlapnew_locrjrjrk_insert_on_column~s"       zBaseWindow._insert_on_columnnpt.NDArray[np.int64] | NonecCsJt|jtttfr |jjSt|jjtr#|jjjdvr#|jj t j dSdS)NmMr) rerMr&r#r'asi8rrkindrrint64rrjrjrk _index_arrays zBaseWindow._index_arrayoutcCsL|jddkr|jddkrtd|jddkr|dS||||S)zValidate and finalize result.rrNo numeric types to aggregater)shaperrr)rirrPrjrjrk_resolve_outputs   zBaseWindow._resolve_outputrcCs<t|jtr |jS|jdurt|j|j|jdSt|jdS)z[ Return an indexer class that will compute the window start and end bounds N) index_array window_sizerS)r)rer`rrbr"rrSr rrjrjrkrs   zBaseWindow._get_window_indexerhomogeneous_funcCallable[..., ArrayLike]rDc Cs||j}|dkrt|t}z||j}Wnttfy,}zt d|d}~ww||}| |j |}|j |||j dS)z5 Series version of _apply_columnwise countrNrcr)rrrrrr_valuesrrrrrrc _constructorr)rirrrPrrrrcrjrjrk _apply_seriess  zBaseWindow._apply_seriesDataFrame | Seriesc Cs8||||jjdkr|||S||j|}|dkr*t|t}|j |_|j dkr2|j }g}g}t | D]1\}}z||}Wnttfy^} z td|j| d} ~ ww||} || ||q<||jt|dkr||dnd} t|j|| |j|dd} |j dkr| j } || |S)zl Apply the given function to the DataFrame broken down into homogeneous sub-frames. rrz#Cannot aggregate non-numeric type: NrF)rcrdverify_integrity)rrrrrrrrrrrWT enumerate_iter_column_arraysrrrrrrappendrrcrrs _from_arraysrdtaker) rirrrrPtaker res_valuesiarrrresrcdfrjrjrk_apply_columnwisesJ          zBaseWindow._apply_columnwisec Cs|jjdkr td||j|}||}|jdkr |jn|}||}|jdkr.|jn|}||j |}|j dt |j krD|j n|j dd|j }|j|||d} || |S)zT Apply the given function to the DataFrame across the entire object rz1method='table' not applicable for Series objects.Nrcrd)rrrfrrrrWrrrcrrrdr[rr) rirrrrPrrrcrdrrjrjrk_apply_tablewises  zBaseWindow._apply_tablewisetargetotherDataFrame | Series | NonepairwisefuncFCallable[[DataFrame | Series, DataFrame | Series], DataFrame | Series]cCsl|||}|dur|}|durdn|}nt|ttfs td|jdkr,|r,||}t|||t|dS)] Apply the given pairwise function given 2 pandas objects (DataFrame/Series) NTz#other must be a DataFrame or Seriesr)r ) rrerrrfrrr+r)rirr r r rrjrjrk_apply_pairwises  zBaseWindow._apply_pairwiserjCallable[..., Any] numba_argstuple[Any, ...]c sZjdur jnjdfdd }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}cs`|jdkr |Sfdd}tjdd ||}Wd|S1s)wY|S)NrcsJjt|jjjd\}}||t||||gRSr)rvrrSrZr[r)xr|r~r rQrriwindow_indexerrjrkcalcYs z9BaseWindow._apply..homogeneous_func..calcignoreall)sizerrerrstaterrrrrjrkrSs   z+BaseWindow._apply..homogeneous_funcrNrr})rrQrr\rrrir rrrrrrjrrk_apply2s  zBaseWindow._apply engine_kwargsdict[str, bool] | NonecKsF|}|jdur |jn|j}||j}|jdkr|j}||}|j dkr/| dd}|j t |||j |j|jd\}} ||| t |tj} tj|| fddit|} | |jf|| |d|j} |jdkrp| jn| } ||j| } |j dkr| } |j| | |jd}|S||j| j}|j| | |d}|||S) Nrris_grouped_kernelF)r|r~rQrr)rrQrrrrWrrrrreshapervrrSrZr[rrfloat_dtype_mappinggenerate_shared_aggregatorr)rrcsqueezerrrdr)rir r  func_kwargsrrQrPrr|r~ dtype_mapping aggregatorrrcrrdrjrjrk _numba_applyos\        zBaseWindow._numba_applycOs2t||||d}|dur|j|d||dS|S)NargsrF)rawr-r)raggapplyrir r-rrrjrjrk aggregateszBaseWindow.aggregate) NNFNrNNNrN)rPrErQrRrSrTrUrVrWr>rXrYrZrVr[rRr\r]r^r_r^r_)r|r}r~r}rrr^r_r)rcr$rrr^r$)rr]rrr^r_)rPr?r^r?FrPr?rrr^r?)rr])r^r])r^r;)rr=r^r})rrCrPrCr^r_)r^r)rrCrPrCr^rC)r^r)rrrrVr^rD)rrrr]rrr^r)NF)rrrrVrrr^r rrr r r rTr r rrr^rFrj)r rrr]rrrr)r rr r!)"ry __module__ __qualname____doc__rK__annotations__ frozensetrLrlrhrrrrrrrrrrrrpropertyrrrrrrrrr+r2r/rjrjrjrkrIxsb    - +             8  @ 3rIcseZdZUdZded<ded<dgZded<dd d)fddZ  d*d+fdd Zd,fd!d" Zd-d.fd$d% Z d/fd'd( Z Z S)0BaseWindowGroupbyz3 Provide the groupby windowing facilities. rG_grouperr _as_indexrJrKT)r@rPrr^r_cspddlm}t||std||_||_|j|jjdd}|ddur)t dt j |g|Ri|dS)NrrFzMust pass a BaseGrouper object.rrderrorsr[z step not implemented for groupby) pandas.core.groupby.opsrGrerfr?r@droprgetrsuperrl)rirPr?r@r-rrG __class__rjrkrls  zBaseWindowGroupby.__init__Frjr rrr]rrrc sNtj||||fi|}jj}g|j}tjj} | |} fddjjD} t| t| kr;|j| dd}jj } tjj } jj }|rVt t|nt jgt jdfdd| D} |dur|}t|ts{t|g}| t|j | t|j t| | | dd}||_js|jttt| d }|S) Ncs&g|]}|jjjvs|dur|qSr)rPrcr)rrrrjrk s z,BaseWindowGroupby._apply..rrArcsg|]}|qSrj)rrc)rrjrkrIsFrr)level)rFrrPrcrrr?rrDcodeslevelsindicesrr concatenatelistarrayintprrer% from_arraysextendr@ reset_indexrange)rir rrrrrgrouped_object_indexgrouped_index_name groupby_keysresult_index_names drop_columnsrNrO group_indicesidx result_indexrG)rrirkrsJ      zBaseWindowGroupby._applyrr r r rTr cs|j|jjdd}t||||durltfdd|jjDslt}t fdd|jjDdd|jj D}g}g} t t t |D]} tt| |} t| \} } || | | qOn7|jj}|jj} |jj}|rtt |ntjgtjd |jd krd nt|jfd d|D}tjtrt jj}t jj}t jj}ntj\}}|g}|g}jjg}||}| |}|jj|}t|||d d }|_S)rrrANc3s |] }t|tkVqdSr)r)rgroup)r rjrkrs z4BaseWindowGroupby._apply_pairwise..csg|] }|jqSrj)rrrc)r gb_indices)rrjrkrI sz5BaseWindowGroupby._apply_pairwise..css|]}t|VqdSr)commaybe_make_list)rpairrjrjrkr&s  rrcsg|] }t|qSrj)rrepeatrrJ)r repeat_byrjrkrICsFrL)rDr?rrFrrrPrrr(rxmaprRrrrfrSrrrNrOrQrTrrdrercr%r)rirr r r rold_result_lengb_pairs groupby_codesgroupby_levels gb_level_pairlabelsrNrOr^ result_codes result_levels result_names idx_codes idx_levelsr`rG)rr rgrrkrsd                 z!BaseWindowGroupby._apply_pairwiser?cs<|jstt|jjtj}| |}t ||S)r) emptyrrQrRr?rPrrrrrFr)rirPr groupby_orderrGrjrkr\s  zBaseWindowGroupby._create_dataNcs*|jdur |j|j}tj|||dS)N)r)rXrP set_indexrMrFr)rirrrrGrjrkrjs zBaseWindowGroupby._gotitem)rPrr?rGr@rr^r_r7) r rrr]rrrrr^rr6r4r5r) ryr8r9r:r;rKrlrrrr __classcell__rjrjrGrkr>s =Tr>csteZdZdZgdZfddZdddZee de de ddddddZ e Z ee ed eeed!eed"eed#e d$d%d&d'd( d?d@d)d*Zee ed eeed!eed"eed#e d+d%d,d-d( d?d@d.d/Zee ed eeed!eed"eed#e d0d%d1d2d( dAdBd5d6Zee ed eeed!eed"eed#e d7d%d8d9d( dAdBd:d;ZZS)CWindowa Provide rolling window calculations. Parameters ---------- window : int, timedelta, str, offset, or BaseIndexer subclass Size of the moving window. If an integer, the fixed number of observations used for each window. If a timedelta, str, or offset, the time period of each window. Each window will be a variable sized based on the observations included in the time-period. This is only valid for datetimelike indexes. To learn more about the offsets & frequency strings, please see `this link `__. If a BaseIndexer subclass, the window boundaries based on the defined ``get_window_bounds`` method. Additional rolling keyword arguments, namely ``min_periods``, ``center``, ``closed`` and ``step`` will be passed to ``get_window_bounds``. min_periods : int, default None Minimum number of observations in window required to have a value; otherwise, result is ``np.nan``. For a window that is specified by an offset, ``min_periods`` will default to 1. For a window that is specified by an integer, ``min_periods`` will default to the size of the window. center : bool, default False If False, set the window labels as the right edge of the window index. If True, set the window labels as the center of the window index. win_type : str, default None If ``None``, all points are evenly weighted. If a string, it must be a valid `scipy.signal window function `__. Certain Scipy window types require additional parameters to be passed in the aggregation function. The additional parameters must match the keywords specified in the Scipy window type method signature. on : str, optional For a DataFrame, a column label or Index level on which to calculate the rolling window, rather than the DataFrame's index. Provided integer column is ignored and excluded from result since an integer index is not used to calculate the rolling window. axis : int or str, default 0 If ``0`` or ``'index'``, roll across the rows. If ``1`` or ``'columns'``, roll across the columns. For `Series` this parameter is unused and defaults to 0. .. deprecated:: 2.1.0 The axis keyword is deprecated. For ``axis=1``, transpose the DataFrame first instead. closed : str, default None If ``'right'``, the first point in the window is excluded from calculations. If ``'left'``, the last point in the window is excluded from calculations. If ``'both'``, the no points in the window are excluded from calculations. If ``'neither'``, the first and last points in the window are excluded from calculations. Default ``None`` (``'right'``). step : int, default None .. versionadded:: 1.5.0 Evaluate the window at every ``step`` result, equivalent to slicing as ``[::step]``. ``window`` must be an integer. Using a step argument other than None or 1 will produce a result with a different shape than the input. method : str {'single', 'table'}, default 'single' .. versionadded:: 1.3.0 Execute the rolling operation per single column or row (``'single'``) or over the entire object (``'table'``). This argument is only implemented when specifying ``engine='numba'`` in the method call. Returns ------- pandas.api.typing.Window or pandas.api.typing.Rolling An instance of Window is returned if ``win_type`` is passed. Otherwise, an instance of Rolling is returned. See Also -------- expanding : Provides expanding transformations. ewm : Provides exponential weighted functions. Notes ----- See :ref:`Windowing Operations ` for further usage details and examples. Examples -------- >>> df = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]}) >>> df B 0 0.0 1 1.0 2 2.0 3 NaN 4 4.0 **window** Rolling sum with a window length of 2 observations. >>> df.rolling(2).sum() B 0 NaN 1 1.0 2 3.0 3 NaN 4 NaN Rolling sum with a window span of 2 seconds. >>> df_time = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]}, ... index=[pd.Timestamp('20130101 09:00:00'), ... pd.Timestamp('20130101 09:00:02'), ... pd.Timestamp('20130101 09:00:03'), ... pd.Timestamp('20130101 09:00:05'), ... pd.Timestamp('20130101 09:00:06')]) >>> df_time B 2013-01-01 09:00:00 0.0 2013-01-01 09:00:02 1.0 2013-01-01 09:00:03 2.0 2013-01-01 09:00:05 NaN 2013-01-01 09:00:06 4.0 >>> df_time.rolling('2s').sum() B 2013-01-01 09:00:00 0.0 2013-01-01 09:00:02 1.0 2013-01-01 09:00:03 3.0 2013-01-01 09:00:05 NaN 2013-01-01 09:00:06 4.0 Rolling sum with forward looking windows with 2 observations. >>> indexer = pd.api.indexers.FixedForwardWindowIndexer(window_size=2) >>> df.rolling(window=indexer, min_periods=1).sum() B 0 1.0 1 3.0 2 2.0 3 4.0 4 4.0 **min_periods** Rolling sum with a window length of 2 observations, but only needs a minimum of 1 observation to calculate a value. >>> df.rolling(2, min_periods=1).sum() B 0 0.0 1 1.0 2 3.0 3 2.0 4 4.0 **center** Rolling sum with the result assigned to the center of the window index. >>> df.rolling(3, min_periods=1, center=True).sum() B 0 1.0 1 3.0 2 3.0 3 6.0 4 4.0 >>> df.rolling(3, min_periods=1, center=False).sum() B 0 0.0 1 1.0 2 3.0 3 3.0 4 6.0 **step** Rolling sum with a window length of 2 observations, minimum of 1 observation to calculate a value, and a step of 2. >>> df.rolling(2, min_periods=1, step=2).sum() B 0 0.0 2 3.0 4 4.0 **win_type** Rolling sum with a window length of 2, using the Scipy ``'gaussian'`` window type. ``std`` is required in the aggregation function. >>> df.rolling(2, win_type='gaussian').sum(std=3) B 0 NaN 1 0.986207 2 2.958621 3 NaN 4 NaN **on** Rolling sum with a window length of 2 days. >>> df = pd.DataFrame({ ... 'A': [pd.to_datetime('2020-01-01'), ... pd.to_datetime('2020-01-01'), ... pd.to_datetime('2020-01-02'),], ... 'B': [1, 2, 3], }, ... index=pd.date_range('2020', periods=3)) >>> df A B 2020-01-01 2020-01-01 1 2020-01-02 2020-01-01 2 2020-01-03 2020-01-02 3 >>> df.rolling('2D', on='A').sum() A B 2020-01-01 2020-01-01 1.0 2020-01-02 2020-01-01 3.0 2020-01-03 2020-01-02 6.0 r`rQrSrUrWrXrZr[r\cstt|jtstd|jtddd}t||jd|_|jdur.td|jt|j t r8t dt |j rB|j dkrFtd|j dkrOt d 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 greaterrNz+'single' is the only supported method type.)rFrhrerUr]rfr r_scipy_weight_generatorr`rrrr\)risignalrGrjrkrh|s$     zWindow._validaterr}offsetrr^cCs*|dkrt|dg}t|t|}|S)zT Center the result in the window for weighted rolling aggregations. rN)rrrtuple)rirr~ lead_indexerrjrjrk_center_windows zWindow._center_windowFrjr ,Callable[[np.ndarray, int, int], np.ndarray]rr]rrrrc s\jjfi|jrtddndd fdd }|||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}cst|jdkr |Sfdd}tjddt||}Wdn1s*wYjr8|}|S)NrcsBttjg}t||f}|jdurjStSr)rrSrrQrQr)radditional_nansr r~rir`rjrkrsz5Window._apply..homogeneous_func..calcrr)rrrrasarrayrSrrrrjrkrs   z'Window._apply..homogeneous_funcNr)r|r`rSrrr[rrjrrkrs  z Window._applyr2z See Also -------- pandas.DataFrame.aggregate : Similar DataFrame method. pandas.Series.aggregate : Similar Series method. at Examples -------- >>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6], "C": [7, 8, 9]}) >>> df A B C 0 1 4 7 1 2 5 8 2 3 6 9 >>> df.rolling(2, win_type="boxcar").agg("mean") A B C 0 NaN NaN NaN 1 1.5 4.5 7.5 2 2.5 5.5 8.5 zSeries/DataFramesee_alsoexamplesklassrWcOs(t||||d}|dur||}|S)Nr,)rr/r1rjrjrkr2s zWindow.aggregate ParametersReturnsSee AlsoExamplesa >>> ser = pd.Series([0, 1, 5, 2, 8]) To get an instance of :class:`~pandas.core.window.rolling.Window` we need to pass the parameter `win_type`. >>> type(ser.rolling(2, win_type='gaussian')) In order to use the `SciPy` Gaussian window we need to provide the parameters `M` and `std`. The parameter `M` corresponds to 2 in our example. We pass the second parameter `std` as a parameter of the following method (`sum` in this case): >>> ser.rolling(2, win_type='gaussian').sum(std=3) 0 NaN 1 0.986207 2 5.917243 3 6.903450 4 9.862071 dtype: float64 rollingzweighted window sumsum window_methodaggregation_description agg_methodcKtj}|j|fd|d|S)Nrrr)window_aggregationsroll_weighted_sumrrirr window_funcrjrjrkrs'z Window.suma >>> ser = pd.Series([0, 1, 5, 2, 8]) To get an instance of :class:`~pandas.core.window.rolling.Window` we need to pass the parameter `win_type`. >>> type(ser.rolling(2, win_type='gaussian')) In order to use the `SciPy` Gaussian window we need to provide the parameters `M` and `std`. The parameter `M` corresponds to 2 in our example. We pass the second parameter `std` as a parameter of the following method: >>> ser.rolling(2, win_type='gaussian').mean(std=3) 0 NaN 1 0.5 2 3.0 3 3.5 4 5.0 dtype: float64 zweighted window meanmeancKr)Nrr)rroll_weighted_meanrrrjrjrkr4s&z Window.meana >>> ser = pd.Series([0, 1, 5, 2, 8]) To get an instance of :class:`~pandas.core.window.rolling.Window` we need to pass the parameter `win_type`. >>> type(ser.rolling(2, win_type='gaussian')) In order to use the `SciPy` Gaussian window we need to provide the parameters `M` and `std`. The parameter `M` corresponds to 2 in our example. We pass the second parameter `std` as a parameter of the following method: >>> ser.rolling(2, win_type='gaussian').var(std=3) 0 NaN 1 0.5 2 8.0 3 4.5 4 18.0 dtype: float64 zweighted window variancevarrddofcKs2ttj|d}|dd|j|fd|d|S)Nrrrr)rrroll_weighted_varpopr)rirrrrrjrjrkres& z Window.vara >>> ser = pd.Series([0, 1, 5, 2, 8]) To get an instance of :class:`~pandas.core.window.rolling.Window` we need to pass the parameter `win_type`. >>> type(ser.rolling(2, win_type='gaussian')) In order to use the `SciPy` Gaussian window we need to provide the parameters `M` and `std`. The parameter `M` corresponds to 2 in our example. We pass the second parameter `std` as a parameter of the following method: >>> ser.rolling(2, win_type='gaussian').std(std=3) 0 NaN 1 0.707107 2 2.828427 3 2.121320 4 4.242641 dtype: float64 z"weighted window standard deviationstdcKst|jd|d|d|S)Nr)rrrrj)r,r)rirrrrjrjrkrs&z Window.std)rr}r~rr^r}r7)r rrr]rrrrr4rrrFrrrr)ryr8r9r:rKrhrrrr-rr2r/r2r.r/r0r3r4rrrrrwrjrjrGrkrxts|   > & % %%rxc@s*eZdZdJdKddZ     dLdMddZdNddZ   dOdPddZ   dOdPddZ   dOdPd d!Z   dOdPd"d#Z   dOdPd$d%Z &   dQdRd)d*Z &   dQdRd+d,Z dJdKd-d.Z dSdTd/d0ZdJdKd1d2Z 3 dUdVd8d9Z : ;  dWdXd@dAZ   & dYdZdFdGZ   & dYdZdHdIZdS)[RollingAndExpandingMixinFrrcCtj}|j|d|dS)Nrr)rroll_sumrrirrrjrjrkrszRollingAndExpandingMixin.countNr rr.engine!Literal['cython', 'numba'] | Noner r!r-tuple[Any, ...] | Nonerdict[str, Any] | Nonec Cs|durd}|dur i}t|stdd}t|rA|dur"td|}|jdkr5t|fit||}n%t|fit||}n|dvrV|durMtd|||||}ntd|j|d |d S) Nrjz'raw parameter must be `True` or `False`Fz.raw must be `True` when using the numba enginerN)cythonNz+cython engine does not accept engine_kwargsz)engine must be either 'numba' or 'cython'r0)rr) rrfr*r\r8r)r9_generate_cython_apply_funcr) rir r.rr r-rr apply_funcrjrjrkr0s@  zRollingAndExpandingMixin.applyrdict[str, Any]bool | np.bool_functionr^?Callable[[np.ndarray, np.ndarray, np.ndarray, int], np.ndarray]cs8ddlmttj||||d|ffdd }|S)Nrr)r-rr.rcs"|s |jdd}||||S)NF)rcr)rM)rbeginr~rQr.rDrirrjrkrszHRollingAndExpandingMixin._generate_cython_apply_func..apply_func)rrDrr roll_apply)rir-rr.rrrjrrkrs z4RollingAndExpandingMixin._generate_cython_apply_funccC\t|r#|jdkrttj}|j|d||dSddlm}|||St j }|j |d|dS)NrqTr.rr r) sliding_sumrr) r*r\r7rnansumr0pandas.core._numba.kernelsrr+rrr)rirrr r rrrjrjrkr    zRollingAndExpandingMixin.sumcCs`t|r%|jdkrttj}|j|d||dSddlm}|j||ddSt j }|j |d|dS) NrqTrrsliding_min_maxis_maxmaxr) r*r\r7rnanmaxr0rrr+rroll_maxrrirrr r rrrjrjrkr   zRollingAndExpandingMixin.maxcCs`t|r%|jdkrttj}|j|d||dSddlm}|j||ddSt j }|j |d|d S) NrqTrrrFrminr) r*r\r7rnanminr0rrr+rroll_minrrrjrjrkr/rzRollingAndExpandingMixin.mincCr)NrqTrr) sliding_meanrr) r*r\r7rnanmeanr0rrr+r roll_meanr)rirrr r rrrjrjrkrErzRollingAndExpandingMixin.meancCsLt|r|jdkrttj}ntj}|j|d||dStj}|j|d|dS)NrqTrmedianr) r*r\r7r nanmedianr0r roll_median_cr)rirrr r rrjrjrkr[s  zRollingAndExpandingMixin.medianrrrcs^t|r|jdkr tdddlm}t|j||dStjfdd}|j |d|d S) Nrqz%std not supported with method='table'r sliding_varrcst||||dS)Nr)r,)rrr~rQrrrjrk zsqrt_funcsz0RollingAndExpandingMixin.std..zsqrt_funcrr) r*r\rrrr,r+rroll_varr)rirrrr rrrjrrkrps  zRollingAndExpandingMixin.stdcCsTt|r|jdkr tdddlm}|j|||dSttj|d}|j |d|dS)Nrqz%var not supported with method='table'rrrrr) r*r\rrrr+rrrr)rirrrr rrrjrjrkrs  zRollingAndExpandingMixin.varcCr)Nskewr)r roll_skewrrrjrjrkr zRollingAndExpandingMixin.skewcCs.|d||j|d|j|d|dSNsemr?rrrpowrirrrjrjrkrs  zRollingAndExpandingMixin.semcCr)Nkurtr)r roll_kurtrrrjrjrkrrzRollingAndExpandingMixin.kurtlinearqfloat interpolationr@cCs@|dkrtj}n|dkrtj}nttj||d}|j|d|dS)Ng?g)quantilerrr)rrrr roll_quantiler)rirrrrrjrjrkrsz!RollingAndExpandingMixin.quantileaverageTr\rA ascendingpctcCs"ttj|||d}|j|d|dS)N)r\r percentilerankr)rr roll_rankr)rir\rrrrrjrjrkrszRollingAndExpandingMixin.rankr r r rTcNjdur tdd|ddlmfdd}j||||S)Nzstep not implemented for covcovrrc s|}|}}jdurjn|j}|jt||jjjd\}} ||t|t j dd>t |||||}t ||||} t ||||} t t||t j||d} || | | | } Wdn1szwY| |j|jddS)NrrrrFr)rrrQrrvrrSrZr[rrrrrrrrrrcr) ryx_arrayy_arrayrrQr|r~mean_x_ymean_xmean_y count_x_yrrDrrirjrkcov_funcs6      z.RollingAndExpandingMixin.cov..cov_funcr[rrrrDrr)rir r rrrrjrrkrs    zRollingAndExpandingMixin.covcr)Nzstep not implemented for corrcorrrrcsJ|}|}}jdurjn|j}|jt||jjjd\}} ||t|t j ddZt |||||}t ||||} t ||||} t t||t j||d} t ||||} t ||||} || | | | }| | d}||}Wdn1swY||j|jddS)NrrrrrFr)rrrQrrvrrSrZr[rrrrrrrrrrrcr)rrrrrrQr|r~rrrrx_vary_var numerator denominatorrrrjrk corr_funcsJ           z0RollingAndExpandingMixin.corr..corr_funcr)rir r rrrrjrrkrs   ( zRollingAndExpandingMixin.corrr4rFNNNN r rr.rrrr r!r-rrr) r-rrrr.rrrr^rFNNrrrrr r!rFNNrrrrrrr r!rrrFrrrr@rrrTFFr\rArrrrrrNNrFr r r rTrrrr)ryr8r9rr0rrrrrrrrrrrrrrrrjrjrjrkrsx  +             1rcseZdZUgdZded<fddZddd Zdd d Zee de de ddddfddZ e Z ee edeedeedeede dddddddd ddfd$d% Zee edeedeedeede d&dd'd(d ! ) ) ) )ddfd5d6 Zee edeeedeedeed7eede d8ddddd9d9d  ! ) )ddfd:d; Zee edeeedeedeed7eede d<dd=d>d  !dd)d)d?dfd@dAZee edeeedeedeed7eede dBdddddCdDd  ! ) )ddfdEdF Zee edeeedeedeed7eede dGdddddHdHd  ! ) )ddfdIdJ Zee edeeedeedeed7eede dKdddddLdLd  ! ) )ddfdMdN Zee ede dOdddeedPedeeddQeed7e dRdddede dSdddddTdUd   ! ) )ddfdXdY Zee ede dOdddeedPedeeddZeed7e d[dddede d\ddddd]d^d   ! ) )ddfd_d` Zee edeedeeddaeed7e dbede dcdddded ddfdfdg Zee ede dOdddeedeedeed7dhede didddddjdkd dddldmZ ee edeedeeddneed7doede dpdddddqdrd ddfdsdt Z!ee ede dudddeedeedeede dvdddddwdwd e"dwdxdy z !ddfd~d Z#ee dede ddddeedeedeede dddddddd  ! !ddfdd Z$ee ede ddddeedeedeede ddddd ) )  !ddfdd Z%ee ede ddddeedeede ddddeed7e ddddede dddddddd  ) )  !ddfdd Z&Z'S)RollingryrJrKc sVt|jjs t|jtttfs t|jj t r|jj j dvrt|j t ttfr|zt|j }WnttfyL}z td|j d|d}~wwt|jtrb|j|jjj|jjj|_nzt|jj }Wn tyud}Ynwt|j|j|_|jdurd|_|jdurtddSt|j trdSt |j r|j dkrtddS) Nrzpassed window z, is not compatible with a datetimelike indexnsrz,step is not supported with frequency windowsrr{)!rFrhrPrtrerMr#r'r&rrrr`r]r r _validate_datetimelike_monotonicr rrrfnanosfreqnrbrHr as_unit_valuerQr[rrr)rirrunitrGrjrkrhLsV        zRolling._validater^r_cCs8|jjr |d|jjs|jjs|ddSdSdS)z Validate self._on is monotonic (increasing or decreasing) and has no NaT values for frequency windows. values must not have NaTzvalues must be monotonicN)rMhasnans_raise_monotonic_erroris_monotonic_increasingis_monotonic_decreasingrrjrjrkr |s  z(Rolling._validate_datetimelike_monotonicmsgr]cCs4|j}|dur|jdkrd}nd}t|d|)Nrrccolumn )rXrWrf)rirrXrjrjrkrs  zRolling._raise_monotonic_errorr2z See Also -------- pandas.Series.rolling : Calling object with Series data. pandas.DataFrame.rolling : Calling object with DataFrame data. a Examples -------- >>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6], "C": [7, 8, 9]}) >>> df A B C 0 1 4 7 1 2 5 8 2 3 6 9 >>> df.rolling(2).sum() A B C 0 NaN NaN NaN 1 3.0 9.0 15.0 2 5.0 11.0 17.0 >>> df.rolling(2).agg({"A": "sum", "B": "min"}) A B 0 NaN NaN 1 3.0 4.0 2 5.0 5.0 zSeries/Dataframerrcstj|g|Ri|Sr)rFr2)rir r-rrGrjrkr2s&zRolling.aggregaterrrra >>> 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  rrzcount of non NaN observationsrrFrrcs t|Sr)rFrrirrGrjrkrs %z Rolling.countz >>> ser = pd.Series([1, 6, 5, 4]) >>> ser.rolling(2).apply(lambda s: s.sum() - s.min()) 0 NaN 1 6.0 2 6.0 3 5.0 dtype: float64 zcustom aggregation functionr0Nr rr.rrr r!r-rrrcstj||||||dS)N)r.rr r-r)rFr0)rir r.rr r-rrGrjrkr0s!z Rolling.applyNotesa] >>> 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 rctj|||dSN)rrr )rFrrirrr rGrjrkr s Ez Rolling.sumz >>> ser = pd.Series([1, 2, 3, 4]) >>> ser.rolling(2).max() 0 NaN 1 2.0 2 3.0 3 4.0 dtype: float64 maximumr)rr crr )rFr)rirrr r-rrGrjrkrUs #z Rolling.maxz Performing a rolling minimum with a window size of 3. >>> s = pd.Series([4, 3, 5, 2, 6]) >>> s.rolling(3).min() 0 NaN 1 NaN 2 3.0 3 2.0 4 2.0 dtype: float64 minimumrcrr )rFrr!rGrjrkr~ $z Rolling.mina The below examples will show rolling mean calculations with window sizes of two and three, respectively. >>> s = pd.Series([1, 2, 3, 4]) >>> s.rolling(2).mean() 0 NaN 1 1.5 2 2.5 3 3.5 dtype: float64 >>> s.rolling(3).mean() 0 NaN 1 NaN 2 2.0 3 3.0 dtype: float64 rcrr )rFrr!rGrjrkrs +z Rolling.meana  Compute the rolling median of a series with a window size of 3. >>> s = pd.Series([0, 1, 2, 3, 4]) >>> s.rolling(3).median() 0 NaN 1 NaN 2 1.0 3 2.0 4 3.0 dtype: float64 rcrr )rFrr!rGrjrkrr$zRolling.medianz ddof : int, default 1 Delta Degrees of Freedom. The divisor used in calculations is ``N - ddof``, where ``N`` represents the number of elements. z1.4z/numpy.std : Equivalent method for NumPy array. z The default ``ddof`` of 1 used in :meth:`Series.std` is different than the default ``ddof`` of 0 in :func:`numpy.std`. A minimum of one period is required for the rolling calculation. a  >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5]) >>> s.rolling(3).std() 0 NaN 1 NaN 2 0.577350 3 1.000000 4 1.000000 5 1.154701 6 0.000000 dtype: float64 zstandard deviationrrrctj||||dSN)rrrr )rFrrirrrr rGrjrkr 4z Rolling.stdz/numpy.var : Equivalent method for NumPy array. z The default ``ddof`` of 1 used in :meth:`Series.var` is different than the default ``ddof`` of 0 in :func:`numpy.var`. A minimum of one period is required for the rolling calculation. a  >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5]) >>> s.rolling(3).var() 0 NaN 1 NaN 2 0.333333 3 1.000000 4 1.000000 5 1.333333 6 0.000000 dtype: float64 variancercr%r&)rFrr'rGrjrkr> r(z Rolling.varz:scipy.stats.skew : Third moment of a probability density. zV A minimum of three periods is required for the rolling calculation. z >>> ser = pd.Series([1, 5, 2, 7, 15, 6]) >>> ser.rolling(3).skew().round(6) 0 NaN 1 NaN 2 1.293343 3 -0.585583 4 0.670284 5 1.652317 dtype: float64 zunbiased skewnessrctj|dSNr)rFrrrGrjrkry s"z Rolling.skewz:A minimum of one period is required for the calculation. z >>> s = pd.Series([0, 1, 2, 3]) >>> s.rolling(2, min_periods=1).sem() 0 NaN 1 0.707107 2 0.707107 3 0.707107 dtype: float64 zstandard error of meanrcCs,|d||j|d|||dSrrrrjrjrkr s #  z Rolling.semz/scipy.stats.kurtosis : Reference SciPy method. z>> arr = [1, 2, 3, 4, 999] >>> import scipy.stats >>> print(f"{{scipy.stats.kurtosis(arr[:-1], bias=False):.6f}}") -1.200000 >>> print(f"{{scipy.stats.kurtosis(arr[1:], bias=False):.6f}}") 3.999946 >>> s = pd.Series(arr) >>> s.rolling(4).kurt() 0 NaN 1 NaN 2 NaN 3 -1.200000 4 3.999946 dtype: float64 z,Fisher's definition of kurtosis without biasrcr*r+)rFrrrGrjrkr s&z Rolling.kurta quantile : float Quantile to compute. 0 <= quantile <= 1. .. deprecated:: 2.1.0 This will be renamed to 'q' in a future version. interpolation : {{'linear', 'lower', 'higher', 'midpoint', 'nearest'}} This optional parameter specifies the interpolation method to use, when the desired quantile lies between two data points `i` and `j`: * linear: `i + (j - i) * fraction`, where `fraction` is the fractional part of the index surrounded by `i` and `j`. * lower: `i`. * higher: `j`. * nearest: `i` or `j` whichever is nearest. * midpoint: (`i` + `j`) / 2. ae >>> s = pd.Series([1, 2, 3, 4]) >>> s.rolling(2).quantile(.4, interpolation='lower') 0 NaN 1 1.0 2 2.0 3 3.0 dtype: float64 >>> s.rolling(2).quantile(.4, interpolation='midpoint') 0 NaN 1 1.5 2 2.5 3 3.5 dtype: float64 rr) old_arg_name new_arg_namerrrr@cr)N)rrr)rFr)rirrrrGrjrkr s 9zRolling.quantilez.. versionadded:: 1.4.0 a method : {{'average', 'min', 'max'}}, default 'average' How to rank the group of records that have the same value (i.e. ties): * average: average rank of the group * min: lowest rank in the group * max: highest rank in the group ascending : bool, default True Whether or not the elements should be ranked in ascending order. pct : bool, default False Whether or not to display the returned rankings in percentile form. a( >>> s = pd.Series([1, 4, 2, 3, 5, 3]) >>> s.rolling(3).rank() 0 NaN 1 NaN 2 2.0 3 2.0 4 3.0 5 1.5 dtype: float64 >>> s.rolling(3).rank(method="max") 0 NaN 1 NaN 2 2.0 3 2.0 4 3.0 5 2.0 dtype: float64 >>> s.rolling(3).rank(method="min") 0 NaN 1 NaN 2 2.0 3 2.0 4 3.0 5 1.0 dtype: float64 rrTr\rArrcr%)N)r\rrr)rFr)rir\rrrrGrjrkr, s Dz Rolling.ranka other : Series or DataFrame, optional If not supplied then will default to self and produce pairwise output. pairwise : bool, default None If False then only matching columns between self and other will be used and the output will be a DataFrame. If True then all pairwise combinations will be calculated and the output will be a MultiIndexed DataFrame in the case of DataFrame inputs. In the case of missing elements, only complete pairwise observations will be used. ddof : int, default 1 Delta Degrees of Freedom. The divisor used in calculations is ``N - ddof``, where ``N`` represents the number of elements. z >>> ser1 = pd.Series([1, 2, 3, 4]) >>> ser2 = pd.Series([1, 4, 5, 8]) >>> ser1.rolling(2).cov(ser2) 0 NaN 1 1.5 2 0.5 3 1.5 dtype: float64 zsample covariancerr r r rTcr%N)r r rr)rFrrir r rrrGrjrkrw s 1z Rolling.covz cov : Similar method to calculate covariance. numpy.corrcoef : NumPy Pearson's correlation calculation. ao This function uses Pearson's definition of correlation (https://en.wikipedia.org/wiki/Pearson_correlation_coefficient). When `other` is not specified, the output will be self correlation (e.g. all 1's), except for :class:`~pandas.DataFrame` inputs with `pairwise` set to `True`. Function will return ``NaN`` for correlations of equal valued sequences; this is the result of a 0/0 division error. When `pairwise` is set to `False`, only matching columns between `self` and `other` will be used. When `pairwise` is set to `True`, the output will be a MultiIndex DataFrame with the original index on the first level, and the `other` DataFrame columns on the second level. In the case of missing elements, only complete pairwise observations will be used. ax The below example shows a rolling calculation with a window size of four matching the equivalent function call using :meth:`numpy.corrcoef`. >>> v1 = [3, 3, 3, 5, 8] >>> v2 = [3, 4, 4, 4, 8] >>> np.corrcoef(v1[:-1], v2[:-1]) array([[1. , 0.33333333], [0.33333333, 1. ]]) >>> np.corrcoef(v1[1:], v2[1:]) array([[1. , 0.9169493], [0.9169493, 1. ]]) >>> s1 = pd.Series(v1) >>> s2 = pd.Series(v2) >>> s1.rolling(4).corr(s2) 0 NaN 1 NaN 2 NaN 3 0.333333 4 0.916949 dtype: float64 The below example shows a similar rolling calculation on a DataFrame using the pairwise option. >>> matrix = np.array([[51., 35.], ... [49., 30.], ... [47., 32.], ... [46., 31.], ... [50., 36.]]) >>> np.corrcoef(matrix[:-1, 0], matrix[:-1, 1]) array([[1. , 0.6263001], [0.6263001, 1. ]]) >>> np.corrcoef(matrix[1:, 0], matrix[1:, 1]) array([[1. , 0.55536811], [0.55536811, 1. ]]) >>> df = pd.DataFrame(matrix, columns=['X', 'Y']) >>> df X Y 0 51.0 35.0 1 49.0 30.0 2 47.0 32.0 3 46.0 31.0 4 50.0 36.0 >>> df.rolling(4).corr(pairwise=True) X Y 0 X NaN NaN Y NaN NaN 1 X NaN NaN Y NaN NaN 2 X NaN NaN Y NaN NaN 3 X 1.000000 0.626300 Y 0.626300 1.000000 4 X 1.000000 0.555368 Y 0.555368 1.000000 correlationrcr%r.)rFrr/rGrjrkr s ~z Rolling.corrr3)rr]r4rrrrrrrrrrrrrr r )(ryr8r9rKr;rhr rrr-rr2r/r2r.r/r3r4replacerr6r0r5r1rrrrrrrrrrrrrrrrwrjrjrGrkr ?sN  0  % $  .A      '       /   / !  ! %   2   ?  ,    :yr c@s.eZdZdZejejZd ddZddZdS) RollingGroupbyz3 Provide a rolling groupby implementation. r^r!cCsd}|j}t|jtr't|j}|jj}t|tsJ|dd|j}n|j dur2t }|j }nt }|j}t |||j j||d}|S)z Return an indexer class that will compute the window start and end bounds Returns ------- GroupbyIndexer Nr)rrgroupby_indicesrindexer_kwargs)rrer`rrs__dict__rdictrrbr"r r!r?rP)rir4rrolling_indexerr`rrjrjrkr? s*      z"RollingGroupby._get_window_indexercCsj|jjr |d|jjD]#}|j|}|js2|js2|j dur$dn|j }t d|d|dqdS)zC Validate that each group in self._on is monotonic rNrczEach group within z' must be monotonic. Sort the values in z first.) rMrrr?rPrrrrrXrf)rir^group_onrXrjrjrkr b s   z/RollingGroupby._validate_datetimelike_monotonicN)r^r!) ryr8r9r:r rKr>rr rjrjrjrkr28 s    #r2)yr: __future__rrdatetimer functoolsrrttextwraprtypingrrrr numpyrpandas._libs.tslibsr r r pandas._libs.window.aggregations_libsr` aggregationsrpandas.compat._optionalr pandas.errorsrpandas.util._decoratorsrrpandas.core.dtypes.commonrrrrrpandas.core.dtypes.dtypesrpandas.core.dtypes.genericrrpandas.core.dtypes.missingrpandas.core._numbarpandas.core.algorithmsrpandas.core.applyrpandas.core.arraysrpandas.core.baserpandas.core.commoncorecommonrcpandas.core.indexers.objectsrr r!r"pandas.core.indexes.apir#r$r%r&r'pandas.core.reshape.concatr(pandas.core.util.numba_r)r*pandas.core.window.commonr+r,pandas.core.window.docr-r.r/r0r1r2r3r4r5r6pandas.core.window.numba_r7r8r9collections.abcr:r;r<pandas._typingr=r>r?r@rArBrrCrDpandas.core.genericrErCrGpandas.core.arrays.datetimelikerHrIr>rxrr r2rjrjrjrks              0     7JJ}