maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/fft/hfft.py

@@ -0,0 +1,112 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+
+from ... import opcodes
+from ..datasource import tensor as astensor
+from .core import TensorFFTMixin, TensorHermitianFFT, validate_fft
+
+
+class TensorHFFT(TensorHermitianFFT, TensorFFTMixin):
+    _op_type_ = opcodes.HFFT
+
+    @classmethod
+    def _get_shape(cls, op, shape):
+        new_shape = list(shape)
+        if op.n is not None:
+            new_shape[op.axis] = op.n
+        else:
+            new_shape[op.axis] = 2 * (shape[op.axis] - 1)
+        return tuple(new_shape)
+
+
+def hfft(a, n=None, axis=-1, norm=None):
+    """
+    Compute the FFT of a signal that has Hermitian symmetry, i.e., a real
+    spectrum.
+
+    Parameters
+    ----------
+    a : array_like
+        The input tensor.
+    n : int, optional
+        Length of the transformed axis of the output. For `n` output
+        points, ``n//2 + 1`` input points are necessary.  If the input is
+        longer than this, it is cropped.  If it is shorter than this, it is
+        padded with zeros.  If `n` is not given, it is determined from the
+        length of the input along the axis specified by `axis`.
+    axis : int, optional
+        Axis over which to compute the FFT. If not given, the last
+        axis is used.
+    norm : {None, "ortho"}, optional
+        Normalization mode (see `mt.fft`). Default is None.
+
+    Returns
+    -------
+    out : Tensor
+        The truncated or zero-padded input, transformed along the axis
+        indicated by `axis`, or the last one if `axis` is not specified.
+        The length of the transformed axis is `n`, or, if `n` is not given,
+        ``2*m - 2`` where ``m`` is the length of the transformed axis of
+        the input. To get an odd number of output points, `n` must be
+        specified, for instance as ``2*m - 1`` in the typical case,
+
+    Raises
+    ------
+    IndexError
+        If `axis` is larger than the last axis of `a`.
+
+    See also
+    --------
+    rfft : Compute the one-dimensional FFT for real input.
+    ihfft : The inverse of `hfft`.
+
+    Notes
+    -----
+    `hfft`/`ihfft` are a pair analogous to `rfft`/`irfft`, but for the
+    opposite case: here the signal has Hermitian symmetry in the time
+    domain and is real in the frequency domain. So here it's `hfft` for
+    which you must supply the length of the result if it is to be odd.
+
+    * even: ``ihfft(hfft(a, 2*len(a) - 2) == a``, within roundoff error,
+    * odd: ``ihfft(hfft(a, 2*len(a) - 1) == a``, within roundoff error.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> signal = mt.array([1, 2, 3, 4, 3, 2])
+    >>> mt.fft.fft(signal).execute()
+    array([ 15.+0.j,  -4.+0.j,   0.+0.j,  -1.-0.j,   0.+0.j,  -4.+0.j])
+    >>> mt.fft.hfft(signal[:4]).execute() # Input first half of signal
+    array([ 15.,  -4.,   0.,  -1.,   0.,  -4.])
+    >>> mt.fft.hfft(signal, 6).execute()  # Input entire signal and truncate
+    array([ 15.,  -4.,   0.,  -1.,   0.,  -4.])
+
+
+    >>> signal = mt.array([[1, 1.j], [-1.j, 2]])
+    >>> (mt.conj(signal.T) - signal).execute()   # check Hermitian symmetry
+    array([[ 0.-0.j,  0.+0.j],
+           [ 0.+0.j,  0.-0.j]])
+    >>> freq_spectrum = mt.fft.hfft(signal)
+    >>> freq_spectrum.execute()
+    array([[ 1.,  1.],
+           [ 2., -2.]])
+
+    """
+    a = astensor(a)
+    validate_fft(a, axis=axis, norm=norm)
+    op = TensorHFFT(n=n, axis=axis, norm=norm, dtype=np.dtype(np.float_))
+    return op(a)

maxframe/tensor/fft/ifft.py

