Use American spelling

Author: asmeurer

array_api_tests/shape_helpers.py

@@ -8,7 +8,7 @@
 
 __all__ = [
     "broadcast_shapes",
-    "normalise_axis",
+    "normalize_axis",
     "ndindex",
     "axis_ndindex",
     "axes_ndindex",
@@ -65,7 +65,7 @@ def broadcast_shapes(*shapes: Shape):
     return result
 
 
-def normalise_axis(
+def normalize_axis(
     axis: Optional[Union[int, Sequence[int]]], ndim: int
 ) -> Tuple[int, ...]:
     if axis is None:

array_api_tests/test_array_object.py

@@ -26,9 +26,9 @@ def scalar_objects(
     )
 
 
-def normalise_key(key: Index, shape: Shape) -> Tuple[Union[int, slice], ...]:
+def normalize_key(key: Index, shape: Shape) -> Tuple[Union[int, slice], ...]:
     """
-    Normalise an indexing key.
+    Normalize an indexing key.
 
     * If a non-tuple index, wrap as a tuple.
     * Represent ellipsis as equivalent slices.
@@ -48,7 +48,7 @@ def get_indexed_axes_and_out_shape(
     key: Tuple[Union[int, slice, None], ...], shape: Shape
 ) -> Tuple[Tuple[Sequence[int], ...], Shape]:
     """
-    From the (normalised) key and input shape, calculates:
+    From the (normalized) key and input shape, calculates:
 
     * indexed_axes: For each dimension, the axes which the key indexes.
     * out_shape: The resulting shape of indexing an array (of the input shape)
@@ -88,7 +88,7 @@ def test_getitem(shape, dtype, data):
     out = x[key]
 
     ph.assert_dtype("__getitem__", in_dtype=x.dtype, out_dtype=out.dtype)
-    _key = normalise_key(key, shape)
+    _key = normalize_key(key, shape)
     axes_indices, expected_shape = get_indexed_axes_and_out_shape(_key, shape)
     ph.assert_shape("__getitem__", out_shape=out.shape, expected=expected_shape)
     out_zero_sided = any(side == 0 for side in expected_shape)
@@ -119,7 +119,7 @@ def test_setitem(shape, dtypes, data):
         x = xp.asarray(obj, dtype=dtypes.result_dtype)
     note(f"{x=}")
     key = data.draw(xps.indices(shape=shape), label="key")
-    _key = normalise_key(key, shape)
+    _key = normalize_key(key, shape)
     axes_indices, out_shape = get_indexed_axes_and_out_shape(_key, shape)
     value_strat = hh.arrays(dtype=dtypes.result_dtype, shape=out_shape)
     if out_shape == ():

array_api_tests/test_fft.py

@@ -94,7 +94,7 @@ def assert_s_axes_shape(
     axes: Optional[List[int]],
     out: Array,
 ):
-    _axes = sh.normalise_axis(axes, x.ndim)
+    _axes = sh.normalize_axis(axes, x.ndim)
     _s = x.shape if s is None else s
     expected = []
     for i in range(x.ndim):
@@ -193,7 +193,7 @@ def test_rfftn(x, data):
 
     ph.assert_float_to_complex_dtype("rfftn", in_dtype=x.dtype, out_dtype=out.dtype)
 
-    _axes = sh.normalise_axis(axes, x.ndim)
+    _axes = sh.normalize_axis(axes, x.ndim)
     _s = x.shape if s is None else s
     expected = []
     for i in range(x.ndim):
@@ -225,7 +225,7 @@ def test_irfftn(x, data):
     )
 
     # TODO: assert shape correctly
-    # _axes = sh.normalise_axis(axes, x.ndim)
+    # _axes = sh.normalize_axis(axes, x.ndim)
     # _s = x.shape if s is None else s
     # expected = []
     # for i in range(x.ndim):

array_api_tests/test_linalg.py

@@ -980,7 +980,7 @@ def test_vector_norm(x, data):
     # TODO: Check that the ord values give the correct norms.
     # ord = kw.get('ord', 2)
 
-    _axes = sh.normalise_axis(axis, x.ndim)
+    _axes = sh.normalize_axis(axis, x.ndim)
 
     ph.assert_keepdimable_shape('linalg.vector_norm', out_shape=res.shape,
                                 in_shape=x.shape, axes=_axes,

array_api_tests/test_manipulation_functions.py

@@ -190,7 +190,7 @@ def test_squeeze(x, data):
     )
 
     axes = (axis,) if isinstance(axis, int) else axis
-    axes = sh.normalise_axis(axes, x.ndim)
+    axes = sh.normalize_axis(axes, x.ndim)
 
     squeezable_axes = [i for i, side in enumerate(x.shape) if side == 1]
     if any(i not in squeezable_axes for i in axes):
@@ -230,7 +230,7 @@ def test_flip(x, data):
 
     ph.assert_dtype("flip", in_dtype=x.dtype, out_dtype=out.dtype)
 
-    _axes = sh.normalise_axis(kw.get("axis", None), x.ndim)
+    _axes = sh.normalize_axis(kw.get("axis", None), x.ndim)
     for indices in sh.axes_ndindex(x.shape, _axes):
         reverse_indices = indices[::-1]
         assert_array_ndindex("flip", x, x_indices=indices, out=out,
@@ -360,7 +360,7 @@ def test_roll(x, data):
         assert_array_ndindex("roll", x, x_indices=indices, out=out, out_indices=shifted_indices, kw=kw)
     else:
         shifts = (shift,) if isinstance(shift, int) else shift
-        axes = sh.normalise_axis(kw["axis"], x.ndim)
+        axes = sh.normalize_axis(kw["axis"], x.ndim)
         shifted_indices = roll_ndindex(x.shape, shifts, axes)
         assert_array_ndindex("roll", x, x_indices=sh.ndindex(x.shape), out=out, out_indices=shifted_indices, kw=kw)
 

array_api_tests/test_searching_functions.py

@@ -36,7 +36,7 @@ def test_argmax(x, data):
     out = xp.argmax(x, **kw)
 
     ph.assert_default_index("argmax", out.dtype)
-    axes = sh.normalise_axis(kw.get("axis", None), x.ndim)
+    axes = sh.normalize_axis(kw.get("axis", None), x.ndim)
     ph.assert_keepdimable_shape(
         "argmax", in_shape=x.shape, out_shape=out.shape, axes=axes, keepdims=keepdims, kw=kw
     )
@@ -73,7 +73,7 @@ def test_argmin(x, data):
     out = xp.argmin(x, **kw)
 
     ph.assert_default_index("argmin", out.dtype)
-    axes = sh.normalise_axis(kw.get("axis", None), x.ndim)
+    axes = sh.normalize_axis(kw.get("axis", None), x.ndim)
     ph.assert_keepdimable_shape(
         "argmin", in_shape=x.shape, out_shape=out.shape, axes=axes, keepdims=keepdims, kw=kw
     )

array_api_tests/test_sorting_functions.py

@@ -56,7 +56,7 @@ def test_argsort(x, data):
     ph.assert_default_index("argsort", out.dtype)
     ph.assert_shape("argsort", out_shape=out.shape, expected=x.shape, kw=kw)
     axis = kw.get("axis", -1)
-    axes = sh.normalise_axis(axis, x.ndim)
+    axes = sh.normalize_axis(axis, x.ndim)
     scalar_type = dh.get_scalar_type(x.dtype)
     for indices in sh.axes_ndindex(x.shape, axes):
         elements = [scalar_type(x[idx]) for idx in indices]
@@ -117,7 +117,7 @@ def test_sort(x, data):
     ph.assert_dtype("sort", out_dtype=out.dtype, in_dtype=x.dtype)
     ph.assert_shape("sort", out_shape=out.shape, expected=x.shape, kw=kw)
     axis = kw.get("axis", -1)
-    axes = sh.normalise_axis(axis, x.ndim)
+    axes = sh.normalize_axis(axis, x.ndim)
     scalar_type = dh.get_scalar_type(x.dtype)
     for indices in sh.axes_ndindex(x.shape, axes):
         elements = [scalar_type(x[idx]) for idx in indices]

array_api_tests/test_statistical_functions.py

@@ -28,7 +28,7 @@ def test_cumulative_sum(x, data):
     if x.ndim == 1:
         axes = axes | st.none()
     axis = data.draw(axes, label='axis')
-    _axis, = sh.normalise_axis(axis, x.ndim)
+    _axis, = sh.normalize_axis(axis, x.ndim)
     dtype = data.draw(kwarg_dtypes(x.dtype))
     include_initial = data.draw(st.booleans(), label="include_initial")
 
@@ -108,7 +108,7 @@ def test_max(x, data):
     out = xp.max(x, **kw)
 
     ph.assert_dtype("max", in_dtype=x.dtype, out_dtype=out.dtype)
-    _axes = sh.normalise_axis(kw.get("axis", None), x.ndim)
+    _axes = sh.normalize_axis(kw.get("axis", None), x.ndim)
     ph.assert_keepdimable_shape(
         "max", in_shape=x.shape, out_shape=out.shape, axes=_axes, keepdims=keepdims, kw=kw
     )
@@ -138,7 +138,7 @@ def test_mean(x, data):
     out = xp.mean(x, **kw)
 
     ph.assert_dtype("mean", in_dtype=x.dtype, out_dtype=out.dtype)
-    _axes = sh.normalise_axis(kw.get("axis", None), x.ndim)
+    _axes = sh.normalize_axis(kw.get("axis", None), x.ndim)
     ph.assert_keepdimable_shape(
         "mean", in_shape=x.shape, out_shape=out.shape, axes=_axes, keepdims=keepdims, kw=kw
     )
@@ -161,7 +161,7 @@ def test_min(x, data):
     out = xp.min(x, **kw)
 
     ph.assert_dtype("min", in_dtype=x.dtype, out_dtype=out.dtype)
-    _axes = sh.normalise_axis(kw.get("axis", None), x.ndim)
+    _axes = sh.normalize_axis(kw.get("axis", None), x.ndim)
     ph.assert_keepdimable_shape(
         "min", in_shape=x.shape, out_shape=out.shape, axes=_axes, keepdims=keepdims, kw=kw
     )
@@ -209,7 +209,7 @@ def test_prod(x, data):
             assert dh.is_int_dtype(out.dtype)  # sanity check
     else:
         ph.assert_dtype("prod", in_dtype=x.dtype, out_dtype=out.dtype, expected=expected_dtype)
-    _axes = sh.normalise_axis(kw.get("axis", None), x.ndim)
+    _axes = sh.normalize_axis(kw.get("axis", None), x.ndim)
     ph.assert_keepdimable_shape(
         "prod", in_shape=x.shape, out_shape=out.shape, axes=_axes, keepdims=keepdims, kw=kw
     )
@@ -239,7 +239,7 @@ def test_prod(x, data):
 )
 def test_std(x, data):
     axis = data.draw(hh.axes(x.ndim), label="axis")
-    _axes = sh.normalise_axis(axis, x.ndim)
+    _axes = sh.normalize_axis(axis, x.ndim)
     N = sum(side for axis, side in enumerate(x.shape) if axis not in _axes)
     correction = data.draw(
         st.floats(0.0, N, allow_infinity=False, allow_nan=False) | st.integers(0, N),
@@ -298,7 +298,7 @@ def test_sum(x, data):
             assert dh.is_int_dtype(out.dtype)  # sanity check
     else:
         ph.assert_dtype("sum", in_dtype=x.dtype, out_dtype=out.dtype, expected=expected_dtype)
-    _axes = sh.normalise_axis(kw.get("axis", None), x.ndim)
+    _axes = sh.normalize_axis(kw.get("axis", None), x.ndim)
     ph.assert_keepdimable_shape(
         "sum", in_shape=x.shape, out_shape=out.shape, axes=_axes, keepdims=keepdims, kw=kw
     )
@@ -329,7 +329,7 @@ def test_sum(x, data):
 )
 def test_var(x, data):
     axis = data.draw(hh.axes(x.ndim), label="axis")
-    _axes = sh.normalise_axis(axis, x.ndim)
+    _axes = sh.normalize_axis(axis, x.ndim)
     N = sum(side for axis, side in enumerate(x.shape) if axis not in _axes)
     correction = data.draw(
         st.floats(0.0, N, allow_infinity=False, allow_nan=False) | st.integers(0, N),

array_api_tests/test_utility_functions.py

@@ -21,7 +21,7 @@ def test_all(x, data):
     out = xp.all(x, **kw)
 
     ph.assert_dtype("all", in_dtype=x.dtype, out_dtype=out.dtype, expected=xp.bool)
-    _axes = sh.normalise_axis(kw.get("axis", None), x.ndim)
+    _axes = sh.normalize_axis(kw.get("axis", None), x.ndim)
     ph.assert_keepdimable_shape(
         "all", in_shape=x.shape, out_shape=out.shape, axes=_axes, keepdims=keepdims, kw=kw
     )
@@ -49,7 +49,7 @@ def test_any(x, data):
     out = xp.any(x, **kw)
 
     ph.assert_dtype("any", in_dtype=x.dtype, out_dtype=out.dtype, expected=xp.bool)
-    _axes = sh.normalise_axis(kw.get("axis", None), x.ndim)
+    _axes = sh.normalize_axis(kw.get("axis", None), x.ndim)
     ph.assert_keepdimable_shape(
         "any", in_shape=x.shape, out_shape=out.shape, axes=_axes, keepdims=keepdims, kw=kw,
     )