html_url,issue_url,id,node_id,user,created_at,updated_at,author_association,body,reactions,performed_via_github_app,issue
https://github.com/pydata/xarray/issues/2007#issuecomment-880141480,https://api.github.com/repos/pydata/xarray/issues/2007,880141480,MDEyOklzc3VlQ29tbWVudDg4MDE0MTQ4MA==,223250,2021-07-14T19:10:46Z,2021-07-14T19:10:46Z,CONTRIBUTOR,"I added support for `.rolling(..., pad=False)` in #5603.  The basic implementation was simple, but getting it working for bottleneck/dask took a little more work.

That fixes, e.g., #4743, but I don't think it's a complete fix for this issue.","{""total_count"": 0, ""+1"": 0, ""-1"": 0, ""laugh"": 0, ""hooray"": 0, ""confused"": 0, ""heart"": 0, ""rocket"": 0, ""eyes"": 0}",,307783090
https://github.com/pydata/xarray/issues/2007#issuecomment-876579830,https://api.github.com/repos/pydata/xarray/issues/2007,876579830,MDEyOklzc3VlQ29tbWVudDg3NjU3OTgzMA==,2448579,2021-07-08T16:30:06Z,2021-07-08T16:30:06Z,MEMBER,Yes. I think we might want this anyway; for `rolling` without any padding at all.,"{""total_count"": 0, ""+1"": 0, ""-1"": 0, ""laugh"": 0, ""hooray"": 0, ""confused"": 0, ""heart"": 0, ""rocket"": 0, ""eyes"": 0}",,307783090
https://github.com/pydata/xarray/issues/2007#issuecomment-876103462,https://api.github.com/repos/pydata/xarray/issues/2007,876103462,MDEyOklzc3VlQ29tbWVudDg3NjEwMzQ2Mg==,223250,2021-07-08T03:55:33Z,2021-07-08T03:55:33Z,CONTRIBUTOR,"> `.pad(...).rolling(..., pad=False)`

For this API, it seems that the only thing that would need to be implemented would be adding a `pad` keyword argument to rolling, defaulting to `True`.  Is that correct?","{""total_count"": 0, ""+1"": 0, ""-1"": 0, ""laugh"": 0, ""hooray"": 0, ""confused"": 0, ""heart"": 0, ""rocket"": 0, ""eyes"": 0}",,307783090
https://github.com/pydata/xarray/issues/2007#issuecomment-875980218,https://api.github.com/repos/pydata/xarray/issues/2007,875980218,MDEyOklzc3VlQ29tbWVudDg3NTk4MDIxOA==,2448579,2021-07-07T22:38:08Z,2021-07-07T22:38:08Z,MEMBER,"This should be easy now so we just need someone to try it out.

This is where the padding happens so the kwarg needs to be passed all the way down to `Variable.rolling_window`
https://github.com/pydata/xarray/blob/67d1955cc1d6941edd12a325090da7e4d029b84c/xarray/core/variable.py#L2132

What should the API be? `.rolling(..., pad_kwargs={...})` or just have `.pad(...).rolling(..., pad=False)` i.e. have the user `pad` beforehand? The only advantage to the first one AFAICT is that the user doesn't have to specify the window length (or padding length) twice.
","{""total_count"": 0, ""+1"": 0, ""-1"": 0, ""laugh"": 0, ""hooray"": 0, ""confused"": 0, ""heart"": 0, ""rocket"": 0, ""eyes"": 0}",,307783090
https://github.com/pydata/xarray/issues/2007#issuecomment-875974272,https://api.github.com/repos/pydata/xarray/issues/2007,875974272,MDEyOklzc3VlQ29tbWVudDg3NTk3NDI3Mg==,6426942,2021-07-07T22:23:31Z,2021-07-07T22:24:11Z,NONE,"Hello! First of all, thanks so much for those of you who contribute to xarray, I've found it super useful as an n-dimensional extension of pandas!