@@ -0,0 +1,114 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+
+from ... import opcodes
+from ..datasource import tensor as astensor
+from .core import TensorComplexFFTMixin, TensorStandardFFT, validate_fft
+
+
+class TensorIFFT(TensorStandardFFT, TensorComplexFFTMixin):
+    _op_type_ = opcodes.IFFT
+
+
+def ifft(a, n=None, axis=-1, norm=None):
+    """
+    Compute the one-dimensional inverse discrete Fourier Transform.
+
+    This function computes the inverse of the one-dimensional *n*-point
+    discrete Fourier transform computed by `fft`.  In other words,
+    ``ifft(fft(a)) == a`` to within numerical accuracy.
+    For a general description of the algorithm and definitions,
+    see `mt.fft`.
+
+    The input should be ordered in the same way as is returned by `fft`,
+    i.e.,
+
+    * ``a[0]`` should contain the zero frequency term,
+    * ``a[1:n//2]`` should contain the positive-frequency terms,
+    * ``a[n//2 + 1:]`` should contain the negative-frequency terms, in
+      increasing order starting from the most negative frequency.
+
+    For an even number of input points, ``A[n//2]`` represents the sum of
+    the values at the positive and negative Nyquist frequencies, as the two
+    are aliased together. See `numpy.fft` for details.
+
+    Parameters
+    ----------
+    a : array_like
+        Input tensor, can be complex.
+    n : int, optional
+        Length of the transformed axis of the output.
+        If `n` is smaller than the length of the input, the input is cropped.
+        If it is larger, the input is padded with zeros.  If `n` is not given,
+        the length of the input along the axis specified by `axis` is used.
+        See notes about padding issues.
+    axis : int, optional
+        Axis over which to compute the inverse DFT.  If not given, the last
+        axis is used.
+    norm : {None, "ortho"}, optional
+        Normalization mode (see `numpy.fft`). Default is None.
+
+    Returns
+    -------
+    out : complex Tensor
+        The truncated or zero-padded input, transformed along the axis
+        indicated by `axis`, or the last one if `axis` is not specified.
+
+    Raises
+    ------
+    IndexError
+        If `axes` is larger than the last axis of `a`.
+
+    See Also
+    --------
+    mt.fft : An introduction, with definitions and general explanations.
+    fft : The one-dimensional (forward) FFT, of which `ifft` is the inverse
+    ifft2 : The two-dimensional inverse FFT.
+    ifftn : The n-dimensional inverse FFT.
+
+    Notes
+    -----
+    If the input parameter `n` is larger than the size of the input, the input
+    is padded by appending zeros at the end.  Even though this is the common
+    approach, it might lead to surprising results.  If a different padding is
+    desired, it must be performed before calling `ifft`.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.fft.ifft([0, 4, 0, 0]).execute()
+    array([ 1.+0.j,  0.+1.j, -1.+0.j,  0.-1.j])
+
+    Create and plot a band-limited signal with random phases:
+
+    >>> import matplotlib.pyplot as plt
+    >>> t = mt.arange(400)
+    >>> n = mt.zeros((400,), dtype=complex)
+    >>> n[40:60] = mt.exp(1j*mt.random.uniform(0, 2*mt.pi, (20,)))
+    >>> s = mt.fft.ifft(n)
+    >>> plt.plot(t.execute(), s.real.execute(), 'b-', t.execute(), s.imag.execute(), 'r--')
+    ...
+    >>> plt.legend(('real', 'imaginary'))
+    ...
+    >>> plt.show()
+
+    """
+    a = astensor(a)
+    validate_fft(a, axis, norm)
+    cplx_type = np.complex_ if hasattr(np, "complex_") else np.complex128
+    op = TensorIFFT(n=n, axis=axis, norm=norm, dtype=np.dtype(cplx_type))
+    return op(a)

maxframe/tensor/fft/ifft2.py

