maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/fft/core.py

@@ -0,0 +1,168 @@
+# 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.
+
+from collections.abc import Iterable
+
+from ...serialization.serializables import (
+    FieldTypes,
+    Int32Field,
+    Int64Field,
+    StringField,
+    TupleField,
+)
+from ..operators import TensorHasInput, TensorOperatorMixin
+from ..utils import validate_axis
+
+
+class TensorFFTBaseMixin(TensorOperatorMixin):
+    __slots__ = ()
+
+    @classmethod
+    def _get_shape(cls, op, shape):
+        raise NotImplementedError
+
+    def __call__(self, a, order=None):
+        shape = self._get_shape(self, a.shape)
+        order = a.order if order is None else order
+        return self.new_tensor([a], shape, order=order)
+
+
+class TensorFFTMixin(TensorFFTBaseMixin):
+    __slots__ = ()
+
+
+class TensorComplexFFTMixin(TensorFFTMixin):
+    @classmethod
+    def _get_shape(cls, op, shape):
+        new_shape = list(shape)
+        if op.n is not None:
+            new_shape[op.axis] = op.n
+        return tuple(new_shape)
+
+
+def validate_fft(tensor, axis=-1, norm=None):
+    validate_axis(tensor.ndim, axis)
+    if norm is not None and norm not in ("ortho",):
+        raise ValueError(f'Invalid norm value {norm}, should be None or "ortho"')
+
+
+class TensorFFTNMixin(TensorFFTBaseMixin):
+    @staticmethod
+    def _merge_shape(op, shape):
+        new_shape = list(shape)
+        if op.shape is not None:
+            for ss, axis in zip(op.shape, op.axes):
+                new_shape[axis] = ss
+        return new_shape
+
+
+class TensorComplexFFTNMixin(TensorFFTNMixin):
+    @classmethod
+    def _get_shape(cls, op, shape):
+        return tuple(cls._merge_shape(op, shape))
+
+
+class TensorRealFFTNMixin(TensorFFTNMixin):
+    @classmethod
+    def _get_shape(cls, op, shape):
+        new_shape = cls._merge_shape(op, shape)
+        new_shape[op.axes[-1]] = new_shape[op.axes[-1]] // 2 + 1
+        return tuple(new_shape)
+
+
+class TensorRealIFFTNMixin(TensorFFTNMixin):
+    @classmethod
+    def _get_shape(cls, op, shape):
+        new_shape = list(shape)
+        new_shape[op.axes[-1]] = 2 * (new_shape[op.axes[-1]] - 1)
+        return tuple(cls._merge_shape(op, new_shape))
+
+
+def validate_fftn(tensor, s=None, axes=None, norm=None):
+    if axes is None:
+        if s is None:
+            axes = tuple(range(tensor.ndim))
+        else:
+            axes = tuple(range(len(s)))
+    else:
+        for axis in axes:
+            validate_axis(tensor.ndim, axis)
+        if len(set(axes)) < len(axes):
+            raise ValueError("Duplicate axes not allowed")
+
+    if norm is not None and norm not in ("ortho",):
+        raise ValueError(f'Invalid norm value {norm}, should be None or "ortho"')
+
+    return axes
+
+
+class TensorFFTShiftMixin(TensorOperatorMixin):
+    __slots__ = ()
+
+    @classmethod
+    def _is_inverse(cls):
+        return False
+
+    @classmethod
+    def _process_axes(cls, x, axes):
+        if axes is None:
+            axes = tuple(range(x.ndim))
+        elif isinstance(axes, Iterable):
+            axes = tuple(axes)
+        else:
+            axes = (axes,)
+
+        return axes
+
+
+class TensorDiscreteFourierTransform(TensorHasInput):
+    __slots__ = ()
+
+
+class TensorBaseFFT(TensorDiscreteFourierTransform):
+    norm = StringField("norm", default=None)
+
+
+class TensorBaseSingleDimensionFFT(TensorBaseFFT):
+    n = Int64Field("n", default=None)
+    axis = Int32Field("axis", default=None)
+
+
+class TensorBaseMultipleDimensionFFT(TensorBaseFFT):
+    shape = TupleField("shape", FieldTypes.int64, default=None)
+    axes = TupleField("axes", FieldTypes.int32, default=None)
+
+
+class TensorStandardFFT(TensorBaseSingleDimensionFFT):
+    pass
+
+
+class TensorStandardFFTN(TensorBaseMultipleDimensionFFT):
+    pass
+
+
+class TensorFFTShiftBase(TensorHasInput):
+    axes = TupleField("axes", FieldTypes.int32, default=None)
+
+
+class TensorRealFFT(TensorBaseSingleDimensionFFT):
+    pass
+
+
+class TensorRealFFTN(TensorBaseMultipleDimensionFFT):
+    pass
+
+
+class TensorHermitianFFT(TensorBaseSingleDimensionFFT):
+    pass

