SciPy 1.12 中文文档（六）

原文：docs.scipy.org/doc/scipy-1.12.0/index.html

scipy.fft.ifftn

docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.ifftn.html#scipy.fft.ifftn

scipy.fft.ifftn(x, s=None, axes=None, norm=None, overwrite_x=False, workers=None, *, plan=None)

计算 N 维逆离散傅里叶变换。

此函数通过快速傅里叶变换（FFT）计算 M-D 数组中任意数量轴上的 N 维离散傅里叶变换的逆变换。换句话说，ifftn(fftn(x)) == x 在数值精度范围内成立。

输入与 ifft 类似，应以与由 fftn 返回的相同方式排序，即应在低阶角落中具有所有轴的零频率项，所有轴的前半部分中的正频率项，所有轴的中点处的奈奎斯特频率项，所有轴的后半部分中的负频率项，按照递减负频率顺序排列。

参数：

x array_like

输入数组，可以是复数。

s 整数序列，可选

输出的形状（每个转换轴的长度）（s[0] 表示轴 0，s[1] 表示轴 1，依此类推）。这对应于 ifft(x, n) 中的 n。沿着任意轴，如果给定的形状小于输入的形状，则输入会被裁剪。如果大于输入的形状，则用零填充输入。如果没有给出 s，则使用由 axes 指定的轴上的输入形状。有关 ifft 的零填充问题，请参见注释。

axes 整数序列，可选

要计算逆离散傅里叶变换（IFFT）的轴。如果未给出，则使用最后 len(s) 个轴，或者如果也未指定 s，则使用所有轴。

norm {"backward", "ortho", "forward"}，可选

归一化模式（参见 fft）。默认为“backward”。

overwrite_x 布尔值，可选

如果为 True，则 x 的内容可以被破坏；默认为 False。详见 fft。

workers 整数，可选

并行计算的最大工作线程数。如果为负数，则值从 os.cpu_count() 循环回来。详见 fft。

plan 对象，可选

此参数保留用于传递由下游 FFT 供应商提供的预计算计划。当前在 SciPy 中未使用。

新版本 1.5.0 中添加。

返回：

out 复数 ndarray

被截断或零填充的输入，沿着由 axes 指示的轴进行变换，或者根据上面参数部分中解释的 s 或 x 的组合。

Raises:

ValueError

如果 s 和 axes 长度不同。

IndexError

如果 axes 的元素大于 x 的轴数。

See also

fftn

前向 N 维 FFT，其中 ifftn 是其逆变换。

ifft

一维逆 FFT。

ifft2

二维逆 FFT。

ifftshift

撤消fftshift，将零频率项移至数组开头。

注意事项

Zero-padding，类似于ifft，是通过在指定维度的输入末尾添加零来完成的。虽然这是常见的方法，但可能导致令人惊讶的结果。如果希望使用另一种形式的零填充，则必须在调用ifftn之前执行。

示例

>>> import scipy.fft
>>> import numpy as np
>>> x = np.eye(4)
>>> scipy.fft.ifftn(scipy.fft.fftn(x, axes=(0,)), axes=(1,))
array([[1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j], # may vary
 [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]]) 

创建并绘制具有带限频率内容的图像：

>>> import matplotlib.pyplot as plt
>>> rng = np.random.default_rng()
>>> n = np.zeros((200,200), dtype=complex)
>>> n[60:80, 20:40] = np.exp(1j*rng.uniform(0, 2*np.pi, (20, 20)))
>>> im = scipy.fft.ifftn(n).real
>>> plt.imshow(im)
<matplotlib.image.AxesImage object at 0x...>
>>> plt.show() 

scipy.fft.rfft

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.rfft.html#scipy.fft.rfft

scipy.fft.rfft(x, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, *, plan=None)

计算实输入的一维离散傅里叶变换。

此函数通过称为快速傅里叶变换（FFT）的高效算法，计算实值数组的一维 n 点离散傅里叶变换（DFT）。

参数：

x：array_like

输入数组

n：int，可选

转换轴上的点数，以用于输入。如果 n 小于输入的长度，则截取输入。如果 n 大于长度，则用零填充输入。如果未给出 n，则使用由 axis 指定的轴上的输入长度。

axis：int，可选

FFT 计算的轴。如果未给出，则使用最后一个轴。

norm：{“backward”，“ortho”，“forward”}，可选

归一化模式（见 fft）。默认为“backward”。

overwrite_x：bool，可选

如果为 True，则可以破坏 x 的内容；默认为 False。有关更多详情，请参见 fft。

workers：int，可选

用于并行计算的最大工作进程数。如果为负数，则从 os.cpu_count() 回绕。有关更多详情，请参见 fft。

plan：object，可选

此参数保留用于传递由下游 FFT 供应商提供的预先计算的计划。目前在 SciPy 中未使用。

新版本 1.5.0 中新增。

返回：

out：复数 ndarray

被截断或以零填充的输入，沿 axis 指示的轴转换，或者如果未指定 axis，则为最后一个。如果 n 为偶数，则转换轴的长度为 (n/2)+1。如果 n 为奇数，则长度为 (n+1)/2。

引发：

IndexError

如果 axis 大于 a 的最后一个轴。

另请参见

irfft

rfft 的逆。

fft

一般（复杂）输入的一维 FFT。

fftn

N-D FFT。

rfft2

实输入的二维 FFT。

rfftn

实输入的 N-D FFT。

注意

当对纯实数输入计算 DFT 时，输出为厄米共轭对称，即负频率项只是对应正频率项的复共轭，并且因此负频率项是多余的。此函数不计算负频率项，因此输出的转换轴的长度为 n//2 + 1。

当 X = rfft(x) 且 fs 为采样频率时，X[0] 包含零频率项 0*fs，由于厄米共轭对称性而为实数。

如果n是偶数，A[-1] 包含代表正负奈奎斯特频率（+fs/2 和 -fs/2）的项，并且必须是纯实数。如果n是奇数，则在 fs/2 处没有项；A[-1] 包含最大的正频率（fs/2*(n-1)/n），在一般情况下是复数。

如果输入a包含虚部，则会被静默丢弃。

例子

>>> import scipy.fft
>>> scipy.fft.fft([0, 1, 0, 0])
array([ 1.+0.j,  0.-1.j, -1.+0.j,  0.+1.j]) # may vary
>>> scipy.fft.rfft([0, 1, 0, 0])
array([ 1.+0.j,  0.-1.j, -1.+0.j]) # may vary 

注意，在实数输入情况下，fft 输出的最后一个元素是第二个元素的复共轭。对于rfft，利用这种对称性只计算非负频率项。

scipy.fft.irfft

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.irfft.html#scipy.fft.irfft

scipy.fft.irfft(x, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, *, plan=None)

计算rfft的逆。

此函数计算由rfft计算的实数输入的一维n点离散傅里叶变换的逆变换。换句话说，irfft(rfft(x), len(x)) == x在数值精度内成立。（有关为什么这里需要len(a)的说明，请参见下面的注释。）

输入预期为由rfft返回的形式，即零频率实部后跟以频率增加顺序排列的复正频率项。由于实数输入的离散傅里叶变换具有埃尔米特对称性，负频率项被视为相应正频率项的复共轭。

参数：

x类似数组

输入数组。

n整数，可选

输出轴的变换长度。对于n个输出点，需要n//2+1个输入点。如果输入比此更长，则会截断。如果比此更短，则会用零填充。如果未给出n，则取为2*(m-1)，其中m为由axis指定的输入轴的长度。

axis整数，可选

用于计算逆 FFT 的轴。如果未给出，则使用最后一个轴。

norm{“backward”, “ortho”, “forward”}，可选

