mindspore 2.3.0__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/numpy/fft.py

@@ -14,7 +14,10 @@
 # ============================================================================
 """Fast Fourier Transform operations, the function docs are adapted from Numpy API."""
 from __future__ import absolute_import
-__all__ = ['fftshift', 'ifftshift', 'fft', 'ifft', 'fft2', 'ifft2', 'fftn', 'ifftn']
+__all__ = ['fft', 'ifft', 'fft2', 'ifft2', 'fftn', 'ifftn',
+           'rfft', 'irfft', 'rfft2', 'irfft2', 'rfftn', 'irfftn',
+           'hfft', 'ihfft', 'hfft2', 'ihfft2', 'hfftn', 'ihfftn',
+           'fftshift', 'ifftshift', 'fftfreq', 'rfftfreq']
 from mindspore import ops
 
 
@@ -40,8 +43,9 @@ def fftshift(x, axes=None):
         >>> import mindspore.numpy as np
         >>> from mindspore import dtype as mstype
         >>> x = np.array([0, 1, 2, 3, 4, -5, -4, -3, -2, -1], dtype=mstype.int32)
-        >>> np.fft.fftshift(x)
-        Tensor(shape=[10], dtype=Int32, value= [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4])
+        >>> out = np.fft.fftshift(x)
+        >>> print(out)
+        [-5 -4 -3 -2 -1  0  1  2  3  4]
     """
     return ops.fftshift(x, axes)
 
@@ -68,8 +72,9 @@ def ifftshift(x, axes=None):
         >>> import mindspore.numpy as np
         >>> from mindspore import dtype as mstype
         >>> x = np.array([0, 1, 2, 3, 4, -5, -4, -3, -2, -1], dtype=mstype.int32)
-        >>> np.fft.ifftshift(np.fft.fftshift(x))
-        Tensor(shape=[10], dtype=Int32, value= [ 0, 1, 2, 3, 4, -5, -4, -3, -2, -1])
+        >>> out = np.fft.ifftshift(np.fft.fftshift(x))
+        >>> print(out)
+        [ 0  1  2  3  4 -5 -4 -3 -2 -1]
     """
     return ops.ifftshift(x, axes)
 
@@ -87,12 +92,12 @@ def fft(a, n=None, axis=-1, norm=None):
 
             - Ascend/CPU: int16, int32, int64, float16, float32, float64, complex64, complex128.
 
-        n (int, optional): Length of the transformed `dim` of the result.
-            If given, the size of the `dim` axis will be zero-padded or truncated to `n` before calculating `fft`.
+        n (int, optional): Length of the transformed `axis` of the result.
+            If given, the size of the `axis` will be zero-padded or truncated to `n` before calculating `fft`.
             Default: ``None`` , which does not need to process `a`.
