Preserve step in RangeIndex.arange and slicing (#11362)

Co-authored-by: Deepak Cherian <dcherian@users.noreply.github.com>

Author: mokashang

doc/whats-new.rst

@@ -33,6 +33,12 @@ Bug Fixes
   a ``zarr_format=3`` store with ``use_zarr_fill_value_as_mask=False``, so it is no
   longer silently lost on round-trip (:issue:`10269`).
   By `Davis Bennett <https://github.com/d-v-b>`_.
+- :py:meth:`~xarray.indexes.RangeIndex.arange` now preserves the requested
+  ``step`` instead of silently re-deriving it from ``(stop - start) / size``, so
+  its values match :py:func:`numpy.arange` when ``step`` does not evenly divide
+  the interval. Strided slicing of a :py:class:`~xarray.indexes.RangeIndex` now
+  preserves the step as well (:issue:`11325`).
+  By `mokashang <https://github.com/mokashang>`_.
 - Fix :py:func:`decode_cf` failing on integer-encoded time arrays that contain
   NaT when running against numpy 2.5+.
   By `Ian Hunt-Isaak <https://github.com/ianhi>`_.

xarray/indexes/range_index.py

@@ -32,6 +32,7 @@ def __init__(
         coord_name: Hashable,
         dim: str,
         dtype: Any = None,
+        step: float | None = None,
     ):
         if dtype is None:
             dtype = np.dtype(np.float64)
@@ -40,7 +41,7 @@ def __init__(
 
         self.start = start
         self.stop = stop
-        self._step = None  # Will be calculated by property
+        self._step = step
 
     @property
     def coord_name(self) -> Hashable:
@@ -121,21 +122,23 @@ def slice(self, sl: slice) -> "RangeCoordinateTransform":
         new_range = range(self.size)[sl]
         new_size = len(new_range)
 
+        # A slice scales the spacing by its own step, e.g. ``[::2]`` doubles it.
+        # Preserve the exact resulting step instead of letting it be re-derived
+        # from ``(stop - start) / size``, which would be wrong whenever the
+        # spacing does not evenly divide the interval. See GH11325.
+        new_step = self.step * new_range.step
         new_start = self.start + new_range.start * self.step
-        new_stop = self.start + new_range.stop * self.step
+        new_stop = new_start + new_size * new_step
 
-        result = type(self)(
+        return type(self)(
             new_start,
             new_stop,
             new_size,
             self.coord_name,
             self.dim,
             dtype=self.dtype,
+            step=new_step,
         )
-        if new_size == 0:
-            # For empty slices, preserve step from parent
-            result._step = self.step
-        return result
 
 
 class RangeIndex(CoordinateTransformIndex):
@@ -278,8 +281,13 @@ def arange(
 
         size = math.ceil((stop - start) / step)
 
+        # Snap ``stop`` to ``start + size * step`` and keep the exact ``step`` so
+        # that the materialized values match ``numpy.arange`` even when ``step``
+        # does not evenly divide ``stop - start``. See GH11325.
+        stop = start + size * step
+        # Snap `stop` to `start + size * step`
         transform = RangeCoordinateTransform(
-            start, stop, size, coord_name, dim, dtype=dtype
+            start, stop, size, coord_name, dim, dtype=dtype, step=step
         )
 
         return cls(transform)

xarray/tests/test_range_index.py

@@ -64,6 +64,19 @@ def test_range_index_arange_properties() -> None:
     assert index.step == 0.1
 
 
+def test_range_index_arange_step_not_dividing_interval() -> None:
+    # GH11325: when ``step`` does not evenly divide ``stop - start`` the
+    # requested step must still be honored and the materialized values must
+    # match ``numpy.arange`` (previously the step was silently re-derived from
+    # ``(stop - start) / size``, e.g. 0.25 instead of the requested 0.3).
+    index = RangeIndex.arange(0.0, 1.0, 0.3, dim="x")
+    assert index.step == 0.3
+    assert index.size == 4
+    actual = xr.Coordinates.from_xindex(index)
+    expected = xr.Coordinates({"x": np.arange(0.0, 1.0, 0.3)})
+    assert_equal(actual, expected, check_default_indexes=False)
+
+
 def test_range_index_linspace() -> None:
     index = RangeIndex.linspace(0.0, 1.0, num=10, endpoint=False, dim="x")
     actual = xr.Coordinates.from_xindex(index)
@@ -141,7 +154,8 @@ def test_range_index_isel() -> None:
     ds2 = create_dataset_arange(0.0, 3.0, 0.1)
     actual = ds2.isel(x=slice(4, None, 3))
     expected = create_dataset_arange(0.4, 3.0, 0.3)
-    assert_identical(actual, expected, check_default_indexes=False, check_indexes=True)
+    assert actual.xindexes["x"].equals(expected.xindexes["x"])
+    np.testing.assert_allclose(actual["x"].values, np.arange(0.0, 3.0, 0.1)[4::3])
 
     # scalar
     actual = ds.isel(x=0)
@@ -372,11 +386,8 @@ def test_range_index_equals_exact() -> None:
     # Create an index directly
     index1 = RangeIndex.arange(0.0, 0.3, 0.1, dim="x")
 
-    # Create the same index by slicing - this accumulates floating point error
-    index_large = RangeIndex.arange(0.0, 1.0, 0.1, dim="x")
-    ds_large = xr.Dataset(coords=xr.Coordinates.from_xindex(index_large))
-    ds_sliced = ds_large.isel(x=slice(3))
-    index2 = ds_sliced.xindexes["x"]
+    # Create an index whose start differs by a tiny floating point amount
+    index2 = RangeIndex.arange(1e-12, 0.3 + 1e-12, 0.1, dim="x")
 
     # Default (exact=False) should be equal due to np.isclose tolerance
     assert index1.equals(index2)