I was just wondering what the current state of this issue is? I'm running into exactly the issue described in https://github.com/pydata/xarray/issues/4743 which seems like a bug; that issue was closed as a dupe of this. Are we just waiting for someone to implement something here, or are there other blockers?","{""total_count"": 0, ""+1"": 0, ""-1"": 0, ""laugh"": 0, ""hooray"": 0, ""confused"": 0, ""heart"": 0, ""rocket"": 0, ""eyes"": 0}",,307783090
https://github.com/pydata/xarray/issues/2007#issuecomment-747376047,https://api.github.com/repos/pydata/xarray/issues/2007,747376047,MDEyOklzc3VlQ29tbWVudDc0NzM3NjA0Nw==,10194086,2020-12-17T11:14:33Z,2020-12-17T16:02:25Z,MEMBER,"I just need to find the **three warmest consecutive months** from a temperature dataset for my work, so I thought I add a complete example. First, create an example dataset with monthly temperature:

```python
import xarray as xr
import numpy as np
import pandas as pd

time = pd.date_range(""2000"", periods=12 * 30, freq=""M"")
temp = np.sin((time.month - 5) / 6 * np.pi) + np.random.randn(*time.shape) * 0.3
da = xr.DataArray(temp, dims=[""time""], coords=dict(time=time))
print(da)
```

```python
<xarray.DataArray (time: 360)>
array([-0.676731, -0.812742, -1.367547, ...,  0.186731,  0.237676, -0.343879])
Coordinates:
  * time     (time) datetime64[ns] 2000-01-31 2000-02-29 ... 2029-12-31
```

Currently we can achieve this like:

```python
n_months = 3

monthly = da.groupby(""time.month"").mean()
padded = monthly.pad(month=n_months, mode=""wrap"")
rolled = padded.rolling(center=True, month=n_months).mean(skipna=False)
sliced = rolled.isel(month=slice(3, -3))

central_month = sliced.idxmax()
```

Implementing `pad_mode` in `rolling` would allow to do:

```python
monthly = da.groupby(""time.month"").mean()
rolled = monthly.rolling(center=True, month=n_months, pad_mode=""wrap"").mean(skipna=False)

central_month = rolled.idxmax()
```
","{""total_count"": 0, ""+1"": 0, ""-1"": 0, ""laugh"": 0, ""hooray"": 0, ""confused"": 0, ""heart"": 0, ""rocket"": 0, ""eyes"": 0}",,307783090
https://github.com/pydata/xarray/issues/2007#issuecomment-747500929,https://api.github.com/repos/pydata/xarray/issues/2007,747500929,MDEyOklzc3VlQ29tbWVudDc0NzUwMDkyOQ==,2448579,2020-12-17T15:16:06Z,2020-12-17T15:16:06Z,MEMBER,"I think we should do `pad_kwargs` so that `monthly.rolling(center-True, month=n_months, pad_kwargs=dict(mode=""constant"", constant_values=5)}` is possible.","{""total_count"": 1, ""+1"": 1, ""-1"": 0, ""laugh"": 0, ""hooray"": 0, ""confused"": 0, ""heart"": 0, ""rocket"": 0, ""eyes"": 0}",,307783090
https://github.com/pydata/xarray/issues/2007#issuecomment-499603340,https://api.github.com/repos/pydata/xarray/issues/2007,499603340,MDEyOklzc3VlQ29tbWVudDQ5OTYwMzM0MA==,1217238,2019-06-06T18:01:54Z,2019-06-06T18:01:54Z,MEMBER,"I think you may need to do cropping afterwards, too, before taking the mean.","{""total_count"": 0, ""+1"": 0, ""-1"": 0, ""laugh"": 0, ""hooray"": 0, ""confused"": 0, ""heart"": 0, ""rocket"": 0, ""eyes"": 0}",,307783090
https://github.com/pydata/xarray/issues/2007#issuecomment-499548285,https://api.github.com/repos/pydata/xarray/issues/2007,499548285,MDEyOklzc3VlQ29tbWVudDQ5OTU0ODI4NQ==,10194086,2019-06-06T15:36:58Z,2019-06-06T15:36:58Z,MEMBER,"I am coming back to @shoyer suggestion in #2011 - your idea would be to do first a `pad` and then a `rolling` operation as e.g.:

