Add RangeIndex

xarray/indexes/range_index.py

@@ -116,24 +116,45 @@ def __init__(self, transform: RangeCoordinateTransform):
     @classmethod
     def arange(
         cls,
-        start: float = 0.0,
-        stop: float = 1.0,
-        step: float = 1.0,
+        start: float | None = None,
+        stop: float | None = None,
+        step: float | None = None,
         *,
         coord_name: Hashable | None = None,
         dim: str,
         dtype: Any = None,
     ) -> "RangeIndex":
         """Create a new RangeIndex from given start, stop and step values.
 
+        ``RangeIndex.arange`` can be called with a varying number of positional arguments:
+
+        - ``RangeIndex.arange(stop)``: the index is within the half-open interval [0, stop)
+          (in other words, the interval including start but excluding stop).
+
+        - ``RangeIndex.arange(start, stop)``: the index is within the half-open interval
+          [start, stop).
+
+        - ``RangeIndex.arange(start, stop, step)``: the index is within the half-open interval
+          [start, stop), with spacing between values given by step.
+
+        .. note::
+           When using a non-integer step, such as 0.1, it is often better to use
+           :py:meth:`~xarray.indexes.RangeIndex.linspace`.
+
+        .. note::
+           ``RangeIndex.arange(start=4.0)`` returns a range index in the [0.0, 4.0)
+           interval, i.e., ``start`` is interpreted as ``stop`` even when it is given
+           as a unique keyword argument.
+
         Parameters
         ----------
         start : float, optional
-            Start of interval (default: 0.0). The interval includes this value.
-        stop : float, optional
-            End of interval (default: 1.0). In general the interval does not
-            include this value, except floating point round-off affects the
-            size of the dimension.
+            Start of interval. The interval includes this value. The default start
+            value is 0. If ``stop`` is not given, the value given here is interpreted
+            as the end of the interval.
+        stop : float
+            End of interval. In general the interval does not include this value,
+            except floating point round-off affects the size of the dimension.
         step : float, optional
             Spacing between values (default: 1.0).
         coord_name : Hashable, optional
@@ -163,6 +184,18 @@ def arange(
             x        RangeIndex (start=0, stop=1, step=0.2)
 
         """
+        if stop is None:
+            if start is None:
+                raise TypeError("RangeIndex.arange() requires stop to be specified")
+            else:
+                stop = start
+                start = None
+        if start is None:
+            start = 0.0
+
+        if step is None:
+            step = 1.0
+
         if coord_name is None:
             coord_name = dim
 

xarray/tests/test_range_index.py

@@ -14,11 +14,51 @@ def create_dataset_arange(
     return xr.Dataset(coords=xr.Coordinates.from_xindex(index))
 
 
-def test_range_index_arange() -> None:
-    index = RangeIndex.arange(0.0, 1.0, 0.1, dim="x")
+@pytest.mark.parametrize(
+    "args,kwargs",
+    [
+        ((10.0,), {}),
+        ((), {"stop": 10.0}),
+        (
+            (
+                2.0,
+                10.0,
+            ),
+            {},
+        ),
+        ((2.0,), {"stop": 10.0}),
+        ((), {"start": 2.0, "stop": 10.0}),
+        ((2.0, 10.0, 2.0), {}),
+        ((), {"start": 2.0, "stop": 10.0, "step": 2.0}),
+    ],
+)
+def test_range_index_arange(args, kwargs) -> None:
+    index = RangeIndex.arange(*args, **kwargs, dim="x")
+    actual = xr.Coordinates.from_xindex(index)
+    expected = xr.Coordinates({"x": np.arange(*args, **kwargs)})
+    assert_equal(actual, expected, check_default_indexes=False)
+
+
+def test_range_index_arange_error() -> None:
+    with pytest.raises(TypeError, match=".*requires stop to be specified"):
+        RangeIndex.arange(dim="x")
+
+
+def test_range_index_arange_start_as_stop() -> None:
+    # Weird although probably very unlikely case where only `start` is given
+    # as keyword argument, which is interpreted as `stop`.
+    # This has been fixed in numpy (https://github.com/numpy/numpy/pull/17878)
+    # using Python C API. In pure Python it's more tricky as there's no easy way to know
+    # whether a value has been passed as positional or keyword argument.
+    # Note: `pandas.RangeIndex` constructor still has this weird behavior.
+    index = RangeIndex.arange(start=10.0, dim="x")
     actual = xr.Coordinates.from_xindex(index)
-    expected = xr.Coordinates({"x": np.arange(0.0, 1.0, 0.1)})
+    expected = xr.Coordinates({"x": np.arange(10.0)})
     assert_equal(actual, expected, check_default_indexes=False)
+
+
+def test_range_index_arange_properties() -> None:
+    index = RangeIndex.arange(0.0, 1.0, 0.1, dim="x")
     assert index.start == 0.0
     assert index.stop == 1.0
     assert index.step == 0.1