Center rolling window for time offset

doc/source/user_guide/window.rst

@@ -157,6 +157,18 @@ By default the labels are set to the right edge of the window, but a
    s.rolling(window=5, center=True).mean()
 
 
+This can also be applied to datetime-like indices.
+.. versionadded:: 1.3
+.. ipython:: python
+
+    df = pd.DataFrame(
+        {"A": [0, 1, 2, 3, 4]}, index=pd.date_range("2020", periods=5, freq="1D")
+    )
+    df
+    df.rolling("2D", center=False).mean()
+    df.rolling("2D", center=True).mean()
+
+
 .. _window.endpoints:
 
 Rolling window endpoints

doc/source/whatsnew/v1.3.0.rst

@@ -134,6 +134,23 @@ a copy will no longer be made (:issue:`32960`)
 The default behavior when not passing ``copy`` will remain unchanged, i.e.
 a copy will be made.
 
+Centered Datetime-Like Rolling Windows
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+When performing rolling calculations on :class:`DataFrame` and :class:`Series`
+objects with a datetime-like index, a centered datetime-like window can now be
+used (:issue:`38780`).
+For example:
+
+.. ipython:: python
+
+    df = pd.DataFrame(
+        {"A": [0, 1, 2, 3, 4]}, index=pd.date_range("2020", periods=5, freq="1D")
+    )
+    df
+    df.rolling("2D", center=True).mean()
+
+
 .. _whatsnew_130.enhancements.other:
 
 Other enhancements

pandas/_libs/window/indexers.pyx

@@ -14,7 +14,7 @@ def calculate_variable_window_bounds(
     int64_t num_values,
     int64_t window_size,
     object min_periods,  # unused but here to match get_window_bounds signature
-    object center,  # unused but here to match get_window_bounds signature
+    bint center,
     object closed,
     const int64_t[:] index
 ):
@@ -32,8 +32,8 @@ def calculate_variable_window_bounds(
     min_periods : object
         ignored, exists for compatibility
 
-    center : object
-        ignored, exists for compatibility
+    center : bint
+        center the rolling window on the current observation
 
     closed : str
         string of side of the window that should be closed
@@ -46,7 +46,8 @@ def calculate_variable_window_bounds(
     (ndarray[int64], ndarray[int64])
     """
     cdef:
-        bint left_closed = False, right_closed = False
+        bint left_closed = False
+        bint right_closed = False
         ndarray[int64_t, ndim=1] start, end
         int64_t start_bound, end_bound, index_growth_sign = 1
         Py_ssize_t i, j
@@ -77,14 +78,27 @@ def calculate_variable_window_bounds(
     # right endpoint is open
     else:
         end[0] = 0
+    if center:
+        for j in range(0, num_values + 1):
+            if (index[j] == index[0] + index_growth_sign * window_size / 2 and
+               right_closed):
+                end[0] = j + 1
+                break
+            elif index[j] >= index[0] + index_growth_sign * window_size / 2:
+                end[0] = j
+                break
 
     with nogil:
 
         # start is start of slice interval (including)
         # end is end of slice interval (not including)
         for i in range(1, num_values):
-            end_bound = index[i]
-            start_bound = index[i] - index_growth_sign * window_size
+            if center:
+                end_bound = index[i] + index_growth_sign * window_size / 2
+                start_bound = index[i] - index_growth_sign * window_size / 2
+            else:
+                end_bound = index[i]
+                start_bound = index[i] - index_growth_sign * window_size
 
             # left endpoint is closed
             if left_closed:
@@ -98,14 +112,27 @@ def calculate_variable_window_bounds(
                     start[i] = j
                     break
 
+            # for centered window advance the end bound until we are
+            # outside the constraint
+            if center:
+                for j in range(end[i - 1], num_values + 1):
+                    if j == num_values:
+                        end[i] = j
+                    elif ((index[j] - end_bound) * index_growth_sign == 0 and
+                          right_closed):
+                        end[i] = j + 1
+                        break
+                    elif (index[j] - end_bound) * index_growth_sign >= 0:
+                        end[i] = j
+                        break
             # end bound is previous end
             # or current index
-            if (index[end[i - 1]] - end_bound) * index_growth_sign <= 0:
+            elif (index[end[i - 1]] - end_bound) * index_growth_sign <= 0:
                 end[i] = i + 1
             else:
                 end[i] = end[i - 1]
 
             # right endpoint is open
-            if not right_closed:
+            if not right_closed and not center:
                 end[i] -= 1
     return start, end

pandas/core/window/rolling.py

@@ -378,7 +378,9 @@ def _get_window_indexer(self) -> BaseIndexer:
             return self.window
         if self._win_freq_i8 is not None:
             return VariableWindowIndexer(
-                index_array=self._index_array, window_size=self._win_freq_i8
+                index_array=self._index_array,
+                window_size=self._win_freq_i8,
+                center=self.center,
             )
         return FixedWindowIndexer(window_size=self.window)
 
@@ -1470,13 +1472,6 @@ def validate(self):
 
             self._validate_monotonic()
 
-            # we don't allow center
-            if self.center:
-                raise NotImplementedError(
-                    "center is not implemented for "
-                    "datetimelike and offset based windows"
-                )
-
             # this will raise ValueError on non-fixed freqs
             try:
                 freq = to_offset(self.window)