fix: review

Author: jharlow-intel

CHANGELOG.md

@@ -11,8 +11,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 ### Fixed
-* Fixed `norm="forward"` and `norm="ortho"` scaling in `mkl_fft.fftn`, `ifftn`, `rfftn`, `irfftn` and the `fft2`/`ifft2`/`rfft2`/`irfft2` family when only a subset of the input axes is transformed and `s` is not given. The scale factor was computed over the full array shape instead of over the transformed axes, over-normalizing the result by the product of the untransformed axis lengths (for example `fft2` on a 3-D array, or `fftn(x, axes=(0,))`). The `mkl_fft.interfaces.numpy_fft` and `mkl_fft.interfaces.scipy_fft` wrappers were unaffected, as they resolve `s` before delegating
-* Fixed `norm="forward"` and `norm="ortho"` scaling in `mkl_fft.irfftn` and `irfft2`, which normalized over the input length `n` along the last transformed axis rather than the complex-to-real output length `2 * (n - 1)`. This applied even when every axis was transformed
+* 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 `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/_fft_utils.py

@@ -103,14 +103,18 @@ def _compute_nd_scale_shape(x, s, axes, norm=None, invreal=False):
         if axes is None:
             ss = list(x.shape)
             last = len(ss) - 1
+        elif len(axes) == 0:
+            # transforming no axes is an identity, so the scale is 1.0;
+            # np.prod(()) is 1, which gives that for every norm
+            return ()
         else:
             ss = [x.shape[ai] for ai in axes]
             last = axes[-1]
         if invreal:
             ss[-1] = 2 * (x.shape[last] - 1)
     except (IndexError, TypeError):
-        # invalid or empty axes; leave the scale alone and let the
-        # transform itself raise
+        # invalid axes; leave the scale alone and let the transform itself
+        # raise, so the error matches what NumPy reports
         return s
     return tuple(ss)
 

mkl_fft/tests/test_dispatch_equivalence.py

@@ -1,3 +1,28 @@
+# Copyright (c) 2026, Intel Corporation
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright notice,
+#       this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#     * Neither the name of Intel Corporation nor the names of its contributors
+#       may be used to endorse or promote products derived from this software
+#       without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
 """Cross-library equivalence checks for axis and axes dispatch.
 
 ``third_party/scipy/test_basic.py::test_fft_with_order`` already checks that
@@ -188,6 +213,33 @@ def test_rfftn_axes_subset_norm(func, dtype, axes, 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"
+
+
+@pytest.mark.parametrize("func", ["rfftn", "irfftn"])
+@pytest.mark.parametrize("norm", [None, "forward", "ortho"])
+def test_empty_axes_r2c_raises_like_numpy(func, norm):
+    """With no axes there is no last transformed axis to hold the half
+    spectrum, so both libraries raise; check the type agrees.
+    """
+    x = _make(_SHAPE_3D, "float64")
+    with pytest.raises(IndexError):
+        getattr(np.fft, func)(x, axes=(), norm=norm)
+    with pytest.raises(IndexError):
+        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("norm", [None, "backward", "forward", "ortho"])
@@ -228,3 +280,104 @@ def test_fftn_axes_subset_out(dtype, axes):
     got = mkl_fft.fftn(x, axes=axes, out=out)
     assert got is out, "out= should be returned"
     _check(got, want, dtype)
+
+
+def _check_out(func, x, dtype, **kwargs):
+    """Run *func* with an ``out`` array shaped and typed from the reference."""
+    want = getattr(np.fft, func)(x, **kwargs)
+    out = np.empty(want.shape, dtype=want.dtype)
+    got = getattr(mkl_fft, func)(x, out=out, **kwargs)
+    assert got is out, "out= should be returned"
+    _check(got, want, dtype)
+
+
+@pytest.mark.parametrize("func", ["fftn", "ifftn"])
+@pytest.mark.parametrize("dtype", ["complex64", "complex128"])
+@pytest.mark.parametrize("axes", [(0,), (2,), (1, 2), None])
+@pytest.mark.parametrize("norm", ["forward", "ortho"])
+def test_c2c_out_with_norm(func, dtype, axes, norm):
+    """The scale is applied while the result is written into ``out``, which is
+    the path this fix changes; ``ifftn`` shares it but was never exercised.
+    """
+    _check_out(func, _make(_SHAPE_3D, dtype), dtype, axes=axes, norm=norm)
+
+
+@pytest.mark.parametrize("dtype", ["float32", "float64"])
+@pytest.mark.parametrize("axes", [(0,), (2,), (1, 2), None])
+@pytest.mark.parametrize("norm", [None, "forward", "ortho"])
+def test_rfftn_out_with_norm(dtype, axes, norm):
+    """r2c: ``out`` is complex with the last transformed axis reduced to
+    ``n // 2 + 1``, a different allocation from the c2c case.
+    """
+    _check_out("rfftn", _make(_SHAPE_3D, dtype), dtype, axes=axes, norm=norm)
+
+
+@pytest.mark.parametrize("dtype", ["complex64", "complex128"])
+@pytest.mark.parametrize("axes", [(2,), (1, 2), None])
+@pytest.mark.parametrize("norm", [None, "forward", "ortho"])
+def test_irfftn_out_with_norm(dtype, axes, norm):
+    """c2r: ``out`` is real with the last transformed axis expanded to
+    ``2 * (n - 1)`` -- the length the invreal branch of the scale helper
+    computes, so this ties the two together.
+    """
+    _check_out("irfftn", _make(_SHAPE_3D, dtype), dtype, axes=axes, norm=norm)
+
+
+# ---------------------------------------------------------------------------
+# s= combined with a scaled norm
+#
+# The scale helper deliberately returns early when s is given, leaving
+# _compute_fwd_scale to normalize over prod(s). These lock that branch down.
+# axes is always passed explicitly: NumPy deprecated giving s without axes.
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize("func", ["fftn", "ifftn"])
+@pytest.mark.parametrize(
+    "axes,s",
+    [
+        ((0,), (16,)),  # pad one axis
+        ((0,), (4,)),  # truncate one axis
+        ((1, 2), (10, 20)),  # pad two
+        ((1, 2), (4, 6)),  # truncate two
+        ((0, 1, 2), (16, 4, 20)),  # pad and truncate together
+    ],
+)
+@pytest.mark.parametrize("norm", ["forward", "ortho"])
+def test_c2c_shape_arg_with_norm(func, axes, s, norm):
+    """The scale must come from ``prod(s)`` -- the padded or truncated length --
+    not from the original axis lengths.
+    """
+    x = _make(_SHAPE_3D, "complex128")
+    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, "complex128")
+
+
+@pytest.mark.parametrize("s", [(8, 7, 20), (8, 7, 10), (8, 7, 24)])
+@pytest.mark.parametrize("norm", ["forward", "ortho"])
+def test_irfftn_shape_arg_with_norm(s, norm):
+    """With ``s`` given, the invreal doubling must *not* be applied: the scale
+    normalizes over ``s[-1]``, not ``2 * (x.shape[-1] - 1)``.
+
+    ``s=(8, 7, 24)`` is deliberately ``2 * (13 - 1)``, so a regression that
+    ignores ``s`` and falls back to the input-derived basis would still pass
+    that one case -- 20 and 10 are what catch it. A regression that instead
+    doubles ``s[-1]`` itself is caught by all three.
+    """
+    x = _make(_SHAPE_3D, "complex128")
+    got = mkl_fft.irfftn(x, s=s, axes=(0, 1, 2), norm=norm)
+    want = np.fft.irfftn(x, s=s, axes=(0, 1, 2), norm=norm)
+    _check(got, want, "complex128")
+
+
+@pytest.mark.parametrize(
+    "axes,s", [((1,), (10,)), ((1,), (4,)), ((1, 2), (10, 20))]
+)
+@pytest.mark.parametrize("norm", ["forward", "ortho"])
+def test_rfftn_shape_arg_with_norm(axes, s, norm):
+    """Locks the r2c ``s``-given path together with scaling."""
+    x = _make(_SHAPE_3D, "float64")
+    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")