@@ -0,0 +1,115 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+
+from ... import opcodes
+from ..datasource import tensor as astensor
+from .core import TensorComplexFFTNMixin, TensorStandardFFTN, validate_fftn
+
+
+class TensorIFFT2(TensorStandardFFTN, TensorComplexFFTNMixin):
+    _op_type_ = opcodes.IFFT2
+
+
+def ifft2(a, s=None, axes=(-2, -1), norm=None):
+    """
+    Compute the 2-dimensional inverse discrete Fourier Transform.
+
+    This function computes the inverse of the 2-dimensional discrete Fourier
+    Transform over any number of axes in an M-dimensional array by means of
+    the Fast Fourier Transform (FFT).  In other words, ``ifft2(fft2(a)) == a``
+    to within numerical accuracy.  By default, the inverse transform is
+    computed over the last two axes of the input array.
+
+    The input, analogously to `ifft`, should be ordered in the same way as is
+    returned by `fft2`, i.e. it should have the term for zero frequency
+    in the low-order corner of the two axes, the positive frequency terms in
+    the first half of these axes, the term for the Nyquist frequency in the
+    middle of the axes and the negative frequency terms in the second half of
+    both axes, in order of decreasingly negative frequency.
+
+    Parameters
+    ----------
+    a : array_like
+        Input tensor, can be complex.
+    s : sequence of ints, optional
+        Shape (length of each axis) of the output (``s[0]`` refers to axis 0,
+        ``s[1]`` to axis 1, etc.).  This corresponds to `n` for ``ifft(x, n)``.
+        Along each axis, if the given shape is smaller than that of the input,
+        the input is cropped.  If it is larger, the input is padded with zeros.
+        if `s` is not given, the shape of the input along the axes specified
+        by `axes` is used.  See notes for issue on `ifft` zero padding.
+    axes : sequence of ints, optional
+        Axes over which to compute the FFT.  If not given, the last two
+        axes are used.  A repeated index in `axes` means the transform over
+        that axis is performed multiple times.  A one-element sequence means
+        that a one-dimensional FFT is performed.
+    norm : {None, "ortho"}, optional
+        Normalization mode (see `mt.fft`). Default is None.
+
+    Returns
+    -------
+    out : complex Tensor
+        The truncated or zero-padded input, transformed along the axes
+        indicated by `axes`, or the last two axes if `axes` is not given.
+
+    Raises
+    ------
+    ValueError
+        If `s` and `axes` have different length, or `axes` not given and
+        ``len(s) != 2``.
+    IndexError
+        If an element of `axes` is larger than than the number of axes of `a`.
+
+    See Also
+    --------
+    mt.fft : Overall view of discrete Fourier transforms, with definitions
+         and conventions used.
+    fft2 : The forward 2-dimensional FFT, of which `ifft2` is the inverse.
+    ifftn : The inverse of the *n*-dimensional FFT.
+    fft : The one-dimensional FFT.
+    ifft : The one-dimensional inverse FFT.
+
+    Notes
+    -----
+    `ifft2` is just `ifftn` with a different default for `axes`.
+
+    See `ifftn` for details and a plotting example, and `numpy.fft` for
+    definition and conventions used.
+
+    Zero-padding, analogously with `ifft`, is performed by appending zeros to
+    the input along the specified dimension.  Although this is the common
+    approach, it might lead to surprising results.  If another form of zero
+    padding is desired, it must be performed before `ifft2` is called.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = 4 * mt.eye(4)
+    >>> mt.fft.ifft2(a).execute()
+    array([[ 1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j],
+           [ 0.+0.j,  0.+0.j,  0.+0.j,  1.+0.j],
+           [ 0.+0.j,  0.+0.j,  1.+0.j,  0.+0.j],
+           [ 0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j]])
+
+    """
+    if len(axes) != 2:
+        raise ValueError("axes length should be 2")
+    a = astensor(a)
+    axes = validate_fftn(a, s=s, axes=axes, norm=norm)
+    cplx_type = np.complex_ if hasattr(np, "complex_") else np.complex128
+    op = TensorIFFT2(shape=s, axes=axes, norm=norm, dtype=np.dtype(cplx_type))
+    return op(a)

maxframe/tensor/fft/ifftn.py