maxframe/tensor/fft/fft.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 TensorComplexFFTMixin, TensorStandardFFT, validate_fft
+
+
+class TensorFFT(TensorStandardFFT, TensorComplexFFTMixin):
+    _op_type_ = opcodes.FFT
+
+
+def fft(a, n=None, axis=-1, norm=None):
+    """
+    Compute the one-dimensional discrete Fourier Transform.
+
+    This function computes the one-dimensional *n*-point discrete Fourier
+    Transform (DFT) with the efficient Fast Fourier Transform (FFT)
+    algorithm [CT].
+
+    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.
+    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 : 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 : for definition of the DFT and conventions used.
+    ifft : The inverse of `fft`.
+    fft2 : The two-dimensional FFT.
+    fftn : The *n*-dimensional FFT.
+    rfftn : The *n*-dimensional FFT of real input.
+    fftfreq : Frequency bins for given FFT parameters.
+
+    Notes
+    -----
+    FFT (Fast Fourier Transform) refers to a way the discrete Fourier
+    Transform (DFT) can be calculated efficiently, by using symmetries in the
+    calculated terms.  The symmetry is highest when `n` is a power of 2, and
+    the transform is therefore most efficient for these sizes.
+
+    The DFT is defined, with the conventions used in this implementation, in
+    the documentation for the `numpy.fft` module.
+
+    References
+    ----------
+    .. [CT] Cooley, James W., and John W. Tukey, 1965, "An algorithm for the
+            machine calculation of complex Fourier series," *Math. Comput.*
+            19: 297-301.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.fft.fft(mt.exp(2j * mt.pi * mt.arange(8) / 8)).execute()
+    array([-2.33486982e-16+1.14423775e-17j,  8.00000000e+00-6.89018570e-16j,
+            2.33486982e-16+2.33486982e-16j,  0.00000000e+00+0.00000000e+00j,
+           -1.14423775e-17+2.33486982e-16j,  0.00000000e+00+1.99159850e-16j,
+            1.14423775e-17+1.14423775e-17j,  0.00000000e+00+0.00000000e+00j])
+
+    In this example, real input has an FFT which is Hermitian, i.e., symmetric
+    in the real part and anti-symmetric in the imaginary part, as described in
+    the `numpy.fft` documentation:
+
+    >>> import matplotlib.pyplot as plt
+    >>> t = mt.arange(256)
+    >>> sp = mt.fft.fft(mt.sin(t))
+    >>> freq = mt.fft.fftfreq(t.shape[-1])
+    >>> plt.plot(freq.execute(), sp.real.execute(), freq.execute(), sp.imag.execute())
+    [<matplotlib.lines.Line2D object at 0x...>, <matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.show()
+
+    """
+    a = astensor(a)
+    validate_fft(a, axis, norm)
+    cplx_type = np.complex_ if hasattr(np, "complex_") else np.complex128
+    op = TensorFFT(n=n, axis=axis, norm=norm, dtype=np.dtype(cplx_type))
+    return op(a)

maxframe/tensor/fft/fft2.py