-        axis (int, optional): Axis over which to compute the `fft`.
-            Default: ``-1`` , which means the last axis of `a` is used.
-        norm (string, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+        axis (int, optional): The dimension along which to take the one dimensional `fft`.
+            Default: ``-1`` , which means transform the last dimension of `a`.
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
             Three modes are defined as,
 
             - ``"backward"`` (no normalization).
@@ -109,10 +114,13 @@ def fft(a, n=None, axis=-1, norm=None):
         ``Ascend`` ``CPU``
 
     Examples:
+        >>> import mindspore
         >>> import mindspore.numpy as np
-        >>> input = np.array([ 1.6243454, -0.6117564, -0.5281718, -1.0729686])
-        >>> np.fft.fft(input)
-        Tensor(shape=[4], dtype=Complex64, value= [-0.588551+0j, 2.15252-0.461212j, 2.7809+0j, 2.15252+0.461212j])
+        >>> a = np.array([ 1.6243454, -0.6117564, -0.5281718, -1.0729686])
+        >>> out = np.fft.fft(a, n=4, axis=-1, norm="backward")
+        >>> print(out)
+        [-0.5885514+0.j          2.1525173-0.46121222j  2.7808986+0.j
+          2.1525173+0.46121222j]
     """
     return ops.fft(a, n, axis, norm)
 
@@ -130,18 +138,17 @@ def ifft(a, n=None, axis=-1, norm=None):
 
             - Ascend/CPU: int16, int32, int64, float16, float32, float64, complex64, complex128.
 
-        n (int, optional): Length of the transformed `dim` of the result.
-        n (int, optional): Signal length.
-            If given, the input will either be zero-padded or trimmed to this length before computing `ifft`.
+        n (int, optional): Length of the transformed `axis` of the result.
+            If given, the size of the `axis` will be zero-padded or truncated to `n` before calculating `ifft`.
             Default: ``None`` , which does not need to process `a`.
-        axis (int, optional): Axis over which to compute the `ifft`.
-            Default: ``-1`` , which means the last axis of `a` is used.
-        norm (string, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+        axis (int, optional): The dimension along which to take the one dimensional `ifft`.
+            Default: ``-1`` , which means transform the last dimension of `a`.
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
             Three modes are defined as,
 
-            - ``"backward"`` (no normalization).
-            - ``"forward"`` (normalize by :math:`1*n`).
-            - ``"ortho"`` (normalize by :math:`1*\sqrt{n}`).
+            - ``"backward"`` (normalize by :math:`1/n`).
+            - ``"forward"`` (no normalization).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
 
     Returns:
         Tensor, The result of `ifft()` function. The default is the same shape as `a`.
@@ -153,10 +160,13 @@ def ifft(a, n=None, axis=-1, norm=None):
         ``Ascend`` ``CPU``
 
     Examples:
+        >>> import mindspore
         >>> import mindspore.numpy as np
-        >>> input = np.array([ 1.6243454, -0.6117564, -0.5281718, -1.0729686])
-        >>> np.fft.ifft(input)
-        Tensor(shape=[4], dtype=Complex64, value= [-0.147138+0j, 0.538129+0.115303j, 0.695225+0j, 0.538129-0.115303j])
+        >>> a = np.array([ 1.6243454, -0.6117564, -0.5281718, -1.0729686])
+        >>> out = np.fft.ifft(a, n=4, axis=-1, norm="backward")
+        >>> print(out)
+        [-0.14713785+0.j          0.5381293 +0.11530305j  0.69522464+0.j
+          0.5381293 -0.11530305j]
     """
     return ops.ifft(a, n, axis, norm)
 
@@ -190,11 +200,10 @@ def rfft(a, n=None, axis=-1, norm=None):
 
     Examples:
         >>> import mindspore
-        >>> from mindspore import Tensor
-        >>> from mindspore import numpy as mnp
-        >>> input = Tensor([1, 2, 3, 4])
-        >>> y = mnp.fft.rfft(input)
-        >>> print(y)
+        >>> import mindspore.numpy as np
+        >>> a = np.array([1, 2, 3, 4])
+        >>> out = np.fft.rfft(a, n=4, axis=-1, norm='backward')
+        >>> print(out)
         [10.+0.j -2.+2.j -2.+0.j]
     """
     return ops.rfft(a, n, axis, norm)
@@ -205,11 +214,11 @@ def irfft(a, n=None, axis=-1, norm=None):
     Calculates the inverse of `rfft()`.
 
     Refer to :func:`mindspore.ops.irfft` for more details.
-    The difference is that `a` corresponds to `input` and `axis` corresponds to `dim`.
+    The difference is that `a` corresponds to `a` and `axis` corresponds to `dim`.
 
     Args:
         a (Tensor): The input tensor.
-        n (int, optional): Length of the transformed `dim` of the result.
+        n (int, optional): Length of the transformed `axis` of the result.
             If given, the input will either be zero-padded or trimmed to this length before computing `rfft`.
             If n is not given, it is taken to be :math:`2*(a.shape[axis]-1)`.
             Default: ``None``.
@@ -218,8 +227,8 @@ def irfft(a, n=None, axis=-1, norm=None):
         norm (string, optional): Normalization mode. Default: ``None`` that means ``"backward"``.
             Three modes are defined as,
 
-            - ``"backward"`` (no normalization).
-            - ``"forward"`` (normalize by :math:`1/n`).
+            - ``"backward"`` (normalize by :math:`1/n`).
+            - ``"forward"`` (no normalization).
             - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
 
     Returns:
@@ -230,13 +239,11 @@ def irfft(a, n=None, axis=-1, norm=None):
 
     Examples:
         >>> import mindspore
-        >>> from mindspore import Tensor
-        >>> from mindspore import numpy as mnp
-        >>> input = Tensor([1, 2, 3, 4])
-        >>> y = mnp.fft.irfft(input)
+        >>> import mindspore.numpy as np
+        >>> a = np.array([1, 2, 3, 4])
+        >>> y = np.fft.irfft(a, n=6, axis=-1, norm='backward')
         >>> print(y)
-        [ 2.5000000e+00 -6.6666669e-01  1.2590267e-15 -1.6666667e-01
-        4.2470195e-16 -6.6666669e-01]
+        [ 2.5        -0.6666667   0.         -0.16666667  0.         -0.6666667 ]
     """
     return ops.irfft(a, n, axis, norm)
 
@@ -260,7 +267,7 @@ def fft2(a, s=None, axes=(-2, -1), norm=None):
         axes (tuple[int], optional): The dimension along which to take the one dimensional `fft2`.
             Default: ``(-2, -1)`` , which means transform the last two dimension of `a`.
         norm (string, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
-            Three modes are defined as,
+            Three modes are defined as, where :math: `n = prod(s)`
 
             - ``"backward"`` (no normalization).
             - ``"forward"`` (normalize by :math:`1/n`).
@@ -278,12 +285,12 @@ def fft2(a, s=None, axes=(-2, -1), norm=None):
     Examples:
         >>> import mindspore.numpy as np
         >>> a = np.ones((4, 4))
-        >>> np.fft.fft2(a, s=(4, 4), axes=(0, 1), norm="backward")
-        Tensor(shape=[4, 4], dtype=Complex64, value=
-        [[16+0j, 0+0j, 0+0j, 0+0j],
-         [0+0j, 0+0j, 0+0j, 0+0j],
-         [0+0j, 0+0j, 0+0j, 0+0j],
-         [0+0j, 0+0j, 0+0j, 0+0j]])
+        >>> out = np.fft.fft2(a, s=(4, 4), axes=(0, 1), norm="backward")
+        >>> print(out)
+        [[16.+0.j  0.+0.j  0.+0.j  0.+0.j]
+         [ 0.+0.j  0.+0.j  0.+0.j  0.+0.j]
+         [ 0.+0.j  0.+0.j  0.+0.j  0.+0.j]
+         [ 0.+0.j  0.+0.j  0.+0.j  0.+0.j]]
     """
     return ops.fft2(a, s, axes, norm)
 
@@ -302,16 +309,16 @@ def ifft2(a, s=None, axes=(-2, -1), norm=None):
             - Ascend/CPU: int16, int32, int64, float16, float32, float64, complex64, complex128.
 
         s (tuple[int], optional): Length of the transformed `axes` of the result.
-            If given, the input will either be zero-padded or trimmed to this length before computing `ifft2`.
+            If given, the `a.shape[axes[i]]` will be zero-padded or truncated to `s[i]` before calculating `ifft2`.
             Default: ``None`` , which does not need to process `a`.
         axes (tuple[int], optional): The dimension along which to take the one dimensional `ifft2`.
             Default: ``(-2, -1)`` , which means transform the last two dimension of `a`.
-        norm (string, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
-            Three modes are defined as,
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+            Three modes are defined as, where :math: `n = prod(s)`
 
-            - ``"backward"`` (no normalization).
-            - ``"forward"`` (normalize by :math:`1*n`).
-            - ``"ortho"`` (normalize by :math:`1*\sqrt{n}`).
+            - ``"backward"`` (normalize by :math:`1/n`).
+            - ``"forward"`` (no normalization).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
 
     Returns:
         Tensor, The result of `ifft2()` function. The default is the same shape as `a`.
@@ -325,12 +332,12 @@ def ifft2(a, s=None, axes=(-2, -1), norm=None):
     Examples:
         >>> import mindspore.numpy as np
         >>> a = np.ones((4, 4))
-        >>> np.fft.ifft2(a, s=(4, 4), axes=(0, 1), norm="backward")
-        Tensor(shape=[4, 4], dtype=Complex64, value=
-        [[1+0j, 0+0j, 0+0j, 0+0j],
-         [0+0j, 0+0j, 0+0j, 0+0j],
-         [0+0j, 0+0j, 0+0j, 0+0j],
-         [0+0j, 0+0j, 0+0j, 0+0j]])
+        >>> out = np.fft.ifft2(a, s=(4, 4), axes=(0, 1), norm="backward")
+        >>> print(out)
+        [[1.+0.j 0.+0.j 0.+0.j 0.+0.j]
+         [0.+0.j 0.+0.j 0.+0.j 0.+0.j]
+         [0.+0.j 0.+0.j 0.+0.j 0.+0.j]
+         [0.+0.j 0.+0.j 0.+0.j 0.+0.j]]
     """
     return ops.ifft2(a, s, axes, norm)
 
@@ -355,7 +362,7 @@ def fftn(a, s=None, axes=None, norm=None):
             Default: ``None`` , which means transform the all dimension of `a`,
             or the last `len(s)` dimensions if s is given.
         norm (string, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
-            Three modes are defined as,
+            Three modes are defined as, where :math: `n = prod(s)`
 
             - ``"backward"`` (no normalization).
             - ``"forward"`` (normalize by :math:`1/n`).
@@ -373,12 +380,12 @@ def fftn(a, s=None, axes=None, norm=None):
     Examples:
         >>> import mindspore.numpy as np
         >>> a = np.ones((2, 2, 2))
-        >>> np.fft.fftn(a, s=(2, 2, 2), axes=(0, 1, 2), norm="backward")
-        Tensor(shape=[2, 2, 2], dtype=Complex64, value=
-        [[[8+0j, 0+0j],
-         [0+0j, 0+0j]],
-         [[0+0j, 0+0j],
-         [0+0j, 0+0j]]])
+        >>> out = np.fft.fftn(a, s=(2, 2, 2), axes=(0, 1, 2), norm="backward")
+        >>> print(out)
+        [[[8.+0.j 0.+0.j]
+          [0.+0.j 0.+0.j]]
+          [[0.+0.j 0.+0.j]
+          [0.+0.j 0.+0.j]]]
     """
     return ops.fftn(a, s, axes, norm)
 
@@ -403,11 +410,11 @@ def ifftn(a, s=None, axes=None, norm=None):
             Default: ``None`` , which means transform the all dimension of `a`,
             or the last `len(s)` dimensions if s is given.
         norm (string, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
-            Three modes are defined as,
+            Three modes are defined as, where :math: `n = prod(s)`
 
-            - ``"backward"`` (no normalization).
-            - ``"forward"`` (normalize by :math:`1*n`).
-            - ``"ortho"`` (normalize by :math:`1*\sqrt{n}`).
+            - ``"backward"`` (normalize by :math:`1/n`).
+            - ``"forward"`` (no normalization).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
 
     Returns:
         Tensor, The result of `ifftn()` function. The default is the same shape as `a`.
@@ -421,11 +428,539 @@ def ifftn(a, s=None, axes=None, norm=None):
     Examples:
         >>> import mindspore.numpy as np
         >>> a = np.ones((2, 2, 2))
-        >>> np.fft.ifftn(a, s=(2, 2, 2), axes=(0, 1, 2), norm="backward")
+        >>> out = np.fft.ifftn(a, s=(2, 2, 2), axes=(0, 1, 2), norm="backward")
+        >>> print(out)
+        [[[1.+0.j 0.+0.j]
+          [0.+0.j 0.+0.j]]
+          [[0.+0.j 0.+0.j]
+          [0.+0.j 0.+0.j]]]
+    """
+    return ops.ifftn(a, s, axes, norm)
+
+
+def rfft2(a, s=None, axes=(-2, -1), norm=None):
+    r"""
+    Calculates the two dimensional discrete Fourier transform for real input `a`.
+
+    Refer to :func:`mindspore.ops.rfft2` for more details.
+    The difference is that `a` corresponds to `input` and `axes` corresponds to `dim`.
+
+    Args:
+        a (Tensor): The input tensor.
+            Supported dtypes:
+
+            - Ascend/CPU: int16, int32, int64, float16, float32, float64.
+
+        s (tuple[int], optional): Length of the transformed `axes` of the result.
+            If given, the size of the `axes[i]` axis will be zero-padded or truncated to `s[i]`
+            before calculating `rfft2`.
+            Default: ``None`` , which does not need to process `a`.
+        axes (tuple[int], optional): The dimension along which to take the one dimensional `rfft2`.
+            Default: ``(-2, -1)`` , which means transform the last two dimension of `a`.
+        norm (string, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+            Three modes are defined as, where :math: `n = prod(s)`
+
+            - ``"backward"`` (no normalization).
+            - ``"forward"`` (normalize by :math:`1/n`).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
+
+    Returns:
+        Tensor, the result of `rfft2()` function, dtype of the result is complex64/128.
+        If `s` is given, result.shape[axes[i]] is :math:`s[i]`, while result.shape[axes[-1]] is :math:`s[-1] // 2 + 1`.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor
+        >>> from mindspore import numpy as mnp
+        >>> a = mnp.ones((2, 2))
+        >>> mnp.fft.rfft2(a, s=(2, 2), axes=(0, 1), norm="backward")
+        Tensor(shape=[2, 2], dtype=Complex64, value=
+        [[4+0j, 0+0j],
+         [0+0j, 0+0j]])
+    """
+    return ops.rfft2(a, s, axes, norm)
+
+
+def irfft2(a, s=None, axes=(-2, -1), norm=None):
+    r"""
+    Calculates the inverse of `rfft2()`.
+
+    Refer to :func:`mindspore.ops.irfft2` for more details.
+    The difference is that `a` corresponds to `input` and `axes` corresponds to `dim`.
+
+    Args:
+        a (Tensor): The input tensor.
+            Supported dtypes:
+
+            - Ascend/CPU: int16, int32, int64, float16, float32, float64, complex64, complex128.
+
+        s (tuple[int], optional): Length of the transformed `axes` of the result.
+            If given, the input will either be zero-padded or trimmed to this length before computing `irfft2`.
+            Default: ``None`` , the axes[-1] of the `a` will be zero-padded to :math:`2*(a.shape[axes[-1]]-1)`.
+        axes (tuple[int], optional): The dimension along which to take the one dimensional `irfft2`.
+            Default: ``(-2, -1)`` , which means transform the last two dimension of `a`.
+        norm (string, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+            Three modes are defined as, where :math: `n = prod(s)`
+
+            - ``"backward"`` (normalize by :math:`1/n`).
+            - ``"forward"`` (no normalization).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
+
+    Returns:
+        Tensor, The result of `irfft2()` function, result.shape[axes[i]] is s[i].
+        When the `a` is int16, int32, int64, float16, float32, complex64, the return value type is float32.
+        When the `a` is float64 or complex128, the return value type is float64.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor
+        >>> from mindspore import numpy as mnp
+        >>> a = mnp.ones((4, 4))
+        >>> mnp.fft.irfft2(a, s=(4, 4), axes=(0, 1), norm="backward")
+        Tensor(shape=[4, 4], dtype=Float32, value=
+        [[ 1.00000000e+00,  0.00000000e+00,  0.00000000e+00,  0.00000000e+00],
+         [ 0.00000000e+00,  0.00000000e+00,  0.00000000e+00,  0.00000000e+00],
+         [ 0.00000000e+00,  0.00000000e+00,  0.00000000e+00,  0.00000000e+00],
+         [ 0.00000000e+00,  0.00000000e+00,  0.00000000e+00,  0.00000000e+00]])
+    """
+    return ops.irfft2(a, s, axes, norm)
+
+
+def rfftn(a, s=None, axes=None, norm=None):
+    r"""
+    Calculates the N dimensional discrete Fourier transform for real input `a`.
+
+    Refer to :func:`mindspore.ops.rfftn` for more details.
+    The difference is that `a` corresponds to `input` and `axes` corresponds to `dim`.
+
+    Args:
+        a (Tensor): The input tensor.
+            Supported dtypes:
+
+            - Ascend/CPU: int16, int32, int64, float16, float32, float64.
+
+        s (tuple[int], optional): Length of the transformed `axes` of the result.
+            If given, the input will either be zero-padded or trimmed to this length before computing `rfftn`.
+            Default: ``None`` , which does not need to process `a`.
+        axes (tuple[int], optional): The dimension along which to take the one dimensional `rfftn`.
+            Default: ``None`` , which means transform the all dimension of `a`,
+            or the last `len(s)` dimensions if s is given.
+        norm (string, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+            Three modes are defined as, where :math: `n = prod(s)`
+
+            - ``"backward"`` (no normalization).
+            - ``"forward"`` (normalize by :math:`1/n`).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
+
+    Returns:
+        Tensor, the result of `rfftn()` function, dtype of the result is complex64/128.
+        If `s` is given, result.shape[axes[i]] is :math:`s[i]`, while result.shape[axes[-1]] is :math:`s[-1] // 2 + 1`.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor
+        >>> from mindspore import numpy as mnp
+        >>> a = mnp.ones((2, 2, 2))
+        >>> mnp.fft.rfftn(a, s=(2, 2, 2), axes=(0, 1, 2), norm="backward")
         Tensor(shape=[2, 2, 2], dtype=Complex64, value=
-        [[[1+0j, 0+0j],
-         [0+0j, 0+0j]],
+        [[[8+0j, 0+0j],
+          [0+0j, 0+0j]],
          [[0+0j, 0+0j],
-         [0+0j, 0+0j]]])
+          [0+0j, 0+0j]]])
     """
-    return ops.ifftn(a, s, axes, norm)
+    return ops.rfftn(a, s, axes, norm)
+
+
+def irfftn(a, s=None, axes=None, norm=None):
+    r"""
+    Calculates the inverse of `rfftn()`.
+
+    Refer to :func:`mindspore.ops.irfftn` for more details.
+    The difference is that `a` corresponds to `input` and `axes` corresponds to `dim`.
+
+    Args:
+        a (Tensor): The input tensor.
+            Supported dtypes:
+
+            - Ascend/CPU: int16, int32, int64, float16, float32, float64, complex64, complex128.
+
+        s (tuple[int], optional): Length of the transformed `axes` of the result.
+            If given, the input will either be zero-padded or trimmed to this length before computing `irfftn`.
+            Default: ``None`` , the axes[-1] of the `a` will be zero-padded to :math:`2*(a.shape[axes[-1]]-1)`.
+        axes (tuple[int], optional): The dimension along which to take the one dimensional `irfftn`.
+            Default: ``None`` , which means transform the all dimension of `a`,
+            or the last `len(s)` dimensions if s is given.
+        norm (string, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+            Three modes are defined as, where :math: `n = prod(s)`
+
+            - ``"backward"`` (normalize by :math:`1/n`).
+            - ``"forward"`` (no normalization).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
+
+    Returns:
+        Tensor, The result of `irfft2()` function, result.shape[axes[i]] is s[i].
+        When the `a` is int16, int32, int64, float16, float32, complex64, the return value type is float32.
+        When the `a` is float64 or complex128, the return value type is float64.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor
+        >>> from mindspore import numpy as mnp
+        >>> a = mnp.ones((2, 2, 2))
+        >>> mnp.fft.irfftn(a, s=(2, 2, 2), axes=(0, 1, 2), norm="backward")
+        Tensor(shape=[2, 2, 2], dtype=Float32, value=
+        [[[ 1.00000000e+00,  0.00000000e+00],
+          [ 0.00000000e+00,  0.00000000e+00]],
+         [[ 0.00000000e+00,  0.00000000e+00],
+          [ 0.00000000e+00,  0.00000000e+00]]])
+    """
+    return ops.irfftn(a, s, axes, norm)
+
+
+def hfft(a, n=None, axis=-1, norm=None):
+    r"""
+    Calculates the one dimensional discrete Fourier transform of of a Hermitian symmetric `a` signal.
+
+    Refer to :func:`mindspore.ops.hfft` for more details.
+    The difference is that `a` corresponds to `input` and `axis` corresponds to `dim`.
+
+    Args:
+        a (Tensor): The input tensor.
+            Supported dtypes:
+
+            - Ascend/CPU: int16, int32, int64, float16, float32, float64, complex64, complex128.
+
+        n (int, optional): Length of the transformed `axis` of the result.
+            If given, the size of the `axis` axis will be zero-padded or truncated to `n` before calculating `hfft`.
+            Default: ``None`` , which does not need to process `a`.
+        axis (int, optional): The dimension along which to take the one dimensional `hfft`.
+            Default: ``-1`` , which means transform the last dimension of `a`.
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+            Three modes are defined as,
+
+            - ``"backward"`` (no normalization).
+            - ``"forward"`` (normalize by :math:`1/n`).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
+
+    Returns:
+        Tensor, The result of `hfft()` function.
+        If `n` is given, result.shape[axis] is :math:`(n - 1) * 2`, otherwise math:`(a.shape[axis] - 1) * 2`.
+        When the `a` is int16, int32, int64, float16, float32, complex64, the return value type is float32.
+        When the `a` is float64 or complex128, the return value type is float64.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor
+        >>> from mindspore import numpy as np
+        >>> a = np.array([ 1.6243454, -0.6117564, -0.5281718, -1.0729686])
+        >>> out = np.fft.hfft(a, n=4, axis=-1, norm="backward")
+        >>> print(out)
+        [-0.12733912  2.1525173   2.3196864   2.1525173 ]
+    """
+    return ops.hfft(a, n, axis, norm)
+
+
+def ihfft(a, n=None, axis=-1, norm=None):
+    r"""
+    Calculates the inverse of `hfft()`.
+
+    Refer to :func:`mindspore.ops.ihfft` for more details.
+    The difference is that `a` corresponds to `input` and `axis` corresponds to `dim`.
+
+    Note:
+        - `ihfft` is currently only used in `mindscience` scientific computing scenarios and
+        dose not support other usage scenarios.
+        - `ihfft` is not supported on Windows platform yet.
+
+    Args:
+        a (Tensor): The input tensor.
+            Supported dtypes:
+
+            - Ascend/CPU: int16, int32, int64, float16, float32, float64.
+
+        n (int, optional): Length of the transformed `axis` of the result.
+            If given, the size of the `axis` will be zero-padded or truncated to `n` before calculating `ihfft`.
+            Default: ``None`` , which does not need to process `a`.
+        axis (int, optional): The dimension along which to take the one dimensional `ihfft`.
+            Default: ``-1`` , which means transform the last dimension of `a`.
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+            Three modes are defined as,
+
+            - ``"backward"`` (normalize by :math:`1/n`).
+            - ``"forward"`` (no normalization).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
+
+    Returns:
+        Tensor, The result of `ihfft()` function.
+        If `n` is given, result.shape[axis] is :math:`n // 2 + 1`, otherwise math:`a.shape[axis] // 2 + 1`.
+        When the `a` is int16, int32, int64, float16, float32, the return value type is complex64.
+        When the `a` is float64, the return value type is complex128.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor
+        >>> from mindspore import numpy as np
+        >>> a = np.array([ 1.6243454, -0.6117564, -0.5281718, -1.0729686])
+        >>> out = np.fft.ihfft(a, n=4, axis=-1, norm="backward")
+        >>> print(out)
+        [-0.14713785-0.j          0.5381293 +0.11530305j  0.69522464-0.j        ]
+    """
+    return ops.ihfft(a, n, axis, norm)
+
+
+def hfft2(a, s=None, axes=(-2, -1), norm=None):
+    r"""
+    Calculates the two dimensional discrete Fourier transform of of a Hermitian symmetric `a` signal.
+
+    Refer to :func:`mindspore.ops.hfft2` for more details.
+    The difference is that `a` corresponds to `input` and `axes` corresponds to `dim`.
+
+    Args:
+        a (Tensor): The input tensor.
+            Supported dtypes:
+
+            - Ascend/CPU: int16, int32, int64, float16, float32, float64, complex64, complex128.
+
+        s (tuple[int], optional): Length of the transformed `axes` of the result.
+            If given, the `a.shape[axes[i]]` will be zero-padded or truncated to `s[i]` before calculating `hfft2`.
+            Default: ``None`` , which does not need to process `a`.
+        axes (tuple[int], optional): The dimension along which to take the one dimensional `hfft2`.
+            Default: ``(-2, -1)`` , which means transform the last two dimension of `a`.
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+            Three modes are defined as, where :math: `n = prod(s)`
+
+            - ``"backward"`` (no normalization).
+            - ``"forward"`` (normalize by :math:`1/n`).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
+
+    Returns:
+        Tensor, The result of `hfft2()` function.
+        If `s` is given, result.shape[axes[i]] is s[i], and for the last transformed axes,
+        result.shape[axes[-1]] is :math:`(s[-1] - 1) * 2`, otherwise :math:`(a.shape[axes[-1]] - 1) * 2`.
+        When the `a` is int16, int32, int64, float16, float32, complex64, the return value type is complex64.
+        When the `a` is float64 or complex128, the return value type is complex128.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore.numpy as np
+        >>> a = np.ones((4, 4))
+        >>> out = np.fft.hfft2(a, s=(4, 4), axes=(0, 1), norm="backward")
+        >>> print(out)
+        [[16.  0.  0.  0.]
+         [ 0.  0.  0.  0.]
+         [ 0.  0.  0.  0.]
+         [ 0.  0.  0.  0.]]
+    """
+    return ops.hfft2(a, s, axes, norm)
+
+
+def ihfft2(a, s=None, axes=(-2, -1), norm=None):
+    r"""
+    Computes the two dimensional inverse discrete Fourier transform of real `a`.
+
+    Refer to :func:`mindspore.ops.ihfft2` for more details.
+    The difference is that `a` corresponds to `input` and `axes` corresponds to `dim`.
+
+    Args:
+        a (Tensor): The input tensor.
+            Supported dtypes:
+
+            - Ascend/CPU: int16, int32, int64, float16, float32, float64.
+
+        s (tuple[int], optional): Length of the transformed `axes` of the result.
+            If given, the `a.shape[axes[i]]` will be zero-padded or truncated to `s[i]` before calculating `ihfft2`.
+            Default: ``None`` , which does not need to process `a`.
+        axes (tuple[int], optional): The dimension along which to take the one dimensional `ihfft2`.
+            Default: ``(-2, -1)`` , which means transform the last two dimension of `a`.
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+            Three modes are defined as, where :math: `n = prod(s)`
+
+            - ``"backward"`` (normalize by :math:`1/n`).
+            - ``"forward"`` (no normalization).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
+
+    Returns:
+        Tensor, The result of `ihfft2()` function.
+        If `s` is given, result.shape[axes[i]] is s[i], and for the last transformed `axes`,
+        result.shape[axes[-1]] is :math:`s[-1] // 2 + 1`, otherwise :math:`a.shape[axes[-1]] // 2 + 1`.
+        When the `a` is int16, int32, int64, float16, float32, the return value type is complex64.
+        When the `a` is float64, the return value type is complex128.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore.numpy as np
+        >>> a = np.ones((4, 4))
+        >>> out = np.fft.ihfft2(a, s=(4, 4), axes=(0, 1), norm="backward")
+        >>> print(out)
+        [[1.-0.j 0.-0.j 0.-0.j]
+         [0.-0.j 0.-0.j 0.-0.j]
+         [0.-0.j 0.-0.j 0.-0.j]
+         [0.-0.j 0.-0.j 0.-0.j]]
+    """
+    return ops.ihfft2(a, s, axes, norm)
+
+
+def hfftn(a, s=None, axes=None, norm=None):
+    r"""
+    Calculates the N dimensional discrete Fourier transform of of a Hermitian symmetric `a`.
+
+    Refer to :func:`mindspore.ops.hfftn` for more details.
+    The difference is that `a` corresponds to `input` and `axes` corresponds to `dim`.
+
+    Args:
+        a (Tensor): The input tensor.
+            Supported dtypes:
+
+            - Ascend/CPU: int16, int32, int64, float16, float32, float64, complex64, complex128.
+
+        s (tuple[int], optional): Length of the transformed `axes` of the result.
+            If given, the `a.shape[axes[i]]` will be zero-padded or truncated to `s[i]` before calculating `hfftn`.
+            Default: ``None`` , which does not need to process `a`.
+        axes (tuple[int], optional): The dimension along which to take the one dimensional `hfftn`.
+            Default: ``(-2, -1)`` , which means transform the last two dimension of `a`.
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+            Three modes are defined as, where :math: `n = prod(s)`
+
+            - ``"backward"`` (no normalization).
+            - ``"forward"`` (normalize by :math:`1/n`).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
+
+    Returns:
+        Tensor, The result of `hfftn()` function.
+        If `s` is given, result.shape[axes[i]] is s[i], and for the last transformed `axes`,
+        result.shape[axes[-1]] is :math:`(s[-1] - 1) * 2`, otherwise :math:`(a.shape[axes[-1]] - 1) * 2`.
+        When the `a` is int16, int32, int64, float16, float32, complex64, the return value type is complex64.
+        When the `a` is float64 or complex128, the return value type is complex128.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore.numpy as np
+        >>> a = np.ones((4, 4))
+        >>> out = np.fft.hfftn(a, s=(4, 4), axes=(0, 1), norm="backward")
+        >>> print(out)
+        [[16.  0.  0.  0.]
+         [ 0.  0.  0.  0.]
+         [ 0.  0.  0.  0.]
+         [ 0.  0.  0.  0.]]
+    """
+    return ops.hfftn(a, s, axes, norm)
+
+
+def ihfftn(a, s=None, axes=None, norm=None):
+    r"""
+    Computes the N dimensional inverse discrete Fourier transform of real `a`.
+
+    Refer to :func:`mindspore.ops.ihfftn` for more details.
+    The difference is that `a` corresponds to `input` and `axes` corresponds to `dim`.
+
+    Args:
+        a (Tensor): The input tensor.
+            Supported dtypes:
+
+            - Ascend/CPU: int16, int32, int64, float16, float32, float64.
+
+        s (tuple[int], optional): Length of the transformed `axes` of the result.
+            If given, the `a.shape[axes[i]]` will be zero-padded or truncated to `s[i]` before calculating `ihfftn`.
+            Default: ``None`` , which does not need to process `a`.
+        axes (tuple[int], optional): The dimension along which to take the one dimensional `ihfftn`.
+            Default: ``(-2, -1)`` , which means transform the last two dimension of `a`.
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+            Three modes are defined as, where :math: `n = prod(s)`
+
+            - ``"backward"`` (normalize by :math:`1/n`).
+            - ``"forward"`` (no normalization).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
+
+    Returns:
+        Tensor, The result of `ihfftn()` function.
+        If `s` is given, result.shape[axes[i]] is s[i], and for the last transformed `axes`,
+        result.shape[axes[-1]] is :math:`s[-1] // 2 + 1`, otherwise :math:`a.shape[axes[-1]] // 2 + 1`.
+        When the `a` is int16, int32, int64, float16, float32, the return value type is complex64.
+        When the `a` is float64, the return value type is complex128.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore.numpy as np
+        >>> a = np.ones((4, 4))
+        >>> out = np.fft.ihfftn(a, s=(4, 4), axes=(0, 1), norm="backward")
+        >>> print(out)
+        [[16.  0.  0.  0.]
+         [ 0.  0.  0.  0.]
+         [ 0.  0.  0.  0.]
+         [ 0.  0.  0.  0.]]
+    """
+    return ops.hfftn(a, s, axes, norm)
+
+
+def fftfreq(n, d=1.0, dtype=None):
+    r"""
+    Return the Discrete Fourier Transform sample frequencies.
+
+    Args:
+        n (int): Window length.
+        d (float, optional): Sample spacing (inverse of the sampling rate). Default: ``1.0`` .
+        dtype (mindspore.dtype, optional): The dtype of the returned frequencies. Default: ``float32`` .
+
+    Returns:
+        Tensor, Array of length ``n`` containing the sample frequencies.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore.numpy as np
+        >>> out = np.fft.fftfreq(n=4, d=1.0)
+        >>> print(out)
+        [ 0.    0.25 -0.5  -0.25]
+    """
+    return ops.fftfreq(n, d, dtype)
+
+
+def rfftfreq(n, d=1.0, dtype=None):
+    r"""
+    Return the Discrete Fourier Transform sample frequencies (for usage with rfft, irfft).
+
+    Args:
+        n (int): Window length.
+        d (float, optional): Sample spacing (inverse of the sampling rate). Default: ``1.0`` .
+        dtype (mindspore.dtype, optional): The dtype of the returned frequencies. Default: ``float32`` .
+
+    Returns:
+        Tensor, Array of length math:`n // 2 + 1` containing the sample frequencies.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore.numpy as np
+        >>> out = np.fft.rfftfreq(n=4, d=1.0)
+        >>> print(out)
+        [0.   0.25 0.5 ]
+    """
+    return ops.rfftfreq(n, d, dtype)