issue_comments

Let me exhaust a few other ideas first. I'll definitely share my thoughts here first before making any commit. Thanks.

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 :)