归一化模式（请参见fft）。默认为“backward”。

overwrite_x布尔值，可选

如果为 True，可以破坏x的内容；默认为 False。有关更多详细信息，请参见fft。

workers整数，可选

用于并行计算的最大工作者数。如果为负数，则值从os.cpu_count()中循环。有关更多详细信息，请参见fft。

plan对象，可选

此参数保留以向下游 FFT 供应商提供的预先计算的计划。目前在 SciPy 中未使用。

自 1.5.0 版开始。

返回：

outndarray

截断或零填充的输入，在axis指示的轴上进行变换，如果未指定axis，则在最后一个轴上进行变换。变换轴的长度为n，或者如果未给出n，则为输入的变换轴的长度的2*(m-1)。要获取奇数输出点，必须指定n。

引发：

IndexError

如果axis大于x的最后一个轴。

另请参阅

rfft

实数输入的一维 FFT，其中irfft是其逆变换。

fft

一维 FFT。

irfft2

实输入的 2D FFT 的逆变换。

irfftn

实输入的 N 维 FFT 的逆变换。

注意事项

返回x的实值n点逆离散傅里叶变换，其中x包含共轭对称序列的非负频率项。n是结果的长度，而不是输入的长度。

如果指定一个n，以便a必须进行零填充或截断，则额外/移除的值将以高频率添加/移除。因此，可以通过傅里叶插值将系列重新采样为m点：a_resamp = irfft(rfft(a), m)。

n的默认值假定输出长度为偶数。根据 Hermitian 对称性，最后一个虚部分量必须为 0，因此被忽略。为了避免丢失信息，必须提供正确的实输入长度。

示例

>>> import scipy.fft
>>> scipy.fft.ifft([1, -1j, -1, 1j])
array([0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j]) # may vary
>>> scipy.fft.irfft([1, -1j, -1])
array([0.,  1.,  0.,  0.]) 

注意输入普通ifft中的最后一项是第二项的复共轭，并且输出处处都有零虚部。调用irfft时，未指定负频率，输出数组纯实数。

scipy.fft.rfft

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.rfft.html#scipy.fft.rfft

scipy.fft.rfft(x, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, *, plan=None)

为实输入计算 1-D 离散 Fourier 变换。

此函数通过一种称为快速 Fourier 变换（FFT）的有效算法计算实值数组的 1-D n-点离散 Fourier 变换（DFT）。

参数：

xarray_like

输入数组

nint, 可选

输入中要使用的变换轴上的点数。如果 n 小于输入的长度，则裁剪输入。如果大于输入，则用零填充。如果未给出 n，则使用由 axis 指定的轴的输入长度。

axisint, 可选

计算 FFT 的轴。如果未给出，则使用最后一个轴。

norm{“backward”, “ortho”, “forward”}, 可选

