fix: changelog and tests

Author: jharlow-intel

CHANGELOG.md

@@ -14,7 +14,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * Pinned Cython in the Coverity Scan workflow so generated code stays stable between scans, and added `coverity/README.md` documenting the known false-positive families and the scan review checklist [gh-374](https://github.com/IntelPython/mkl_fft/pull/374)
 
 ### Fixed
-* Fixed `norm="forward"`/`"ortho"` scaling in `fftn`, `ifftn`, `rfftn`, `irfftn` and the `fft2` family when only a subset of axes is transformed: the scale used the full array shape instead of the transformed axes. The `numpy_fft` and `scipy_fft` interfaces were unaffected [gh-370](https://github.com/IntelPython/mkl_fft/pull/370)
+* Fixed `norm="forward"`/`"ortho"` scaling in `fftn`, `ifftn`, `rfftn`, `irfftn` and the `fft2` family when only a subset of axes is transformed: the scale used the full array shape instead of the transformed axes [gh-336](https://github.com/IntelPython/mkl_fft/issues/336), [gh-370](https://github.com/IntelPython/mkl_fft/pull/370)
 * Fixed `norm="forward"`/`"ortho"` scaling in `irfftn` and `irfft2`, which normalized over the input length `n` rather than the complex-to-real output length `2 * (n - 1)` [gh-370](https://github.com/IntelPython/mkl_fft/pull/370)
 * Declared `f_ndim` as a C `int` in `_allocate_result` so the buffer size is computed in C rather than through a Python object, resolving a Coverity out-of-bounds (OVERRUN) false positive [gh-364](https://github.com/IntelPython/mkl_fft/pull/364)
 * Silenced a Coverity `UNUSED_VALUE` finding in `__create_descriptor_1d` by marking the `DftiFreeDescriptor` status (used only by a debug-only `assert`) as intentionally unused [gh-365](https://github.com/IntelPython/mkl_fft/pull/365)

mkl_fft/tests/test_dispatch_equivalence.py

@@ -59,10 +59,20 @@
 _SHAPE_4D = (4, 5, 6, 7)
 
 _DTYPES = ["float32", "float64", "complex64", "complex128"]
-_REAL_DTYPES = ["float32", "float64"]
 
 _ORDERS = ["C", "F", "non-contiguous"]
 
+
+def _cases(funcs, dtypes=_DTYPES):
+    """(func, dtype) pairs, dropping the real-input transforms on complex."""
+    return [
+        (f, dt)
+        for f in funcs
+        for dt in dtypes
+        if not (f.startswith("rfft") and np.dtype(dt).kind == "c")
+    ]
+
+
 # Relative tolerance by input precision. Single-precision transforms of
 # random data over these lengths stay well inside 2e-5.
 _TOL = {
@@ -72,10 +82,22 @@
     "complex128": 1e-12,
 }
 
-# every non-empty subset of the axes of a 3-D array, plus None
-_AXES_3D = [
-    ax for n in (1, 2, 3) for ax in itertools.combinations(range(3), n)
-] + [None]
+_NEG_AXES_3D = [
+    (-1,),  # last axis
+    (-2,),  # middle axis: per-vector path in the C backend
+    (-3,),  # first axis
+    (-2, -1),  # the fft2 default
+    (-3, -1),
+    (-1, -2),  # reversed: picks a different last axis for r2c
+    (0, -1),  # mixed sign
+    (-3, -2, -1),
+]
+
+_AXES_3D = (
+    [ax for n in (1, 2, 3) for ax in itertools.combinations(range(3), n)]
+    + _NEG_AXES_3D
+    + [None]  # every axis
+)
 
 
 def _make(shape, dtype, seed=42):
@@ -122,13 +144,10 @@ def test_fftn_axes_subset(func, dtype, axes, order):
     _check(got, want, dtype)
 
 
-@pytest.mark.parametrize("func", ["rfftn", "irfftn"])
-@pytest.mark.parametrize("dtype", _DTYPES)
+@pytest.mark.parametrize("func,dtype", _cases(["rfftn", "irfftn"]))
 @pytest.mark.parametrize("axes", _AXES_3D)
 @pytest.mark.parametrize("order", _ORDERS)
 def test_rfftn_axes_subset(func, dtype, axes, order):
-    if func == "rfftn" and dtype not in _REAL_DTYPES:
-        pytest.skip("rfftn takes real input")
     x = _relayout(_make(_SHAPE_3D, dtype), order)
     got = getattr(mkl_fft, func)(x, axes=axes)
     want = getattr(np.fft, func)(x, axes=axes)
@@ -151,29 +170,25 @@ def test_fft_axis_3d(func, dtype, axis, order):
     _check(got, want, dtype)
 
 
-@pytest.mark.parametrize("func", ["fft", "ifft", "rfft"])
-@pytest.mark.parametrize("dtype", ["float64", "complex128"])
+@pytest.mark.parametrize(
+    "func,dtype", _cases(["fft", "ifft", "rfft"], ["float64", "complex128"])
+)
 @pytest.mark.parametrize("axis", range(len(_SHAPE_4D)))
 @pytest.mark.parametrize("order", _ORDERS)
 def test_fft_axis_4d(func, dtype, axis, order):
     """A rank-4 array has two interior axes, so the per-vector fallback in the
     C backend is exercised twice within one sweep.
     """
-    if func == "rfft" and dtype != "float64":
-        pytest.skip("rfft takes real input")
     x = _relayout(_make(_SHAPE_4D, dtype), order)
     got = getattr(mkl_fft, func)(x, axis=axis)
     want = getattr(np.fft, func)(x, axis=axis)
     _check(got, want, dtype)
 
 
-@pytest.mark.parametrize("func", ["rfft", "irfft"])
-@pytest.mark.parametrize("dtype", _DTYPES)
+@pytest.mark.parametrize("func,dtype", _cases(["rfft", "irfft"]))
 @pytest.mark.parametrize("axis", range(len(_SHAPE_3D)))
 @pytest.mark.parametrize("order", _ORDERS)
 def test_rfft_axis_3d(func, dtype, axis, order):
-    if func == "rfft" and dtype not in _REAL_DTYPES:
-        pytest.skip("rfft takes real input")
     x = _relayout(_make(_SHAPE_3D, dtype), order)
     got = getattr(mkl_fft, func)(x, axis=axis)
     want = getattr(np.fft, func)(x, axis=axis)
@@ -226,7 +241,7 @@ def test_ortho_roundtrip_is_identity(shape, axes):
 
 @pytest.mark.parametrize("func", ["fftn", "ifftn"])
 @pytest.mark.parametrize("dtype", ["float64", "complex128"])
-@pytest.mark.parametrize("axes", [(0,), (1,), (2,), (1, 2), None])
+@pytest.mark.parametrize("axes", _AXES_3D)
 @pytest.mark.parametrize("norm", [None, "backward", "forward", "ortho"])
 def test_fftn_axes_subset_norm(func, dtype, axes, norm):
     x = _make(_SHAPE_3D, dtype)
@@ -235,37 +250,24 @@ def test_fftn_axes_subset_norm(func, dtype, axes, norm):
     _check(got, want, dtype)
 
 
-@pytest.mark.parametrize("func", ["rfftn", "irfftn"])
-@pytest.mark.parametrize("dtype", ["float64", "complex128"])
-@pytest.mark.parametrize("axes", [(0,), (1,), (2,), (1, 2), None])
+@pytest.mark.parametrize(
+    "func,dtype", _cases(["rfftn", "irfftn"], ["float64", "complex128"])
+)
+@pytest.mark.parametrize("axes", _AXES_3D)
 @pytest.mark.parametrize("norm", [None, "backward", "forward", "ortho"])
 def test_rfftn_axes_subset_norm(func, dtype, axes, norm):
     """Includes ``axes=None``: for c2r the scale basis is the *output* length
     along the last transformed axis, so a full-axes irfftn is normalized over
     ``2 * (n - 1)`` rather than ``n``.
     """
-    if func == "rfftn" and dtype != "float64":
-        pytest.skip("rfftn takes real input")
     x = _make(_SHAPE_3D, dtype)
     got = getattr(mkl_fft, func)(x, axes=axes, norm=norm)
     want = getattr(np.fft, func)(x, axes=axes, norm=norm)
     _check(got, want, dtype)
 
 
-@pytest.mark.parametrize("func", ["fftn", "ifftn", "fft2", "ifft2"])
-@pytest.mark.parametrize("dtype", ["float64", "complex128"])
-@pytest.mark.parametrize("norm", [None, "backward", "forward", "ortho"])
-def test_empty_axes_is_identity(func, dtype, norm):
-    """``axes=()`` transforms nothing, so the scale is 1.0 under every norm and
-    the input comes back untouched, as it does from NumPy.
-    """
-    x = _make(_SHAPE_3D, dtype)
-    got = getattr(mkl_fft, func)(x, axes=(), norm=norm)
-    want = getattr(np.fft, func)(x, axes=(), norm=norm)
-    _check(got, want, dtype)
-    assert got is x, "no axes transformed, so the input should be returned"
-
-
+# c2c axes=() is covered by test_fftnd.py::test_empty_axes and
+# ::test_empty_axes_returns_same_object; only the r2c family is missing there.
 @pytest.mark.parametrize("func", ["rfftn", "irfftn"])
 @pytest.mark.parametrize("norm", [None, "forward", "ortho"])
 def test_empty_axes_r2c_raises_like_numpy(func, norm):
@@ -279,15 +281,15 @@ def test_empty_axes_r2c_raises_like_numpy(func, norm):
         getattr(mkl_fft, func)(x, axes=(), norm=norm)
 
 
-@pytest.mark.parametrize("func", ["fft2", "ifft2", "rfft2", "irfft2"])
-@pytest.mark.parametrize("dtype", ["float64", "complex128"])
+@pytest.mark.parametrize(
+    "func,dtype",
+    _cases(["fft2", "ifft2", "rfft2", "irfft2"], ["float64", "complex128"]),
+)
 @pytest.mark.parametrize("norm", [None, "backward", "forward", "ortho"])
 def test_fft2_on_3d_norm(func, dtype, norm):
     """``fft2`` on a rank-3 array transforms 2 of 3 axes, so it is a subset
     transform even though the caller passed no ``axes``.
     """
-    if func == "rfft2" and dtype != "float64":
-        pytest.skip("rfft2 takes real input")
     x = _make(_SHAPE_3D, dtype)
     got = getattr(mkl_fft, func)(x, norm=norm)
     want = getattr(np.fft, func)(x, norm=norm)
@@ -420,3 +422,51 @@ def test_rfftn_shape_arg_with_norm(axes, s, norm):
     got = mkl_fft.rfftn(x, s=s, axes=axes, norm=norm)
     want = np.fft.rfftn(x, s=s, axes=axes, norm=norm)
     _check(got, want, "float64")
+
+
+_R2C_AXES_S = [
+    ((2,), (20,)),
+    ((2,), (10,)),
+    ((1, 2), (5, 20)),
+    ((0, 2), (10, 24)),
+    ((-1,), (20,)),
+    ((-2, -1), (5, 20)),
+]
+
+_C2C_AXES_S = [
+    ((0,), (16,)),
+    ((0,), (4,)),
+    ((1, 2), (10, 20)),
+    ((0, 1, 2), (16, 4, 20)),
+]
+
+
+@pytest.mark.parametrize("func", ["rfftn", "irfftn"])
+@pytest.mark.parametrize("axes,s", _R2C_AXES_S)
+@pytest.mark.parametrize("norm", ["forward", "ortho"])
+def test_r2c_axes_subset_s_and_norm(func, axes, s, norm):
+    dtype = "float64" if func == "rfftn" else "complex128"
+    x = _make(_SHAPE_3D, dtype)
+    got = getattr(mkl_fft, func)(x, s=s, axes=axes, norm=norm)
+    want = getattr(np.fft, func)(x, s=s, axes=axes, norm=norm)
+    _check(got, want, dtype)
+
+
+@pytest.mark.parametrize("func", ["fftn", "ifftn"])
+@pytest.mark.parametrize("axes,s", _C2C_AXES_S)
+@pytest.mark.parametrize("norm", ["forward", "ortho"])
+def test_out_with_s_and_norm(func, axes, s, norm):
+    x = _make(_SHAPE_3D, "complex128")
+    _check_out(func, x, "complex128", s=s, axes=axes, norm=norm)
+
+
+@pytest.mark.parametrize("func", ["fft2", "ifft2", "rfft2", "irfft2"])
+@pytest.mark.parametrize("shape", [(16, 18), _SHAPE_3D])
+@pytest.mark.parametrize("s", [(8, 9), (32, 36), (8, 36)])
+@pytest.mark.parametrize("norm", ["forward", "ortho"])
+def test_fft2_family_with_s_and_norm(func, shape, s, norm):
+    dtype = "float64" if func == "rfft2" else "complex128"
+    x = _make(shape, dtype)
+    got = getattr(mkl_fft, func)(x, s=s, norm=norm)
+    want = getattr(np.fft, func)(x, s=s, norm=norm)
+    _check(got, want, dtype)