issue_comments: 253681067

My opinion is that the nan has got to go. If we want to (1) maintain pandas-consistency and (2) use bottleneck without mucking it up, then I think we need to add some logic in either rolling.reduce() or rolling._center_result().

So here's my failed attempt:

``` def reverse_and_roll_1d(data, window_size, min_periods=1): """ Implements a concept to fix the end-of-array problem with xarray.core.rolling._center_shift(), by 1.) take slice of the back-end of the array 2.) flip it 3.) compute centered-window arithmetic 4.) flip it again 5.) replace back-end of default result with (4)

:param DataArray data: 1-D data array, with dim name 'x'.
:param int window_size: size of window.
"""
# first the default way to computing centered window
r = data.rolling(x=window_size, center=True, min_periods=min_periods)
avg = r.mean()
# now we need to fix the back-end of the array
rev_start = len(data.x) # an index
rev_end = len(data.x) - window_size - 1 \
                 if len(data.data) > window_size \
                else None  # another index
tail_slice = slice(rev_start, rev_end, -1) # back end of array, flipped
r2 = data[dict(x=tail_slice)].\
    rolling(x=window_size, center=True, min_periods=min_periods)
avg[dict(x=slice(-window_size+1, None))] = \
    r2.mean()[dict(x=slice(window_size-2, None, -1))] # replacement

return avg

```

This algorithm is consistently 8 times slower than pd.DataFrame.rolling(), for various 1d array sizes.

I'm open to ideas as well :)