``` python

import numpy as np
import xarray as xr

x = np.arange(1, 366)
y = np.random.randn(365)
ds = xr.DataArray(y, dims=dict(dayofyear=x))

ds.pad(dayofyear=15, mode='wrap').rolling(center=True, dayofyear=31).mean()

```

","{""total_count"": 1, ""+1"": 1, ""-1"": 0, ""laugh"": 0, ""hooray"": 0, ""confused"": 0, ""heart"": 0, ""rocket"": 0, ""eyes"": 0}",,307783090
https://github.com/pydata/xarray/issues/2007#issuecomment-392070454,https://api.github.com/repos/pydata/xarray/issues/2007,392070454,MDEyOklzc3VlQ29tbWVudDM5MjA3MDQ1NA==,17162724,2018-05-25T14:11:20Z,2018-05-25T14:11:20Z,CONTRIBUTOR,"I was going to suggest this feature so glad others are interested.

In my use case I would like to smooth a daily climatology. My colleague uses matlab and uses https://www.mathworks.com/matlabcentral/fileexchange/52688-nan-tolerant-fast-smooth

Using the `slice` solution as @mathause showed above, it would look something like (using code from http://xarray.pydata.org/en/stable/examples/weather-data.html#toy-weather-data)

```
import numpy as np
import pandas as pd
import xarray as xr

times = pd.date_range('2000-01-01', '2010-12-31', name='time')
annual_cycle = np.sin(2 * np.pi * (times.dayofyear.values / 366 - 0.28))
noise = 15 * np.random.rand(annual_cycle.size)
data = 10 + (15 * annual_cycle) + noise
da = xr.DataArray(data, coords=[times], dims='time')
#da.plot()
#Check variability at one day
#da.groupby('time.dayofyear').std('time')[0]
da_clim = da.groupby('time.dayofyear').mean('time')
_da_clim = xr.concat([da_clim[-15:], da_clim, da_clim[:15]], 'dayofyear')
da_clim_smooth = _da_clim.rolling(dayofyear=31, center=True).mean().dropna('dayofyear')
#da_clim_smooth.plot()
```
","{""total_count"": 0, ""+1"": 0, ""-1"": 0, ""laugh"": 0, ""hooray"": 0, ""confused"": 0, ""heart"": 0, ""rocket"": 0, ""eyes"": 0}",,307783090
https://github.com/pydata/xarray/issues/2007#issuecomment-375850170,https://api.github.com/repos/pydata/xarray/issues/2007,375850170,MDEyOklzc3VlQ29tbWVudDM3NTg1MDE3MA==,5635139,2018-03-24T06:16:29Z,2018-03-24T06:16:29Z,MEMBER,"#2011 looks good - I didn't realize numpy already had `pad`

Agree with your other comments. Thanks as ever @fujiisoup ","{""total_count"": 1, ""+1"": 1, ""-1"": 0, ""laugh"": 0, ""hooray"": 0, ""confused"": 0, ""heart"": 0, ""rocket"": 0, ""eyes"": 0}",,307783090
https://github.com/pydata/xarray/issues/2007#issuecomment-375828864,https://api.github.com/repos/pydata/xarray/issues/2007,375828864,MDEyOklzc3VlQ29tbWVudDM3NTgyODg2NA==,6815844,2018-03-24T00:05:08Z,2018-03-24T00:05:08Z,MEMBER,"> I don't think the kwarg should be called fill_value - that traditionally has a specific meaning of ""the value to replace NaN with"". 

Agreed. [`dask.ghost`](http://dask.pydata.org/en/latest/array-ghost.html#boundaries) has `boundaries` keyword, for which we can choose between *periodic*, *reflect*, and any constant.
I think this would be a good reference.
Maybe we can deprecate `fill_value` keyword and replace it by `boundaries`?
(I slightly regret that I choose `fill_value` keyword in `construct`).

> How it's implemented - do you have a view here? 

Only a slight modification of `construct` machinery realizes this (see #2011).
I think this option should be available only in `construct` method (not in the traditional rolling constructor) for the sake of simplicity (according to this [comment](https://github.com/pydata/xarray/issues/2010#issuecomment-375750884)).","{""total_count"": 0, ""+1"": 0, ""-1"": 0, ""laugh"": 0, ""hooray"": 0, ""confused"": 0, ""heart"": 0, ""rocket"": 0, ""eyes"": 0}",,307783090
https://github.com/pydata/xarray/issues/2007#issuecomment-375810316,https://api.github.com/repos/pydata/xarray/issues/2007,375810316,MDEyOklzc3VlQ29tbWVudDM3NTgxMDMxNg==,5635139,2018-03-23T22:03:24Z,2018-03-23T22:03:24Z,MEMBER,"@fujiisoup Yes for sure - I think it would be good. I think there are two salient questions:
- Where this lives in the API: Should this be under `construct`? I don't think the kwarg should be called `fill_value` - that traditionally has a specific meaning of ""the value to replace `NaN` with"". I don't understand the `periodic` reference, but likely I'm missing something. Could be `wrap=True`, or `roll=True`?
- How it's implemented - do you have a view here? Can you use the `construct` machinery? Or we make a new array and run `rolling` over it?","{""total_count"": 0, ""+1"": 0, ""-1"": 0, ""laugh"": 0, ""hooray"": 0, ""confused"": 0, ""heart"": 0, ""rocket"": 0, ""eyes"": 0}",,307783090
https://github.com/pydata/xarray/issues/2007#issuecomment-375681041,https://api.github.com/repos/pydata/xarray/issues/2007,375681041,MDEyOklzc3VlQ29tbWVudDM3NTY4MTA0MQ==,6815844,2018-03-23T14:22:57Z,2018-03-23T14:22:57Z,MEMBER,"@maxim-lian , do you agree to add this feature?
Although the same behavior can be realized by adding head/tail values to the original array and truncate them after the computation, the `periodic` option would significantly simplify this.","{""total_count"": 0, ""+1"": 0, ""-1"": 0, ""laugh"": 0, ""hooray"": 0, ""confused"": 0, ""heart"": 0, ""rocket"": 0, ""eyes"": 0}",,307783090
https://github.com/pydata/xarray/issues/2007#issuecomment-375484121,https://api.github.com/repos/pydata/xarray/issues/2007,375484121,MDEyOklzc3VlQ29tbWVudDM3NTQ4NDEyMQ==,5635139,2018-03-22T22:56:09Z,2018-03-22T22:56:09Z,MEMBER,"Though I'm not sure you need the `construct` machinery. 

IIUC you need to copy a window-sized amount of data from the front of the array onto the back. 

You could do that with construct-like machinery, which would save a copy - though not a large copy","{""total_count"": 1, ""+1"": 1, ""-1"": 0, ""laugh"": 0, ""hooray"": 0, ""confused"": 0, ""heart"": 0, ""rocket"": 0, ""eyes"": 0}",,307783090
https://github.com/pydata/xarray/issues/2007#issuecomment-375476906,https://api.github.com/repos/pydata/xarray/issues/2007,375476906,MDEyOklzc3VlQ29tbWVudDM3NTQ3NjkwNg==,6815844,2018-03-22T22:22:26Z,2018-03-22T22:22:26Z,MEMBER,"I think the implementation would be not so difficult by supporting more flexible `fill_value` option in [`xr.DataArrayRolling.construct` method](http://xarray.pydata.org/en/stable/generated/xarray.core.rolling.DataArrayRolling.construct.html#xarray.core.rolling.DataArrayRolling.construct).

Maybe `fill_value='periodic'` would be a possible API,
```python
da.rolling(dayofyear=31).construct('window', fill_value='periodic').mean('window')
```

@mathause, any interest in contributing?","{""total_count"": 0, ""+1"": 0, ""-1"": 0, ""laugh"": 0, ""hooray"": 0, ""confused"": 0, ""heart"": 0, ""rocket"": 0, ""eyes"": 0}",,307783090
https://github.com/pydata/xarray/issues/2007#issuecomment-375455202,https://api.github.com/repos/pydata/xarray/issues/2007,375455202,MDEyOklzc3VlQ29tbWVudDM3NTQ1NTIwMg==,10194086,2018-03-22T20:57:59Z,2018-03-22T20:57:59Z,MEMBER,"I think what I want is like the `filter` [function in R](https://stat.ethz.ch/R-manual/R-devel/library/stats/html/filter.html) with `circular=True`.

I found two possibilities but they are quite ""hand made"" and certainly not very efficient

Solution with slicing:
``` python
# take the last and first elements and append/ prepend them
first = ds[:15]
last = ds[-15:]
extended = xr.concat([last, ds, first], 'dayofyear')
# do the rolling on the extended ds and get rid of NaNs
sol1 = extended.rolling(dayofyear=31, center=True).mean().dropna('dayofyear')
```

Solution with `roll`:
``` python
roll1 = ds.roll(dayofyear=150).rolling(dayofyear=31, center=True).mean()
roll2 = ds.rolling(dayofyear=31, center=True).mean()
sol2 = xr.concat([roll1, roll2], dim='r').mean('r')
```
Call `rolling` on original and `roll`ed dataset, and put them together again.","{""total_count"": 0, ""+1"": 0, ""-1"": 0, ""laugh"": 0, ""hooray"": 0, ""confused"": 0, ""heart"": 0, ""rocket"": 0, ""eyes"": 0}",,307783090
https://github.com/pydata/xarray/issues/2007#issuecomment-375445915,https://api.github.com/repos/pydata/xarray/issues/2007,375445915,MDEyOklzc3VlQ29tbWVudDM3NTQ0NTkxNQ==,10194086,2018-03-22T20:26:24Z,2018-03-22T20:27:59Z,MEMBER,"Probably a mix of both - I want to compute a moving average, but with periodic boundaries. `rolling` sets `window_length - 1` elements to nan. However I want to calculate these like so:

    running_mean_0 = xr.concat([ds[-15:], ds[:16]]).mean()
    running_mean_1 = xr.concat([ds[-14:], ds[:17]]).mean()

and so on...

","{""total_count"": 0, ""+1"": 0, ""-1"": 0, ""laugh"": 0, ""hooray"": 0, ""confused"": 0, ""heart"": 0, ""rocket"": 0, ""eyes"": 0}",,307783090
https://github.com/pydata/xarray/issues/2007#issuecomment-375441040,https://api.github.com/repos/pydata/xarray/issues/2007,375441040,MDEyOklzc3VlQ29tbWVudDM3NTQ0MTA0MA==,5635139,2018-03-22T20:09:54Z,2018-03-22T20:09:54Z,MEMBER,"> `ds.rolling(center=True, dayofyear=31).mean()`

What do you mean by `rolling` here? As a reduce operation over a rolling window, like a moving average (`rolling` in xarray)? Or rolling around the end of a dataarray when shifting (`roll` in xarray)? Or a mix of both?

Specifically, what's the `dayofyear=31` doing?","{""total_count"": 0, ""+1"": 0, ""-1"": 0, ""laugh"": 0, ""hooray"": 0, ""confused"": 0, ""heart"": 0, ""rocket"": 0, ""eyes"": 0}",,307783090
https://github.com/pydata/xarray/issues/2007#issuecomment-375431424,https://api.github.com/repos/pydata/xarray/issues/2007,375431424,MDEyOklzc3VlQ29tbWVudDM3NTQzMTQyNA==,1197350,2018-03-22T19:35:50Z,2018-03-22T19:35:50Z,MEMBER,"Very useful suggestion.

> Also I cannot really think of an easy way to append the first elements to the end of the dataset and then calculate rolling.

We already support a different type of ""rolling"" with periodicity
http://xarray.pydata.org/en/latest/generated/xarray.DataArray.roll.html?highlight=roll
and it is straightforward to apply roll operations at the variable level:
https://github.com/pydata/xarray/blob/master/xarray/core/variable.py#L1007-L1026

I suspect this would not be too hard to implement.
","{""total_count"": 0, ""+1"": 0, ""-1"": 0, ""laugh"": 0, ""hooray"": 0, ""confused"": 0, ""heart"": 0, ""rocket"": 0, ""eyes"": 0}",,307783090