@@ -0,0 +1,118 @@
+# 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 TensorFFT2(TensorStandardFFTN, TensorComplexFFTNMixin):
+    _op_type_ = opcodes.FFT2
+
+
+def fft2(a, s=None, axes=(-2, -1), norm=None):
+    """
+    Compute the 2-dimensional discrete Fourier Transform
+
+    This function computes the *n*-dimensional discrete Fourier Transform
+    over any axes in an *M*-dimensional array by means of the
+    Fast Fourier Transform (FFT).  By default, the transform is computed over
+    the last two axes of the input array, i.e., a 2-dimensional FFT.
+
+    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 ``fft(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.
+    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.
+    ifft2 : The inverse two-dimensional FFT.
+    fft : The one-dimensional FFT.
+    fftn : The *n*-dimensional FFT.
+    fftshift : Shifts zero-frequency terms to the center of the array.
+        For two-dimensional input, swaps first and third quadrants, and second
+        and fourth quadrants.
+
+    Notes
+    -----
+    `fft2` is just `fftn` with a different default for `axes`.
+
+    The output, analogously to `fft`, contains the term for zero frequency in
+    the low-order corner of the transformed 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
+    the axes, in order of decreasingly negative frequency.
+
+    See `fftn` for details and a plotting example, and `mt.fft` for
+    definitions and conventions used.
+
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.mgrid[:5, :5][0]
+    >>> mt.fft.fft2(a).execute()
+    array([[ 50.0 +0.j        ,   0.0 +0.j        ,   0.0 +0.j        ,
+              0.0 +0.j        ,   0.0 +0.j        ],
+           [-12.5+17.20477401j,   0.0 +0.j        ,   0.0 +0.j        ,
+              0.0 +0.j        ,   0.0 +0.j        ],
+           [-12.5 +4.0614962j ,   0.0 +0.j        ,   0.0 +0.j        ,
+              0.0 +0.j        ,   0.0 +0.j        ],
+           [-12.5 -4.0614962j ,   0.0 +0.j        ,   0.0 +0.j        ,
+                0.0 +0.j        ,   0.0 +0.j        ],
+           [-12.5-17.20477401j,   0.0 +0.j        ,   0.0 +0.j        ,
+              0.0 +0.j        ,   0.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 = TensorFFT2(shape=s, axes=axes, norm=norm, dtype=np.dtype(cplx_type))
+    return op(a)

maxframe/tensor/fft/fftfreq.py

@@ -0,0 +1,80 @@
+# 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 ...serialization.serializables import Float64Field, Int32Field
+from ..core import TensorOrder
+from ..operators import TensorOperator, TensorOperatorMixin
+
+
+class TensorFFTFreq(TensorOperator, TensorOperatorMixin):
+    _op_type_ = opcodes.FFTFREQ
+
+    n = Int32Field("n")
+    d = Float64Field("d")
+
+    def __call__(self, chunk_size=None):
+        shape = (self.n,)
+        return self.new_tensor(
+            None, shape, raw_chunk_size=chunk_size, order=TensorOrder.C_ORDER
+        )
+
+
+def fftfreq(n, d=1.0, gpu=None, chunk_size=None):
+    """
+    Return the Discrete Fourier Transform sample frequencies.
+
+    The returned float tensor `f` contains the frequency bin centers in cycles
+    per unit of the sample spacing (with zero at the start).  For instance, if
+    the sample spacing is in seconds, then the frequency unit is cycles/second.
+
+    Given a window length `n` and a sample spacing `d`::
+
+      f = [0, 1, ...,   n/2-1,     -n/2, ..., -1] / (d*n)   if n is even
+      f = [0, 1, ..., (n-1)/2, -(n-1)/2, ..., -1] / (d*n)   if n is odd
+
+    Parameters
+    ----------
+    n : int
+        Window length.
+    d : scalar, optional
+        Sample spacing (inverse of the sampling rate). Defaults to 1.
+    gpu : bool, optional
+        Allocate the tensor on GPU if True, False as default
+    chunk_size : int or tuple of int or tuple of ints, optional
+        Desired chunk size on each dimension
+
+    Returns
+    -------
+    f : Tensor
+        Array of length `n` containing the sample frequencies.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> signal = mt.array([-2, 8, 6, 4, 1, 0, 3, 5], dtype=float)
+    >>> fourier = mt.fft.fft(signal)
+    >>> n = signal.size
+    >>> timestep = 0.1
+    >>> freq = mt.fft.fftfreq(n, d=timestep)
+    >>> freq.execute()
+    array([ 0.  ,  1.25,  2.5 ,  3.75, -5.  , -3.75, -2.5 , -1.25])
+
+    """
+    n, d = int(n), float(d)
+    op = TensorFFTFreq(n=n, d=d, dtype=np.dtype(float), gpu=gpu)
+    return op(chunk_size)

maxframe/tensor/fft/fftn.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 TensorFFTN(TensorStandardFFTN, TensorComplexFFTNMixin):
+    _op_type_ = opcodes.FFTN
+
+
+def fftn(a, s=None, axes=None, norm=None):
+    """
+    Compute the N-dimensional discrete Fourier Transform.
+
+    This function computes the *N*-dimensional discrete Fourier Transform over
+    any number of axes in an *M*-dimensional tensor by means of the Fast Fourier
+    Transform (FFT).
+
+    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 ``fft(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.
+    axes : sequence of ints, optional
+        Axes over which to compute the FFT.  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 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` and `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.
+    ifftn : The inverse of `fftn`, the inverse *n*-dimensional FFT.
+    fft : The one-dimensional FFT, with definitions and conventions used.
+    rfftn : The *n*-dimensional FFT of real input.
+    fft2 : The two-dimensional FFT.
+    fftshift : Shifts zero-frequency terms to centre of tensor
+
+    Notes
+    -----
+    The output, analogously to `fft`, contains the term for zero frequency in
+    the low-order corner of all axes, 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.
+
+    See `mt.fft` for details, definitions and conventions used.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.mgrid[:3, :3, :3][0]
+    >>> mt.fft.fftn(a, axes=(1, 2)).execute()
+    array([[[  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]],
+           [[  9.+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]],
+           [[ 18.+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]]])
+    >>> mt.fft.fftn(a, (2, 2), axes=(0, 1)).execute()
+    array([[[ 2.+0.j,  2.+0.j,  2.+0.j],
+            [ 0.+0.j,  0.+0.j,  0.+0.j]],
+           [[-2.+0.j, -2.+0.j, -2.+0.j],
+            [ 0.+0.j,  0.+0.j,  0.+0.j]]])
+
+    >>> import matplotlib.pyplot as plt
+    >>> [X, Y] = mt.meshgrid(2 * mt.pi * mt.arange(200) / 12,
+    ...                      2 * mt.pi * mt.arange(200) / 34)
+    >>> S = mt.sin(X) + mt.cos(Y) + mt.random.uniform(0, 1, X.shape)
+    >>> FS = mt.fft.fftn(S)
+    >>> plt.imshow(mt.log(mt.abs(mt.fft.fftshift(FS))**2).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 = TensorFFTN(shape=s, axes=axes, norm=norm, dtype=np.dtype(cplx_type))
+    return op(a)

maxframe/tensor/fft/fftshift.py

@@ -0,0 +1,79 @@
+# 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 TensorFFTShift(TensorFFTShiftBase, TensorFFTShiftMixin):
+    _op_type_ = opcodes.FFTSHIFT
+
+    def __call__(self, x):
+        return self.new_tensor([x], x.shape)
+
+
+def fftshift(x, axes=None):
+    """
+    Shift the zero-frequency component to the center of the spectrum.
+
+    This function swaps half-spaces for all axes listed (defaults to all).
+    Note that ``y[0]`` is the Nyquist component only if ``len(x)`` is even.
+
+    Parameters
+    ----------
+    x : array_like
+        Input tensor.
+    axes : int or shape tuple, optional
+        Axes over which to shift.  Default is None, which shifts all axes.
+
+    Returns
+    -------
+    y : Tensor
+        The shifted tensor.
+
+    See Also
+    --------
+    ifftshift : The inverse of `fftshift`.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> freqs = mt.fft.fftfreq(10, 0.1)
+    >>> freqs.execute()
+    array([ 0.,  1.,  2.,  3.,  4., -5., -4., -3., -2., -1.])
+    >>> mt.fft.fftshift(freqs).execute()
+    array([-5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.])
+
+    Shift the zero-frequency component only along the second axis:
+
+    >>> 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.fftshift(freqs, axes=(1,)).execute()
+    array([[ 2.,  0.,  1.],
+           [-4.,  3.,  4.],
+           [-1., -3., -2.]])
+
+    """
+    x = astensor(x)
+    dtype = np.fft.fftshift(np.empty((1,) * max(1, x.ndim), dtype=x.dtype)).dtype
+    axes = TensorFFTShift._process_axes(x, axes)
+    op = TensorFFTShift(axes=axes, dtype=dtype)
+    return op(x)