@@ -0,0 +1,123 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+
+from ... import opcodes
+from ..datasource import tensor as astensor
+from .core import TensorComplexFFTNMixin, TensorStandardFFTN, validate_fftn
+
+
+class TensorIFFTN(TensorStandardFFTN, TensorComplexFFTNMixin):
+    _op_type_ = opcodes.IFFTN
+
+
+def ifftn(a, s=None, axes=None, norm=None):
+    """
+    Compute the N-dimensional inverse discrete Fourier Transform.
+
+    This function computes the inverse of the N-dimensional discrete
+    Fourier Transform over any number of axes in an M-dimensional tensor by
+    means of the Fast Fourier Transform (FFT).  In other words,
+    ``ifftn(fftn(a)) == a`` to within numerical accuracy.
+    For a description of the definitions and conventions used, see `mt.fft`.
+
+    The input, analogously to `ifft`, should be ordered in the same way as is
+    returned by `fftn`, i.e. it should have the term for zero frequency
+    in all axes in the low-order corner, the positive frequency terms in the
+    first half of all axes, the term for the Nyquist frequency in the middle
+    of all axes and the negative frequency terms in the second half of all
+    axes, in order of decreasingly negative frequency.
+
+    Parameters
+    ----------
+    a : array_like
+        Input tensor, can be complex.
+    s : sequence of ints, optional
+        Shape (length of each transformed axis) of the output
+        (``s[0]`` refers to axis 0, ``s[1]`` to axis 1, etc.).
+        This corresponds to ``n`` for ``ifft(x, n)``.
+        Along any axis, if the given shape is smaller than that of the input,
+        the input is cropped.  If it is larger, the input is padded with zeros.
+        if `s` is not given, the shape of the input along the axes specified
+        by `axes` is used.  See notes for issue on `ifft` zero padding.
+    axes : sequence of ints, optional
+        Axes over which to compute the IFFT.  If not given, the last ``len(s)``
+        axes are used, or all axes if `s` is also not specified.
+        Repeated indices in `axes` means that the inverse transform over that
+        axis is performed multiple times.
+    norm : {None, "ortho"}, optional
+        Normalization mode (see `mt.fft`). Default is None.
+
+    Returns
+    -------
+    out : complex Tensor
+        The truncated or zero-padded input, transformed along the axes
+        indicated by `axes`, or by a combination of `s` or `a`,
+        as explained in the parameters section above.
+
+    Raises
+    ------
+    ValueError
+        If `s` and `axes` have different length.
+    IndexError
+        If an element of `axes` is larger than than the number of axes of `a`.
+
+    See Also
+    --------
+    mt.fft : Overall view of discrete Fourier transforms, with definitions
+         and conventions used.
+    fftn : The forward *n*-dimensional FFT, of which `ifftn` is the inverse.
+    ifft : The one-dimensional inverse FFT.
+    ifft2 : The two-dimensional inverse FFT.
+    ifftshift : Undoes `fftshift`, shifts zero-frequency terms to beginning
+        of tensor.
+
+    Notes
+    -----
+    See `mt.fft` for definitions and conventions used.
+
+    Zero-padding, analogously with `ifft`, is performed by appending zeros to
+    the input along the specified dimension.  Although this is the common
+    approach, it might lead to surprising results.  If another form of zero
+    padding is desired, it must be performed before `ifftn` is called.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.eye(4)
+    >>> mt.fft.ifftn(mt.fft.fftn(a, axes=(0,)), axes=(1,)).execute()
+    array([[ 1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j],
+           [ 0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j],
+           [ 0.+0.j,  0.+0.j,  1.+0.j,  0.+0.j],
+           [ 0.+0.j,  0.+0.j,  0.+0.j,  1.+0.j]])
+
+
+    Create and plot an image with band-limited frequency content:
+
+    >>> import matplotlib.pyplot as plt
+    >>> n = mt.zeros((200,200), dtype=complex)
+    >>> n[60:80, 20:40] = mt.exp(1j*mt.random.uniform(0, 2*mt.pi, (20, 20)))
+    >>> im = mt.fft.ifftn(n).real
+    >>> plt.imshow(im.execute())
+    <matplotlib.image.AxesImage object at 0x...>
+    >>> plt.show()
+
+    """
+    a = astensor(a)
+    axes = validate_fftn(a, s=s, axes=axes, norm=norm)
+    cplx_type = np.complex_ if hasattr(np, "complex_") else np.complex128
+    op = TensorIFFTN(shape=s, axes=axes, norm=norm, dtype=np.dtype(cplx_type))
+    return op(a)

maxframe/tensor/fft/ifftshift.py