标准化模式（参见 [fft](docs.scipy.org/doc/scipy-1… "scipy.fft.fft"）。默认为“backward”。

overwrite_xbool, 可选

如果为 True，则 x 的内容可以被破坏；默认为 False。详见 fft。

workersint, 可选

并行计算的最大工作线程数。如果为负，则值从 os.cpu_count() 包装。详见 fft。

planobject, 可选

此参数保留用于传递下游 FFT 供应商提供的预先计算的计划。目前在 SciPy 中未使用。

从版本 1.5.0 开始新增。

返回：

out复数 ndarray

沿 axis 指示的轴变换的截断或零填充输入的最后一个。如果 n 是偶数，则转换轴的长度为 (n/2)+1。如果 n 是奇数，则长度为 (n+1)/2。

引发：

IndexError

如果 axis 大于 a 的最后一个轴。

另请参阅

irfft

rfft 的反函数。

fft

一般（复数）输入的 1-D FFT。

fftn

N-D FFT。

rfft2

实输入的 2-D FFT。

rfftn

实输入的 N-D FFT。

注意

当计算纯实数输入的 DFT 时，输出是共轭对称的，即负频率项只是相应正频率项的复共轭，并且负频率项因此是多余的。此函数不计算负频率项，因此输出的转换轴的长度为 n//2 + 1。

当 X = rfft(x) 且 fs 是采样频率时，X[0] 包含零频率项 0*fs，由于 Hermitian 对称性是实数。

如果 n 是偶数，A[-1] 包含代表正负 Nyquist 频率（+fs/2 和 -fs/2）的项，并且还必须是纯实数。如果 n 是奇数，在 fs/2 处没有项；A[-1] 包含最大的正频率（fs/2*(n-1)/n），在一般情况下是复数。

如果输入的 a 包含虚部，则会被默默丢弃。

示例

>>> import scipy.fft
>>> scipy.fft.fft([0, 1, 0, 0])
array([ 1.+0.j,  0.-1.j, -1.+0.j,  0.+1.j]) # may vary
>>> scipy.fft.rfft([0, 1, 0, 0])
array([ 1.+0.j,  0.-1.j, -1.+0.j]) # may vary 

注意在fft输出的最后一个元素是第二个元素的复共轭，对于实数输入。对于rfft，这种对称性被利用来计算仅非负频率项。

scipy.fft.rfft2

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.rfft2.html#scipy.fft.rfft2

scipy.fft.rfft2(x, s=None, axes=(-2, -1), norm=None, overwrite_x=False, workers=None, *, plan=None)

计算实数组的二维 FFT。

参数：

x 数组

输入数组，假定为实数。

s int 序列，可选

FFT 的形状。

axes int 序列，可选

进行 FFT 计算的轴。

norm{“backward”, “ortho”, “forward”}，可选

标准化模式（参见fft）。默认为“backward”。

overwrite_x bool，可选

如果为 True，则可以破坏x的内容；默认值为 False。更多细节请参见fft。

workers int，可选

最大并行计算工作者数量。如果为负数，则从os.cpu_count()中获取值。更多细节请参见fft。

plan 对象，可选

此参数保留供下游 FFT 供应商提供的预计算计划。目前在 SciPy 中未使用。

新增版本为 1.5.0。

返回：

out ndarray

实 2D FFT 的结果。

另请参见

irfft2

实输入的二维 FFT 的逆。

rfft

实输入的一维 FFT。

rfftn

计算实输入的 N 维离散傅里叶变换。

注意事项

实际上这只是rfftn，具有不同的默认行为。更多细节请参见rfftn。

scipy.fft.irfft2

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.irfft2.html#scipy.fft.irfft2

scipy.fft.irfft2(x, s=None, axes=(-2, -1), norm=None, overwrite_x=False, workers=None, *, plan=None)

计算rfft2的逆变换。

参数：

xarray_like

输入数组

s整数序列，可选

逆 FFT 的实输出的形状。

axes整数序列，可选

计算逆 FFT 的轴。默认是最后两个轴。

norm{“backward”, “ortho”, “forward”}，可选

标准化模式（参见fft）。默认为“backward”。

overwrite_xbool，可选

如果为 True，则可以销毁x的内容；默认为 False。有关更多详细信息，请参见fft。

workers整数，可选

并行计算的最大工作线程数。如果为负数，则该值从os.cpu_count()循环。有关更多详细信息，请参见fft。

plan对象，可选

此参数保留用于传递由下游 FFT 供应商提供的预计算计划。目前在 SciPy 中未使用。

自 1.5.0 版本新功能。

返回：

outndarray

逆实 2-D FFT 的结果。

另请参见

rfft2

实输入的二维 FFT。

irfft

实输入的 1-D FFT 的逆变换。

irfftn

N-D FFT 的实输入的逆变换。

注意

实际上是具有不同默认值的irfftn。有关更多详细信息，请参见irfftn。

scipy.fft.rfft2

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.rfft2.html#scipy.fft.rfft2

scipy.fft.rfft2(x, s=None, axes=(-2, -1), norm=None, overwrite_x=False, workers=None, *, plan=None)

计算一个实数组的二维 FFT。

参数：

x数组

输入数组，被视为实数。

s整数序列，可选

FFT 的形状。

axes整数序列，可选

执行 FFT 的轴。

norm{“backward”, “ortho”, “forward”}，可选

归一化模式（参见fft）。默认为“backward”。

overwrite_x布尔值，可选

如果为 True，则可以销毁x的内容；默认为 False。有关更多详情，请参阅fft。

workers整数，可选

最大用于并行计算的工作进程数。如果为负数，则值从os.cpu_count()循环。有关更多详情，请参阅fft。

plan对象，可选

此参数保留用于传递下游 FFT 供应商提供的预计算计划。目前在 SciPy 中未使用。

版本 1.5.0 中的新功能。

返回：

outndarray

实 2-D FFT 的结果。

另请参阅

irfft2

实输入的二维 FFT 的逆。

rfft

实输入的 1-D FFT。

rfftn

计算实输入的 N 维离散傅立叶变换。

注释

这实际上只是具有不同默认行为的rfftn。有关更多详情，请参阅rfftn。

scipy.fft.rfftn

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.rfftn.html#scipy.fft.rfftn

scipy.fft.rfftn(x, s=None, axes=None, norm=None, overwrite_x=False, workers=None, *, plan=None)

计算实输入的 N-D 离散傅里叶变换。

通过快速傅里叶变换（FFT）在 M-D 实数组上计算任意数量轴的 N-D 离散傅里叶变换。默认情况下，所有轴都进行变换，实数变换在最后一个轴上执行，而其余变换为复数。

参数：

xarray_like

输入数组，假定为实数。

sint 序列，可选

使用输入中的每个变换轴的长度（s[0] 指轴 0，s[1] 指轴 1 等）。s 的最后一个元素对应于 rfft(x, n) 的 n，而对于其余轴，它对应于 fft(x, n) 的 n。沿任何轴，如果给定的形状小于输入的形状，则裁剪输入。如果它更大，则用零填充输入。如果没有给出 s，则使用由 axes 指定的轴上的输入形状。

axesint 序列，可选

用于计算 FFT 的轴。如果未给出，则使用最后 len(s) 个轴，或者如果 s 也未指定，则使用所有轴。

norm{“backward”, “ortho”, “forward”}，可选

归一化模式（参见 fft）。默认为 “backward”。

overwrite_xbool，可选

如果为 True，则可以破坏 x 的内容；默认为 False。有关更多详细信息，请参见 fft。

workersint，可选

用于并行计算的最大工作进程数。如果为负数，则该值从 os.cpu_count() 回绕。有关更多详细信息，请参见 fft。

plan对象，可选

此参数保留用于传递由下游 FFT 供应商提供的预计算计划。目前在 SciPy 中未使用。

自版本 1.5.0 新增。

返回：

out复数 ndarray

截断或用零填充的输入，在 axes 指示的轴上变换，或者根据上述参数部分中 s 和 x 的组合变换。最后一个变换轴的长度将为 s[-1]//2+1，而其余变换轴的长度将根据 s 或保持与输入相同。

引发：

ValueError

如果 s 和 axes 长度不同。

IndexError

如果 axes 的元素大于 x 的轴数。

另请参见

irfftn

rfftn 的逆变换，即实输入的 N-D FFT 的逆变换。

fft

1-D FFT，使用的定义和约定。

rfft

实输入的 1-D FFT。

fftn

N-D FFT。

rfft2

二维实数输入的 FFT。

注意事项

对于实数输入的变换是通过rfft在最后一个变换轴上执行，然后通过fftn在剩余轴上执行变换。输出顺序与rfft的最终变换轴相同，并与fftn在剩余变换轴上相同。

查看详细信息，请参阅fft，其中包括使用的定义和约定。

示例

>>> import scipy.fft
>>> import numpy as np
>>> x = np.ones((2, 2, 2))
>>> scipy.fft.rfftn(x)
array([[[8.+0.j,  0.+0.j], # may vary
 [0.+0.j,  0.+0.j]],
 [[0.+0.j,  0.+0.j],
 [0.+0.j,  0.+0.j]]]) 

>>> scipy.fft.rfftn(x, axes=(2, 0))
array([[[4.+0.j,  0.+0.j], # may vary
 [4.+0.j,  0.+0.j]],
 [[0.+0.j,  0.+0.j],
 [0.+0.j,  0.+0.j]]]) 

scipy.fft.irfftn

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.irfftn.html#scipy.fft.irfftn

scipy.fft.irfftn(x, s=None, axes=None, norm=None, overwrite_x=False, workers=None, *, plan=None)

计算rfftn的逆。

此函数通过快速傅里叶变换（FFT）计算 N-D 实数输入的逆离散傅里叶变换，适用于 M-D 数组中的任意轴。换句话说，irfftn(rfftn(x), x.shape) == x在数值精度内成立（a.shape对于irfft也像len(a)一样必要，并且出于同样的原因）。

输入应按照rfftn返回的方式排序，即在最终转换轴的情况下，如同irfft一样，并且沿所有其他轴向ifftn。

参数：

x类数组

输入数组。

sint 序列，可选

输出的形状（每个转换轴的长度）（s[0]指代轴 0，s[1]指代轴 1 等）。s也是沿此轴使用的输入点数，最后一个轴除外，其使用输入的s[-1]//2+1点。沿任何轴，如果由s指示的形状小于输入的形状，则对输入进行裁剪。如果它大于输入，则用零填充。如果未给出s，则使用由轴指定的输入形状。除了最后一个轴，其被认为是2*(m-1)，其中m是沿该轴的输入长度。

axesint 序列，可选

要计算逆 FFT 的轴。如果未给出，则使用最后len(s)轴，如果s也未指定，则使用所有轴。

norm{“backward”, “ortho”, “forward”}，可选

规范化模式（详见fft）。默认为“backward”。

overwrite_xbool，可选

如果为 True，x的内容可以被销毁；默认为 False。详见fft了解更多细节。

workersint，可选

最大工作线程数，用于并行计算。如果为负数，则从os.cpu_count()中循环使用值。详见fft了解更多细节。

plan对象，可选

此参数保留用于传递由下游 FFT 供应商提供的预先计算的计划。目前在 SciPy 中未使用。

自 1.5.0 版本起新增。

返回：

outndarray

截断或零填充的输入，沿着由axes指示的轴或由s或x的组合转换，如上面的参数部分所解释的。每个转换轴的长度由相应的s元素给出，或者如果没有给出s，则在除最后一个轴之外的每个轴上输入的长度。当没有给出s时，在最终转换轴上的输出长度为2*(m-1)，其中m是输入的最终转换轴的长度。为了在最终轴上获得奇数个输出点，必须指定s。

引发：

值错误

如果s和axes的长度不同。

索引错误

如果axes的元素大于x的轴数。

另请参见

实数输入的 n 维逆傅里叶变换

实数输入的正向 N 维 FFT，其中n 维逆傅里叶变换 ifftn是其反向。

傅里叶变换

1-D FFT，使用的定义和惯例。

逆傅里叶变换

实数输入的 1-D FFT 的逆变换。

二维逆傅里叶变换

实数输入的 2-D FFT 的逆变换。

注释

参见傅里叶变换用于定义和惯例。

参见实数输入的 rfft用于定义和惯例。

s的默认值假设最终转换轴上的输出长度为偶数。在执行最终的复数到实数转换时，Hermite 对称性要求该轴上的最后一个虚部分量必须为 0，因此被忽略。为了避免信息丢失，必须提供正确长度的实输入。

示例

>>> import scipy.fft
>>> import numpy as np
>>> x = np.zeros((3, 2, 2))
>>> x[0, 0, 0] = 3 * 2 * 2
>>> scipy.fft.irfftn(x)
array([[[1.,  1.],
 [1.,  1.]],
 [[1.,  1.],
 [1.,  1.]],
 [[1.,  1.],
 [1.,  1.]]]) 

scipy.fft.rfftn

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.rfftn.html#scipy.fft.rfftn

scipy.fft.rfftn(x, s=None, axes=None, norm=None, overwrite_x=False, workers=None, *, plan=None)

计算实数输入的 N-D 离散傅立叶变换。

此函数通过快速傅里叶变换（FFT）计算 M-D 实数组中任意轴上的 N-D 离散傅里叶变换。默认情况下，所有轴都进行变换，实变换在最后一个轴上执行，而其余变换是复数变换。

参数：

xarray_like

输入数组，假设为实数。

ssequence of ints, optional

从输入中使用的形状（沿每个转换轴的长度）。(s[0]表示轴 0，s[1]表示轴 1，依此类推。)s的最后一个元素对应于rfft(x, n)的n，而对于其余轴，则对应于fft(x, n)的n。沿任何轴，如果给定的形状小于输入的形状，则输入被裁剪。如果形状较大，则用零填充输入。如果没有给出s，则使用由axes指定的轴的输入形状。

axessequence of ints, optional

用于计算 FFT 的轴。如果未给出，则使用最后len(s)个轴，或者如果未指定s，则使用所有轴。

norm{“backward”, “ortho”, “forward”}, optional

规范化模式（请参见fft）。默认为“backward”。

overwrite_xbool, optional

如果为 True，则可以销毁x的内容；默认值为 False。更多细节请参见fft。

workersint, optional

并行计算时要使用的最大工作线程数。如果是负数，该值从os.cpu_count()开始循环。更多细节请参见fft。

planobject, optional

此参数保留用于通过下游 FFT 供应商提供的预计算计划。目前在 SciPy 中未使用。

新版 1.5.0。

返回：

outcomplex ndarray

沿axes指示的轴变换的截断或零填充输入，或者根据上述参数部分中的s和x的组合。最后一个转换的轴的长度将为s[-1]//2+1，而其余转换的轴将根据s的长度或保持不变。

引发：

ValueError

如果s和axes的长度不同。

IndexError

如果axes的任何元素大于x的轴数。

另请参阅

irfftn

rfftn的逆变换，即实数输入的 N-D FFT 的逆变换。

fft

1-D FFT，使用的定义和约定。

rfft

实数输入的 1-D FFT。

fftn

N-D FFT。

rfft2

实数输入的二维 FFT。

注意

对于实数输入的变换是在最后一个变换轴上执行，就像rfft那样，然后在剩余的轴上执行变换，就像fftn那样。输出的顺序与最后一个变换轴的rfft相同，对于剩余的变换轴与fftn相同。

参见fft获取详细信息、定义和使用约定。

示例

>>> import scipy.fft
>>> import numpy as np
>>> x = np.ones((2, 2, 2))
>>> scipy.fft.rfftn(x)
array([[[8.+0.j,  0.+0.j], # may vary
 [0.+0.j,  0.+0.j]],
 [[0.+0.j,  0.+0.j],
 [0.+0.j,  0.+0.j]]]) 

>>> scipy.fft.rfftn(x, axes=(2, 0))
array([[[4.+0.j,  0.+0.j], # may vary
 [4.+0.j,  0.+0.j]],
 [[0.+0.j,  0.+0.j],
 [0.+0.j,  0.+0.j]]]) 

scipy.fft.hfft

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.hfft.html#scipy.fft.hfft

scipy.fft.hfft(x, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, *, plan=None)

计算具有埃尔米特对称性的信号的 FFT，即实谱。

参数：

x 类似数组

输入数组。

n 整数，可选

输出轴的变换长度。对于 n 个输出点，需要 n//2 + 1 个输入点。如果输入比这更长，则将截断。如果比这更短，则用零填充。如果未给出 n，则取为 2*(m-1)，其中 m 是由 axis 指定的输入轴的长度。

axis 整数，可选

FFT 计算的轴。如果未指定，则使用最后一个轴。

norm {“backward”, “ortho”, “forward”}，可选

规范化模式（参见 fft）。默认为“backward”。

overwrite_x 布尔值，可选

如果为 True，则可以销毁 x 的内容；默认为 False。详细信息请参见 fft。

workers 整数，可选

用于并行计算的最大工作者数量。如果为负数，则从 os.cpu_count() 回绕。详细信息请参见 fft。

plan 对象，可选

此参数保留用于传递由下游 FFT 供应商提供的预先计算的计划。目前在 SciPy 中未使用。

自版本 1.5.0 新增。

返回：

out ndarray

指定的轴上被截断或用零填充的输入，在 axis 没有指定时为最后一个轴。转换后的轴的长度为 n，或者如果未给出 n，则为 2*m - 2，其中 m 是输入的转换轴的长度。为了获得奇数个输出点，必须指定 n，例如，通常情况下为 2*m - 1。

异常：

索引错误

如果 axis 大于 a 的最后一个轴。

另请参阅

rfft

计算实输入的 1-D FFT。

ihfft

hfft 的逆变换。

hfftn

计算埃尔米特信号的 N-D FFT。

注意

hfft/ihfft 是一对类似于 rfft/irfft 的函数，但适用于相反的情况：这里信号在时间域具有埃尔米特对称性，在频率域是实数。因此，在这里，是 hfft，如果结果长度为奇数，则必须提供结果长度。* 偶数：ihfft(hfft(a, 2*len(a) - 2) == a，在舍入误差范围内，* 奇数：ihfft(hfft(a, 2*len(a) - 1) == a，在舍入误差范围内。

示例

>>> from scipy.fft import fft, hfft
>>> import numpy as np
>>> a = 2 * np.pi * np.arange(10) / 10
>>> signal = np.cos(a) + 3j * np.sin(3 * a)
>>> fft(signal).round(10)
array([ -0.+0.j,   5.+0.j,  -0.+0.j,  15.-0.j,   0.+0.j,   0.+0.j,
 -0.+0.j, -15.-0.j,   0.+0.j,   5.+0.j])
>>> hfft(signal[:6]).round(10) # Input first half of signal
array([  0.,   5.,   0.,  15.,  -0.,   0.,   0., -15.,  -0.,   5.])
>>> hfft(signal, 10)  # Input entire signal and truncate
array([  0.,   5.,   0.,  15.,  -0.,   0.,   0., -15.,  -0.,   5.]) 

scipy.fft.ihfft

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.ihfft.html#scipy.fft.ihfft

scipy.fft.ihfft(x, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, *, plan=None)

计算具有 Hermitian 对称性的信号的逆 FFT。

参数：

x类似数组

输入数组。

nint，可选

逆 FFT 的长度，要使用输入轴上的点数。如果n小于输入的长度，则截断输入。如果n大于长度，则用零填充输入。如果没有给出n，则使用由axis指定的输入轴的长度。

axisint，可选

计算逆 FFT 的轴。如果未给出，则使用最后一个轴。

norm{“backward”, “ortho”, “forward”}，可选

规范化模式（参见fft）。默认为“backward”。

overwrite_x布尔值，可选

如果为 True，则可以破坏x的内容；默认为 False。详见fft获取更多细节。

workersint，可选

并行计算的最大工作线程数。如果为负数，则从os.cpu_count()开始计数。详见fft获取更多细节。

plan对象，可选

此参数保留给下游 FFT 供应商提供的预先计算的计划。目前在 SciPy 中未使用。

版本 1.5.0 中的新功能。

返回：

out复数 ndarray

截断或零填充的输入，在由axis指示的轴上进行变换，如果未指定axis，则使用最后一个轴。变换轴的长度为n//2 + 1。

另请参见

hfft，irfft

注意事项

hfft/ihfft是rfft/irfft的对应关系，用于反向情况：此处，信号在时间域具有 Hermitian 对称性，在频率域中为实数。因此，在这里，使用hfft，如果结果的长度为奇数，则必须提供其长度：* 偶数：ihfft(hfft(a, 2*len(a) - 2) == a，在舍入误差范围内；* 奇数：ihfft(hfft(a, 2*len(a) - 1) == a，在舍入误差范围内。

示例

>>> from scipy.fft import ifft, ihfft
>>> import numpy as np
>>> spectrum = np.array([ 15, -4, 0, -1, 0, -4])
>>> ifft(spectrum)
array([1.+0.j,  2.+0.j,  3.+0.j,  4.+0.j,  3.+0.j,  2.+0.j]) # may vary
>>> ihfft(spectrum)
array([ 1.-0.j,  2.-0.j,  3.-0.j,  4.-0.j]) # may vary 

scipy.fft.hfft2

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.hfft2.html#scipy.fft.hfft2

scipy.fft.hfft2(x, s=None, axes=(-2, -1), norm=None, overwrite_x=False, workers=None, *, plan=None)

计算 Hermitian 复数数组的 2-D FFT。

参数：

x数组

输入数组，假定为 Hermitian 复数。

s整数序列，可选

实际输出的形状。

axes整数序列，可选

计算 FFT 的轴。

norm{“backward”, “ortho”, “forward”}，可选

归一化模式（参见fft）。默认为“backward”。

overwrite_x布尔值，可选

如果为 True，则x的内容可以被销毁；默认为 False。更多详情请参见fft。

workers整数，可选

用于并行计算的最大工作线程数。如果为负数，则该值从os.cpu_count()中回绕。更多详情请参见fft。

plan对象，可选

这个参数保留给下游 FFT 供应商提供的预先计算的计划。目前在 SciPy 中没有使用。

新增于版本 1.5.0。

返回：

outndarray

2-D Hermitian 复数实 FFT 的真实结果。

另请参见

hfftn

计算 Hermitian 复数输入的 N-D 离散傅里叶变换。

注意

这实际上就是具有不同默认行为的hfftn。更多详情请参见hfftn。

scipy.fft.ihfft2

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.ihfft2.html#scipy.fft.ihfft2

scipy.fft.ihfft2(x, s=None, axes=(-2, -1), norm=None, overwrite_x=False, workers=None, *, plan=None)

计算实谱的 2-D 逆 FFT。

参数：

x类似数组

输入数组

s整数序列，可选

实际输入到逆 FFT 的形状。

axes整数序列，可选

计算逆 FFT 的轴。默认是最后两个轴。

norm{“backward”, “ortho”, “forward”}，可选

标准化模式（请参见fft）。默认为“backward”。

overwrite_x布尔值，可选

如果为 True，则x的内容可以被销毁；默认为 False。详见fft获取更多详情。

workers整数，可选

并行计算使用的最大工作线程数。如果为负数，则从os.cpu_count()中获取值。详见fft获取更多详情。

plan对象，可选

此参数保留供下游 FFT 供应商提供的预计算计划。目前在 SciPy 中未使用。

新版本为 1.5.0。

返回：

out ndarray

逆实 2-D FFT 的结果。

另请参阅

ihfftn

计算埃尔米特输入的 N-D FFT 的逆。

注意

这实际上是带有不同默认值的ihfftn。有关更多详细信息，请参见ihfftn。

scipy.fft.hfftn

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.hfftn.html#scipy.fft.hfftn

scipy.fft.hfftn(x, s=None, axes=None, norm=None, overwrite_x=False, workers=None, *, plan=None)

计算埃尔米特对称复数输入的 N 维 FFT，即具有实谱的信号。

该函数通过快速傅里叶变换（FFT）计算了 M-D 数组中任意数量轴上的埃尔米特对称复数输入的 N 维离散傅里叶变换。换句话说，ihfftn(hfftn(x, s)) == x 在数值精度范围内成立。(s 在这里是 x.shape，其中 s[-1] = x.shape[-1] * 2 - 1，出于与irfft相同的原因，这是必需的。)

参数：

x array_like

输入数组。

s 整数序列，可选

输出的形状（每个转换轴的长度）（s[0] 指代轴 0，s[1] 指代轴 1，以此类推）。s 也是沿该轴使用的输入点数，除了最后一个轴，其中使用输入点数的个数为 s[-1]//2+1。沿任何轴，如果由s指示的形状小于输入的形状，则对输入进行裁剪。如果大于输入，则用零填充输入。如果未给出s，则使用由 axes 指定的轴上的输入的形状。除了最后一个轴，其长度被认为是 2*(m-1)，其中 m 是沿该轴的输入的长度。

axes 整数序列，可选

用于计算逆 FFT 的轴。如果未给出，则使用最后len(s)轴，如果s也未指定，则使用所有轴。

norm {“backward”, “ortho”, “forward”}，可选

规范化模式（参见fft）。默认为“backward”。

overwrite_x 布尔值，可选

如果为 True，则x的内容可以被破坏；默认为 False。详见fft了解更多详情。

workers 整数，可选

用于并行计算的最大工作线程数。如果为负数，则值从 os.cpu_count() 环绕。详见fft了解更多详情。

plan 对象，可选

此参数保留以向下游 FFT 供应商提供的预计算计划。目前在 SciPy 中未使用。

版本 1.5.0 中的新功能。

返回：

out ndarray

截断或零填充的输入，沿axes指示的轴或由s或x的组合转换，如上面参数部分所述。如果未给出s，则每个转换的轴的长度由相应的s元素给出，如果未给出s，则在最后一个转换的轴上，输出的长度是 2*(m-1)，其中 m 是输入的最后一个转换轴的长度。要在最终轴上获得奇数个输出点，必须指定s。

引发：

ValueError

如果s和axes的长度不同。

IndexError

如果 axes 的元素大于 x 的轴数。

另见

ihfftn

具有实谱的逆 N-D FFT。hfftn 的逆。

fft

1-D FFT，使用的定义和约定。

rfft

实输入的正向 FFT。

注意事项

对于 1-D 信号 x 要有实谱，必须满足 Hermitian 特性：

x[i] == np.conj(x[-i]) for all i 

这通过依次在每个轴上反射来推广到更高维度：

x[i, j, k, ...] == np.conj(x[-i, -j, -k, ...]) for all i, j, k, ... 

这不应与 Hermitian 矩阵混淆，其转置为其自身的共轭：

x[i, j] == np.conj(x[j, i]) for all i, j 

s 的默认值假定最终转换轴上的输出长度为偶数。在执行最终的复数到实数转换时，Hermitian 对称性要求该轴上的最后一个虚部分量必须为 0，因此被忽略。为了避免信息丢失，必须提供正确长度的实输入。

示例

>>> import scipy.fft
>>> import numpy as np
>>> x = np.ones((3, 2, 2))
>>> scipy.fft.hfftn(x)
array([[[12.,  0.],
 [ 0.,  0.]],
 [[ 0.,  0.],
 [ 0.,  0.]],
 [[ 0.,  0.],
 [ 0.,  0.]]]) 

scipy.fft.ihfftn

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.ihfftn.html#scipy.fft.ihfftn

scipy.fft.ihfftn(x, s=None, axes=None, norm=None, overwrite_x=False, workers=None, *, plan=None)

为实谱计算 N-D 反离散傅里叶变换。

该函数通过快速傅里叶变换（FFT）计算 M-D 实数组上任意数量轴的 N-D 反离散傅里叶变换。默认情况下，所有轴都会进行变换，实变换在最后一个轴上执行，而剩余的变换为复变换。

参数：

x类似数组

输入数组，被视为实数。

s整数序列，可选

输入中要使用的形状（沿每个转换轴的长度）。(s[0]指轴 0，s[1]指轴 1，以此类推)。沿任何轴，如果给定的形状小于输入的形状，则输入被裁剪。如果大于输入的形状，则用零填充。如果未给出s，则使用由axes指定的轴的输入形状。

axes整数序列，可选

用于计算 FFT 的轴。如果未给出，则使用最后len(s)个轴，或者如果也未指定s，则使用所有轴。

norm{“backward”, “ortho”, “forward”}，可选

标准化模式（详见fft）。默认为“backward”。

overwrite_x布尔值，可选

如果为 True，则x的内容可以被销毁；默认为 False。详见fft获取更多详情。

workers整数，可选

用于并行计算的最大工作进程数。如果为负数，则从os.cpu_count()进行环绕。详见fft获取更多详情。

plan对象，可选

此参数保留用于传递由下游 FFT 供应商提供的预先计算的计划。目前在 SciPy 中未使用。

自版本 1.5.0 起新增。

返回：

out复数 ndarray

在由axes指示的轴上进行变换的截断或零填充的输入，或者根据上述参数部分中的s和x的组合。最后一个轴的长度将为s[-1]//2+1，而其余变换的轴将根据s的长度或保持输入不变。

引发：

值错误

如果s和axes长度不同。

索引错误

如果axes的元素大于x的轴数。

参见

hfftn

厄米输入的 N-D 正向 FFT。

hfft

厄米输入的 1-D FFT。

fft

1-D FFT，使用的定义和约定。

fftn

N-D FFT。

hfft2

厄米输入的 2-D FFT。

注：

对于实数输入的变换是通过ihfft在最后一个转换轴上执行的，然后通过ifftn在剩余轴上执行变换。输出顺序是埃尔米特输出信号的正部分，与rfft的格式相同。

示例

>>> import scipy.fft
>>> import numpy as np
>>> x = np.ones((2, 2, 2))
>>> scipy.fft.ihfftn(x)
array([[[1.+0.j,  0.+0.j], # may vary
 [0.+0.j,  0.+0.j]],
 [[0.+0.j,  0.+0.j],
 [0.+0.j,  0.+0.j]]])
>>> scipy.fft.ihfftn(x, axes=(2, 0))
array([[[1.+0.j,  0.+0.j], # may vary
 [1.+0.j,  0.+0.j]],
 [[0.+0.j,  0.+0.j],
 [0.+0.j,  0.+0.j]]]) 

scipy.fft.dct

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.dct.html#scipy.fft.dct

scipy.fft.dct(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, orthogonalize=None)

返回任意类型序列x的离散余弦变换。

参数：

x类数组

输入数组。

type{1, 2, 3, 4}，可选

DCT 的类型（见注释）。默认类型为 2。

n，可选

变换的长度。如果n < x.shape[axis]，x 将被截断。如果n > x.shape[axis]，x 将被零填充。默认结果为n = x.shape[axis]。

axis整数，可选

执行 DCT 的轴；默认是在最后一个轴上（即，axis=-1）。

norm{“backward”, “ortho”, “forward”}，可选

规范化模式（见注释）。默认为“backward”。

overwrite_x布尔值，可选

如果为 True，则x的内容可以被破坏；默认值为 False。

workers整数，可选

可以用于并行计算的最大工作人员数。如果为负数，则该值从os.cpu_count()中循环。更多详情，请参阅fft。

orthogonalize布尔值，可选

是否使用正交化的 DCT 变体（见注释）。当norm="ortho"时默认为True，否则为False。

1.8.0 版的新功能。

返回：

y实数的 ndarray

转换后的输入数组。

另请参阅

idct

反向 DCT

注释

对于单维数组x，dct(x, norm='ortho') 等同于 MATLAB 中的 dct(x)。

警告

对于type in {1, 2, 3}，norm="ortho"打破了直接与直接傅立叶变换的对应关系。要恢复它，您必须指定orthogonalize=False。

对于norm="ortho"，dct 和idct 在两个方向上都按相同的总因子缩放。默认情况下，转换也是正交的，这意味着对于类型 1、2 和 3，转换定义被修改以给出 DCT 矩阵的正交性（见下文）。

对于norm="backward"，dct 没有缩放，而idct 按1/N缩放，其中N是 DCT 的“逻辑”大小。对于norm="forward"，1/N规范化应用于正向的dct，而idct 是未规范化的。

离理论上有 8 种 DCT 类型，SciPy 仅实现了前 4 种类型。一般所说的 DCT 通常指的是 DCT 类型 2，而反向 DCT 通常指的是 DCT 类型 3。

Type I

DCT-I 有几种定义；我们使用以下定义（对于norm="backward"）

[y_k = x_0 + (-1)^k x_{N-1} + 2 \sum_{n=1}^{N-2} x_n \cos\left( \frac{\pi k n}{N-1} \right)]

如果 orthogonalize=True，x[0] 和 x[N-1] 被乘以缩放因子 (\sqrt{2})，而 y[0] 和 y[N-1] 被除以 (\sqrt{2})。与 norm="ortho" 结合，这使得相应的系数矩阵正交化（O @ O.T = np.eye(N)）。

注

DCT-I 仅支持输入大小 > 1。

类型 II

有几种定义的 DCT-II；我们使用以下（用于 norm="backward"）

[y_k = 2 \sum_{n=0}^{N-1} x_n \cos\left(\frac{\pi k(2n+1)}{2N} \right)]

如果 orthogonalize=True，y[0] 被 (\sqrt{2}) 除以，与 norm="ortho" 结合，使相应的系数矩阵正交化（O @ O.T = np.eye(N)）。

类型 III

有几种定义，我们使用以下（用于 norm="backward"）

[y_k = x_0 + 2 \sum_{n=1}^{N-1} x_n \cos\left(\frac{\pi(2k+1)n}{2N}\right)]

如果 orthogonalize=True，x[0] 项被乘以 (\sqrt{2})，与 norm="ortho" 结合，使相应的系数矩阵正交化（O @ O.T = np.eye(N)）。

（非归一化的）DCT-III 是（非归一化的）DCT-II 的逆，乘以因子 2N。经过正交化的 DCT-III 恰好是正交化的 DCT-II 的逆。

类型 IV

有几种定义的 DCT-IV；我们使用以下（用于 norm="backward"）

[y_k = 2 \sum_{n=0}^{N-1} x_n \cos\left(\frac{\pi(2k+1)(2n+1)}{4N} \right)]

orthogonalize 在这里没有效果，因为 DCT-IV 矩阵已经在缩放因子 2N 的范围内是正交的。

参考文献

[1]

‘一维和二维快速余弦变换’, 作者 J. Makhoul, IEEE Transactions on acoustics, speech and signal processing vol. 28(1), pp. 27-34, DOI:10.1109/TASSP.1980.1163351 (1980).

[2]

维基百科，“离散余弦变换”，en.wikipedia.org/wiki/Discrete_cosine_transform

示例

类型 1 DCT 对于实数、偶对称输入等效于 FFT（但更快）。输出也是实数且偶对称的。FFT 输入的一半用于生成 FFT 输出的一半：

>>> from scipy.fft import fft, dct
>>> import numpy as np
>>> fft(np.array([4., 3., 5., 10., 5., 3.])).real
array([ 30.,  -8.,   6.,  -2.,   6.,  -8.])
>>> dct(np.array([4., 3., 5., 10.]), 1)
array([ 30.,  -8.,   6.,  -2.]) 

scipy.fft.idct

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.idct.html#scipy.fft.idct

scipy.fft.idct(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, orthogonalize=None)

返回任意类型序列的逆离散余弦变换。

参数：

x类似数组

输入数组。

type{1, 2, 3, 4}，可选项

DCT 的类型（参见注释）。默认类型为 2。

n整数，可选项

变换的长度。如果n < x.shape[axis]，则x被截断。如果n > x.shape[axis]，则x被零填充。默认结果为n = x.shape[axis]。

axis整数，可选项

计算 IDCT 的轴向，默认为最后一个轴（即axis=-1）。

norm{“backward”, “ortho”, “forward”}，可选项

归一化模式（参见注释）。默认为“backward”。

overwrite_x布尔值，可选项

如果为 True，则x的内容可以被破坏；默认为 False。

workers整数，可选项

并行计算的最大工作线程数。如果为负值，则从os.cpu_count()回绕。详情请参见fft。

orthogonalize布尔值，可选项

是否使用正交化的 IDCT 变体（参见注释）。当norm="ortho"时，默认为True，否则为False。

新功能：1.8.0 版本。

返回：

idct实部的 ndarray

转换后的输入数组。

另请参见

dct

正向 DCT

注释

对于单维数组x，idct(x, norm='ortho')等同于 MATLAB 的idct(x)。

警告

对于type in {1, 2, 3}，norm="ortho"破坏了直接与逆直接傅立叶变换的对应关系。要恢复它，必须指定orthogonalize=False。

对于norm="ortho"，dct和idct在两个方向上都被相同的总体因子缩放。默认情况下，变换也是正交化的，对于类型 1、2 和 3 意味着变换定义被修改以提供 IDCT 矩阵的正交性（详见dct的完整定义）。

“The” IDCT 是 IDCT-II，与归一化的 DCT-III 相同。

IDCT 等同于普通的 DCT，除了归一化和类型。DCT 类型 1 和 4 是它们自己的逆，而 DCT 类型 2 和 3 是彼此的逆。

示例

类型 1 的 DCT 等同于对于实数、偶对称输入的 DFT。输出也是实数和偶对称的。IFFT 输入的一半用于生成 IFFT 输出的一半：

>>> from scipy.fft import ifft, idct
>>> import numpy as np
>>> ifft(np.array([ 30.,  -8.,   6.,  -2.,   6.,  -8.])).real
array([  4.,   3.,   5.,  10.,   5.,   3.])
>>> idct(np.array([ 30.,  -8.,   6.,  -2.]), 1)
array([  4.,   3.,   5.,  10.]) 

scipy.fft.dctn

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.dctn.html#scipy.fft.dctn

scipy.fft.dctn(x, type=2, s=None, axes=None, norm=None, overwrite_x=False, workers=None, *, orthogonalize=None)

返回指定轴上的多维离散余弦变换。

参数：

x数组样式

输入数组。

类型{1, 2, 3, 4}，可选

DCT 的类型（详见注释）。默认类型为 2。

s整数或整数数组或 None，可选

结果的形状。如果 s 和 axes（见下文）都为 None，则 s 为 x.shape；如果 s 为 None 而 axes 不为 None，则 s 为 numpy.take(x.shape, axes, axis=0)。如果 s[i] > x.shape[i]，第 i 维度用零填充。如果 s[i] < x.shape[i]，第 i 维度被截断为长度 s[i]。如果 s 的任何元素为 -1，则使用 x 相应维度的大小。

轴整数或整数数组或 None，可选

DCT 计算的轴。如果未指定，则使用最后的 len(s) 轴，或者如果 s 也未指定，则使用所有轴。

norm{“backward”, “ortho”, “forward”}，可选

规范化模式（见注释）。默认为 “backward”。

覆盖 x布尔值，可选

如果为 True，则 x 的内容可以被破坏；默认为 False。

工作线程整数，可选

用于并行计算的最大工作线程数。如果为负数，则从 os.cpu_count() 循环使用值。详见 fft。

正交化布尔值，可选

是否使用正交化的 DCT 变体（见注释）。当 norm="ortho" 时，默认为 True，否则为 False。

1.8.0 版新功能。

返回：

y实数的 ndarray

转换后的输入数组。

另请参见

idctn

多维反离散余弦变换

注释

有关 DCT 类型和规范化模式的详细信息及参考，请参见 dct。

示例

>>> import numpy as np
>>> from scipy.fft import dctn, idctn
>>> rng = np.random.default_rng()
>>> y = rng.standard_normal((16, 16))
>>> np.allclose(y, idctn(dctn(y)))
True 

scipy.fft.idctn

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.idctn.html#scipy.fft.idctn

scipy.fft.idctn(x, type=2, s=None, axes=None, norm=None, overwrite_x=False, workers=None, orthogonalize=None)

沿指定轴返回多维逆离散余弦变换。

参数：

x类似数组

输入数组。

类型{1, 2, 3, 4}，可选

DCT 的类型（见注释）。默认类型为 2。

s整数或整数数组或 None，可选

结果的形状。如果s和axes（见下文）都为 None，则s为x.shape；如果s为 None 但axes不为 None，则s为numpy.take(x.shape, axes, axis=0)。如果s[i] > x.shape[i]，则第 i 维度用零填充。如果s[i] < x.shape[i]，则第 i 维度被截断为长度s[i]。如果s的任何元素为-1，则使用x对应维度的大小。

轴整数或整数数组或 None，可选

计算 IDCT 的轴。如果未给出，则使用最后len(s)个轴，或者如果s也未指定，则使用所有轴。

norm{“backward”, “ortho”, “forward”}，可选

标准化模式（见注释）。默认为“backward”。

overwrite_x布尔值，可选

如果为 True，则可以销毁x的内容；默认为 False。

工作进程数整数，可选

用于并行计算的最大工作进程数。如果为负数，则该值从os.cpu_count()循环。有关更多详细信息，请参见fft。

正交化布尔值，可选

是否使用正交化 IDCT 变体（见备注）。当norm="ortho"时，默认为True，否则为False。

新版本 1.8.0 中新增。

返回：

y实数的 ndarray

转换后的输入数组。

另请参见

dctn

多维 DCT

注

有关 IDCT 类型和标准化模式的完整详细信息以及参考资料，请参见idct。

示例

>>> import numpy as np
>>> from scipy.fft import dctn, idctn
>>> rng = np.random.default_rng()
>>> y = rng.standard_normal((16, 16))
>>> np.allclose(y, idctn(dctn(y)))
True 

scipy.fft.dst

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.dst.html#scipy.fft.dst

scipy.fft.dst(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, orthogonalize=None)

返回任意类型序列 x 的离散正弦变换。

参数：

x 数组样式

输入数组。

type {1, 2, 3, 4}，可选

DST 的类型（参见注释）。默认类型为 2。

n 整数，可选

变换的长度。如果 n < x.shape[axis]，则截断 x。如果 n > x.shape[axis]，则对 x 进行零填充。默认结果为 n = x.shape[axis]。

axis 整数，可选

计算 DST 的轴；默认为最后一个轴（即 axis=-1）。

norm {“backward”, “ortho”, “forward”}，可选

归一化模式（参见注释）。默认为“backward”。

overwrite_x 布尔值，可选

如果为 True，则 x 的内容可以被破坏；默认为 False。

workers 整数，可选

用于并行计算的最大工作进程数。如果为负数，则该值从 os.cpu_count() 循环回来。有关更多详情，请参见 fft。

orthogonalize 布尔值，可选

是否使用正交化 DST 变体（见注释）。当 norm="ortho" 时，默认为 True，否则为 False。

1.8.0 版本中的新功能。

返回：

dst 实数的 ndarray

转换后的输入数组。

另请参见

idst

逆 DST

注释

警告

对于 type in {2, 3}，norm="ortho" 打破了与直接傅里叶变换的直接对应关系。要恢复它，必须指定 orthogonalize=False。

对于 norm="ortho"，dst 和 idst 在两个方向上都按相同的总体因子进行缩放。默认情况下，变换也被正交化，对于类型 2 和 3，这意味着变换定义被修改以给出 DST 矩阵的正交性（见下文）。

对于 norm="backward"，dst 上没有缩放，而 idst 缩放因子为 1/N，其中 N 是 DST 的“逻辑”大小。

理论上有 8 种 DST 类型，适用于不同的偶数/奇数边界条件和边界偏移[1]，SciPy 仅实现了前 4 种类型。

类型 I

对于 DST-I，有几种定义；我们在 norm="backward" 时使用以下定义。DST-I 假设输入在 (n=-1) 和 (n=N) 附近是奇数。

[y_k = 2 \sum_{n=0}^{N-1} x_n \sin\left(\frac{\pi(k+1)(n+1)}{N+1}\right)]

注意，DST-I 仅支持输入大小 > 1。非归一化的 DST-I 是其自身的逆，缩放因子为 (2(N+1))。正交化后的 DST-I 正好是其自身的逆。

orthogonalize 在这里没有效果，因为 DST-I 矩阵已经正交，只是缩放因子为 2N。

类型 II

对于 norm="backward"，DST-II 有几个定义；我们使用以下定义。DST-II 假设输入在 (n=-1/2) 和 (n=N-1/2) 处是奇函数；输出在 (k=-1) 处是奇函数，在 (k=N-1) 处是偶函数。

[y_k = 2 \sum_{n=0}^{N-1} x_n \sin\left(\frac{\pi(k+1)(2n+1)}{2N}\right)]

如果 orthogonalize=True，则 y[-1] 被除以 (\sqrt{2})，结合 norm="ortho" 使用，使得相应的系数矩阵是标准正交的（O @ O.T = np.eye(N)）。

Type III

DST-III 有几个定义，我们使用以下定义（对于 norm="backward"）。DST-III 假设输入在 (n=-1) 处是奇函数，在 (n=N-1) 处是偶函数。

[y_k = (-1)^k x_{N-1} + 2 \sum_{n=0}^{N-2} x_n \sin\left( \frac{\pi(2k+1)(n+1)}{2N}\right)]

如果 orthogonalize=True，则 x[-1] 被乘以 (\sqrt{2})，结合 norm="ortho" 使用，使得相应的系数矩阵是标准正交的（O @ O.T = np.eye(N)）。

（未归一化的）DST-III 是（未归一化的）DST-II 的逆，乘以一个因子 (2N)。正交化的 DST-III 恰好是正交化的 DST-II 的逆。

Type IV

DST-IV 有几个定义，我们使用以下定义（对于 norm="backward"）。DST-IV 假设输入在 (n=-0.5) 处是奇函数，在 (n=N-0.5) 处是偶函数。

[y_k = 2 \sum_{n=0}^{N-1} x_n \sin\left(\frac{\pi(2k+1)(2n+1)}{4N}\right)]

orthogonalize 在这里无效，因为 DST-IV 矩阵已经是正交的，只差一个 2N 的比例因子。

（未归一化的）DST-IV 是其自身的逆，乘以一个因子 (2N)。正交化的 DST-IV 恰好是其自身的逆。

参考文献

[1]

Wikipedia，“离散正弦变换”，en.wikipedia.org/wiki/Discrete_sine_transform

scipy.fft.idst

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.idst.html#scipy.fft.idst

scipy.fft.idst(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, orthogonalize=None)

返回任意类型序列的逆离散正弦变换。

参数：

x类似数组

输入数组。

type{1, 2, 3, 4}，可选

DST 的类型（见笔记）。默认类型为 2。

n整数，可选

变换长度。如果n < x.shape[axis]，则截断x。如果n > x.shape[axis]，则在x中填充零。默认情况下，结果为n = x.shape[axis]。

axis整数，可选

计算 idst 的轴；默认为最后一个轴（即，axis=-1）。

norm{“backward”, “ortho”, “forward”}，可选

归一化模式（见笔记）。默认为“backward”。

overwrite_x布尔值，可选

如果为 True，则x的内容可以被破坏；默认为 False。

workers整数，可选

用于并行计算的最大工作线程数。如果为负数，则从os.cpu_count()中回环值。有关更多详细信息，请参阅fft。

orthogonalize布尔值，可选

是否使用正交化的 IDST 变体（见笔记）。当norm="ortho"时，默认为 True，否则为 False。

从版本 1.8.0 开始。

返回：

idst实数的 ndarray

转换后的输入数组。

另请参阅

dst

前向 DST

笔记

警告

对于type in {2, 3}，norm="ortho"打破了与逆直接傅里叶变换的直接对应关系。

对于norm="ortho"，dst和idst在两个方向上都按相同的整体因子进行缩放。默认情况下，变换也被正交化，对于类型 2 和 3 来说，这意味着变换定义被修改以使得 DST 矩阵正交（请参阅dst以获取完整的定义）。

“The” IDST 是 IDST-II，它与标准化的 DST-III 相同。

IDST 等效于正常的 DST，除了归一化和类型。DST 类型 1 和 4 是它们自己的逆，而 DSTs 2 和 3 互为逆。

scipy.fft.dstn

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.dstn.html#scipy.fft.dstn

scipy.fft.dstn(x, type=2, s=None, axes=None, norm=None, overwrite_x=False, workers=None, orthogonalize=None)

返回沿指定轴的多维离散正弦变换。

参数：

x数组型

输入数组。

type{1, 2, 3, 4}，可选

DST 的类型（见备注）。默认类型为 2。

s整数或整数数组或 None，可选

结果的形状。如果s和axes（见下文）都为 None，则s为x.shape；如果s为 None 但axes不为 None，则s为numpy.take(x.shape, axes, axis=0)。如果s[i] > x.shape[i]，则第 i 维度用零填充。如果s[i] < x.shape[i]，则第 i 维度被截断到长度s[i]。如果shape的任何元素为-1，则使用x对应维度的大小。

axesint 或整数数组或 None，可选

计算 DST 的轴。如果未给出，则使用最后len(s)个轴，或者如果s也未指定，则使用所有轴。

norm{“backward”, “ortho”, “forward”}，可选

标准化模式（见备注）。默认为“backward”。

overwrite_x布尔值，可选

如果为 True，则x的内容可以被销毁；默认为 False。

workers整数，可选

用于并行计算的最大工作进程数。如果为负，则该值从os.cpu_count()循环。有关详细信息，请参见fft。

orthogonalize布尔值，可选

是否使用正交化的 DST 变体（见备注）。当norm="ortho"时，默认为True，否则为False。

新版本 1.8.0 中添加。

返回：

y实数的 ndarray

转换后的输入数组。

另请参阅

idstn

多维反 DST

备注

有关 DST 类型和标准化模式的完整详情以及参考文献，请参见dst。

示例

>>> import numpy as np
>>> from scipy.fft import dstn, idstn
>>> rng = np.random.default_rng()
>>> y = rng.standard_normal((16, 16))
>>> np.allclose(y, idstn(dstn(y)))
True