@@ -0,0 +1,73 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+
+from ... import opcodes
+from ..datasource import tensor as astensor
+from .core import TensorFFTShiftBase, TensorFFTShiftMixin
+
+
+class TensorIFFTShift(TensorFFTShiftBase, TensorFFTShiftMixin):
+    _op_type_ = opcodes.IFFTSHIFT
+
+    @classmethod
+    def _is_inverse(cls):
+        return True
+
+    def __call__(self, x):
+        return self.new_tensor([x], x.shape)
+
+
+def ifftshift(x, axes=None):
+    """
+    The inverse of `fftshift`. Although identical for even-length `x`, the
+    functions differ by one sample for odd-length `x`.
+
+    Parameters
+    ----------
+    x : array_like
+        Input tensor.
+    axes : int or shape tuple, optional
+        Axes over which to calculate.  Defaults to None, which shifts all axes.
+
+    Returns
+    -------
+    y : Tensor
+        The shifted tensor.
+
+    See Also
+    --------
+    fftshift : Shift zero-frequency component to the center of the spectrum.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> freqs = mt.fft.fftfreq(9, d=1./9).reshape(3, 3)
+    >>> freqs.execute()
+    array([[ 0.,  1.,  2.],
+           [ 3.,  4., -4.],
+           [-3., -2., -1.]])
+    >>> mt.fft.ifftshift(mt.fft.fftshift(freqs)).execute()
+    array([[ 0.,  1.,  2.],
+           [ 3.,  4., -4.],
+           [-3., -2., -1.]])
+
+    """
+    x = astensor(x)
+    dtype = np.fft.ifftshift(np.empty((1,) * max(1, x.ndim), dtype=x.dtype)).dtype
+    axes = TensorIFFTShift._process_axes(x, axes)
+    op = TensorIFFTShift(axes=axes, dtype=dtype)
+    return op(x)

maxframe/tensor/fft/ihfft.py

@@ -0,0 +1,93 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+
+from ... import opcodes
+from ..datasource import tensor as astensor
+from .core import TensorFFTMixin, TensorHermitianFFT, validate_fft
+
+
+class TensorIHFFT(TensorHermitianFFT, TensorFFTMixin):
+    _op_type_ = opcodes.IHFFT
+
+    @classmethod
+    def _get_shape(cls, op, shape):
+        new_shape = list(shape)
+        shape = op.n if op.n is not None else shape[op.axis]
+        if shape % 2 == 0:
+            shape = (shape // 2) + 1
+        else:
+            shape = (shape + 1) // 2
+        new_shape[op.axis] = shape
+        return tuple(new_shape)
+
+
+def ihfft(a, n=None, axis=-1, norm=None):
+    """
+    Compute the inverse FFT of a signal that has Hermitian symmetry.
+
+    Parameters
+    ----------
+    a : array_like
+        Input tensor.
+    n : int, optional
+        Length of the inverse FFT, the number of points along
+        transformation axis in the input to use.  If `n` is smaller than
+        the length of the input, the input is cropped.  If it is larger,
+        the input is padded with zeros. If `n` is not given, the length of
+        the input along the axis specified by `axis` is used.
+    axis : int, optional
+        Axis over which to compute the inverse FFT. If not given, the last
+        axis is used.
+    norm : {None, "ortho"}, optional
+        Normalization mode (see `numpy.fft`). Default is None.
+
+    Returns
+    -------
+    out : complex Tensor
+        The truncated or zero-padded input, transformed along the axis
+        indicated by `axis`, or the last one if `axis` is not specified.
+        The length of the transformed axis is ``n//2 + 1``.
+
+    See also
+    --------
+    hfft, irfft
+
+    Notes
+    -----
+    `hfft`/`ihfft` are a pair analogous to `rfft`/`irfft`, but for the
+    opposite case: here the signal has Hermitian symmetry in the time
+    domain and is real in the frequency domain. So here it's `hfft` for
+    which you must supply the length of the result if it is to be odd:
+
+    * even: ``ihfft(hfft(a, 2*len(a) - 2) == a``, within roundoff error,
+    * odd: ``ihfft(hfft(a, 2*len(a) - 1) == a``, within roundoff error.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> spectrum = mt.array([ 15, -4, 0, -1, 0, -4])
+    >>> mt.fft.ifft(spectrum).execute()
+    array([ 1.+0.j,  2.-0.j,  3.+0.j,  4.+0.j,  3.+0.j,  2.-0.j])
+    >>> mt.fft.ihfft(spectrum).execute()
+    array([ 1.-0.j,  2.-0.j,  3.-0.j,  4.-0.j])
+
+    """
+    a = astensor(a)
+    validate_fft(a, axis=axis, norm=norm)
+    cplx_type = np.complex_ if hasattr(np, "complex_") else np.complex128
+    op = TensorIHFFT(n=n, axis=axis, norm=norm, dtype=np.dtype(cplx_type))
+    return op(a)