SciPy-1-12-中文文档-三-

SciPy 1.12 中文文档（三）

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

数据集（scipy.datasets）

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

数据集方法

ascent()	获取一个 8 位灰度深度、512 x 512 衍生图像，方便用于演示。
face([gray])	获取一个 1024 x 768 的浣熊脸彩色图像。
electrocardiogram()	加载一个心电图作为 1-D 信号的示例。

实用方法

download_all([path])	下载所有 scipy.datasets 模块的数据集文件的实用方法。
clear_cache([datasets])	清理 scipy 数据集缓存目录。

数据集的使用

SciPy 数据集方法可以简单地按如下方式调用：'<dataset-name>()' 这会通过网络下载数据集文件一次，并保存缓存，然后返回一个代表数据集的 numpy.ndarray 对象。

请注意，不同数据集方法的返回数据结构和数据类型可能不同。有关更详细的用法示例，请查看上面特定数据集方法的文档。

数据集检索和存储工作原理

SciPy 数据集文件存储在 SciPy GitHub 组织下的各个 github 仓库中，遵循命名约定为'dataset-<name>'，例如 scipy.datasets.face 文件位于 github.com/scipy/dataset-face。scipy.datasets 子模块利用并依赖于 Pooch，一个旨在简化获取数据文件的 Python 包。Pooch 在调用数据集函数时使用这些仓库来检索相应的数据集文件。

所有数据集的注册表，基本上是文件名与它们的 SHA256 哈希和仓库网址的映射被维护，Pooch 使用它来处理和验证在函数调用时的下载。下载数据集一次后，文件将保存在系统缓存目录下的'scipy-data'中。

不同平台上的数据集缓存位置可能会有所不同。

对于 macOS：

'~/Library/Caches/scipy-data' 

对于 Linux 和其他类 Unix 平台：

'~/.cache/scipy-data'  # or the value of the XDG_CACHE_HOME env var, if defined 

对于 Windows：

'C:\Users\<user>\AppData\Local\<AppAuthor>\scipy-data\Cache' 

在由于各种安全原因而受限网络连接的环境中，或者在没有持续互联网连接的系统上，可以通过将数据集存储库的内容放置在上述提到的缓存目录中手动加载数据集的缓存，以避免在没有互联网连接时出现数据集获取错误。

scipy.datasets.ascent

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.datasets.ascent.html#scipy.datasets.ascent

scipy.datasets.ascent()

获取一个 8 位灰度位深度，512 x 512 像素的图像，方便用于演示。

该图像源自于www.public-domain-image.com/people-public-domain-images-pictures/上的 accent-to-the-top.jpg。

参数：

无

返回：

ascentndarray

用于测试和演示的方便图像

示例

>>> import scipy.datasets
>>> ascent = scipy.datasets.ascent()
>>> ascent.shape
(512, 512)
>>> ascent.max()
255 

>>> import matplotlib.pyplot as plt
>>> plt.gray()
>>> plt.imshow(ascent)
>>> plt.show() 

scipy.datasets.face

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.datasets.face.html#scipy.datasets.face

scipy.datasets.face(gray=False)

获取一张 1024 x 768 的浣熊脸部彩色图像。

raccoon-procyon-lotor.jpg 位于 www.public-domain-image.com

Parameters:

graybool, 可选

如果为 True 返回 8 位灰度图像，否则返回彩色图像

Returns:

facendarray

浣熊脸部图像

Examples

>>> import scipy.datasets
>>> face = scipy.datasets.face()
>>> face.shape
(768, 1024, 3)
>>> face.max()
255
>>> face.dtype
dtype('uint8') 

>>> import matplotlib.pyplot as plt
>>> plt.gray()
>>> plt.imshow(face)
>>> plt.show() 

scipy.datasets.electrocardiogram

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.datasets.electrocardiogram.html#scipy.datasets.electrocardiogram

scipy.datasets.electrocardiogram()

加载心电图作为一维信号的示例。

返回的信号是一段长达 5 分钟的心电图（ECG），即心脏电活动的医学记录，采样频率为 360 赫兹。

返回:

ecgndarray

以 360 赫兹采样的毫伏（mV）单位的心电图。

注

提供的信号是来自 PhysioNet 上的 MIT-BIH 心律失常数据库的记录 208（MLII 导联）的摘录（19:35 至 24:35）。该摘录包括由噪声引起的伪迹、典型心跳以及病理变化。

1.1.0 版本的新功能。

参考文献

[1]

Moody GB, Mark RG. MIT-BIH 心律失常数据库的影响. IEEE Eng in Med and Biol 20(3):45-50 (2001 年 5-6 月). (PMID: 11446209); DOI:10.13026/C2F305

[2]

Goldberger AL, Amaral LAN, Glass L, Hausdorff JM, Ivanov PCh, Mark RG, Mietus JE, Moody GB, Peng C-K, Stanley HE. PhysioBank, PhysioToolkit 和 PhysioNet：复杂生理信号的新研究资源的组成部分。循环 101(23):e215-e220; DOI:10.1161/01.CIR.101.23.e215

例子

>>> from scipy.datasets import electrocardiogram
>>> ecg = electrocardiogram()
>>> ecg
array([-0.245, -0.215, -0.185, ..., -0.405, -0.395, -0.385])
>>> ecg.shape, ecg.mean(), ecg.std()
((108000,), -0.16510875, 0.5992473991177294) 

如所述，信号特征显示了几个具有不同形态的区域。例如，前几秒显示了正常窦性心律的心脏电活动，如下图所示。

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> fs = 360
>>> time = np.arange(ecg.size) / fs
>>> plt.plot(time, ecg)
>>> plt.xlabel("time in s")
>>> plt.ylabel("ECG in mV")
>>> plt.xlim(9, 10.2)
>>> plt.ylim(-1, 1.5)
>>> plt.show() 

然而，在第 16 秒之后，首次早期室性收缩，也称为期外收缩，出现了。这些与典型心跳的形态学不同。这种差异可以在以下图中轻松观察到。

>>> plt.plot(time, ecg)
>>> plt.xlabel("time in s")
>>> plt.ylabel("ECG in mV")
>>> plt.xlim(46.5, 50)
>>> plt.ylim(-2, 1.5)
>>> plt.show() 

在几个点上，大型伪迹干扰了记录，例如：

>>> plt.plot(time, ecg)
>>> plt.xlabel("time in s")
>>> plt.ylabel("ECG in mV")
>>> plt.xlim(207, 215)
>>> plt.ylim(-2, 3.5)
>>> plt.show() 

最后，检查功率谱表明，大部分生物信号由低频组成。在 60 赫兹处，主电网引起的噪声可以清晰地观察到。

>>> from scipy.signal import welch
>>> f, Pxx = welch(ecg, fs=fs, nperseg=2048, scaling="spectrum")
>>> plt.semilogy(f, Pxx)
>>> plt.xlabel("Frequency in Hz")
>>> plt.ylabel("Power spectrum of the ECG in mV**2")
>>> plt.xlim(f[[0, -1]])
>>> plt.show() 

scipy.datasets.download_all

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.datasets.download_all.html#scipy.datasets.download_all

scipy.datasets.download_all(path=None)

用于下载scipy.datasets模块中所有数据集文件的实用方法。

参数：

pathstr，可选

下载所有数据集文件的目录路径。如果为 None，则默认为由 pooch 检测到的系统缓存目录。

数据集（scipy.datasets）

原文：docs.scipy.org/doc/scipy-1.12.0/reference/datasets.html#module-scipy.datasets

数据集方法

ascent()	获取一个 8 位灰度深度的 512 x 512 推导图像，用于演示方便。
face([gray])	获取一个 1024 x 768 的彩色浣熊脸部图像。
electrocardiogram()	加载一个心电图作为一维信号的示例。

实用方法

download_all([path])	下载 scipy.datasets 模块的所有数据集文件的实用方法。
clear_cache([datasets])	清理 scipy 数据集缓存目录。

数据集的使用

SciPy 数据集方法可以简单地如下调用：'<dataset-name>()' 这会通过网络下载数据集文件一次，并保存缓存，然后返回表示数据集的 numpy.ndarray 对象。

注意，不同数据集方法的返回数据结构和数据类型可能不同。有关使用的更详细示例，请查看上述特定数据集方法的文档。

数据集检索和存储工作方式

SciPy 数据集文件存储在 SciPy GitHub 组织的各个单独存储库中，遵循命名约定为 'dataset-<name>'，例如 scipy.datasets.face 文件位于 github.com/scipy/dataset-face。scipy.datasets 子模块利用并依赖于 Pooch，一个简化数据文件获取的 Python 包。Pooch 在调用数据集函数时使用这些存储库来检索相应的数据集文件。

所有数据集的注册表，实质上是文件名与其 SHA256 哈希及存储库 URL 的映射，均由 Pooch 维护，用于在函数调用时处理和验证下载。下载数据集一次后，文件将保存在系统缓存目录下的 'scipy-data' 文件夹中。

数据集缓存位置在不同平台可能有所不同。

对于 macOS：

'~/Library/Caches/scipy-data' 

对于 Linux 和其他类 Unix 平台：

'~/.cache/scipy-data'  # or the value of the XDG_CACHE_HOME env var, if defined 

对于 Windows：

'C:\Users\<user>\AppData\Local\<AppAuthor>\scipy-data\Cache' 

在因各种安全原因而网络连接受限制的环境中，或者在没有持续互联网连接的系统上，可以通过将数据集仓库的内容手动放置在上述提到的缓存目录中，来加载数据集的缓存，以避免在没有互联网连接时获取数据集时发生错误。

scipy.datasets.clear_cache

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.datasets.clear_cache.html#scipy.datasets.clear_cache

scipy.datasets.clear_cache(datasets=None)

清理 scipy 数据集缓存目录。

如果提供了 scipy.datasets 方法或其列表/元组，则 clear_cache 将删除与传递的数据集方法可调用相关联的所有数据文件。

默认情况下，它会删除所有缓存的数据文件。

参数：

datasets 可调用对象或可调用对象的列表/元组或 None

示例

>>> from scipy import datasets
>>> ascent_array = datasets.ascent()
>>> ascent_array.shape
(512, 512)
>>> datasets.clear_cache([datasets.ascent])
Cleaning the file ascent.dat for dataset ascent 

离散傅立叶变换（scipy.fft）

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

快速傅立叶变换（FFT）

fft(x[, n, axis, norm, overwrite_x, ...])	计算一维离散傅立叶变换。
ifft(x[, n, axis, norm, overwrite_x, ...])	计算一维离散傅立叶逆变换。
fft2(x[, s, axes, norm, overwrite_x, ...])	计算二维离散傅立叶变换
ifft2(x[, s, axes, norm, overwrite_x, ...])	计算二维离散傅立叶逆变换。
fftn(x[, s, axes, norm, overwrite_x, ...])	计算 N 维离散傅立叶变换。
ifftn(x[, s, axes, norm, overwrite_x, ...])	计算 N 维离散傅立叶逆变换。
rfft(x[, n, axis, norm, overwrite_x, ...])	计算实输入的一维离散傅立叶变换。
irfft(x[, n, axis, norm, overwrite_x, ...])	计算rfft的逆变换。
rfft2(x[, s, axes, norm, overwrite_x, ...])	计算实数组的二维傅立叶变换。
irfft2(x[, s, axes, norm, overwrite_x, ...])	计算rfft2的逆变换
rfftn(x[, s, axes, norm, overwrite_x, ...])	计算实输入的 N 维离散傅立叶变换。
irfftn(x[, s, axes, norm, overwrite_x, ...])	计算rfftn的逆变换
hfft(x[, n, axis, norm, overwrite_x, ...])	计算具有共轭对称性的信号的傅立叶变换，即实谱。
ihfft(x[, n, axis, norm, overwrite_x, ...])	计算具有共轭对称性的信号的逆傅立叶变换。
hfft2(x[, s, axes, norm, overwrite_x, ...])	计算共轭复数数组的二维傅立叶变换。
ihfft2(x[, s, axes, norm, overwrite_x, ...])	计算实谱的二维逆 FFT。
hfftn(x[, s, axes, norm, overwrite_x, ...])	计算 Hermite 对称复输入的 N 维 FFT，即具有实谱的信号。
ihfftn(x[, s, axes, norm, overwrite_x, ...])	计算实谱的 N 维逆离散傅里叶变换。

离散正弦和余弦变换（DST 和 DCT）

dct(x[, type, n, axis, norm, overwrite_x, ...])	返回任意类型序列 x 的离散余弦变换。
idct(x[, type, n, axis, norm, overwrite_x, ...])	返回任意类型序列的离散余弦逆变换。
dctn(x[, type, s, axes, norm, overwrite_x, ...])	返回沿指定轴的多维离散余弦变换。
idctn(x[, type, s, axes, norm, overwrite_x, ...])	返回沿指定轴的多维离散余弦逆变换。
dst(x[, type, n, axis, norm, overwrite_x, ...])	返回任意类型序列 x 的离散正弦变换。
idst(x[, type, n, axis, norm, overwrite_x, ...])	返回任意类型序列的离散正弦逆变换。
dstn(x[, type, s, axes, norm, overwrite_x, ...])	返回沿指定轴的多维离散正弦变换。
idstn(x[, type, s, axes, norm, overwrite_x, ...])	返回沿指定轴的多维离散正弦逆变换。

快速 Hankel 变换

fht(a, dln, mu[, offset, bias])	计算快速 Hankel 变换。
ifht(A, dln, mu[, offset, bias])	计算逆快速 Hankel 变换。

辅助函数

fftshift(x[, axes])	将零频率分量移至频谱中心。
ifftshift(x[, axes])	fftshift 的逆操作。
fftfreq(n[, d, xp, device])	返回离散傅里叶变换的采样频率。
rfftfreq(n[, d, xp, device])	返回离散傅里叶变换采样频率（用于 rfft, irfft 的使用）。
fhtoffset(dln, mu[, initial, bias])	返回快速 Hankel 变换的最佳偏移量。
next_fast_len(target[, real])	查找输入数据到 fft 的下一个快速大小，用于零填充等。
set_workers(workers)	默认工作线程数的上下文管理器，用于 scipy.fft。
get_workers()	返回当前上下文中默认的工作线程数。

后端控制

set_backend(backend[, coerce, only])	在固定范围内设置后端的上下文管理器。
skip_backend(backend)	在固定范围内跳过某个后端的上下文管理器。
set_global_backend(backend[, coerce, only, ...])	设置全局 fft 后端。
register_backend(backend)	注册永久使用的后端。

scipy.fft.fft

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

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

计算 1-D 离散傅里叶变换。

此函数使用高效的快速傅里叶变换（FFT）算法计算 1-D n-点离散傅里叶变换（DFT）[1]。

参数：

xarray_like

输入数组，可以是复数。

nint, optional

输出的变换轴的长度。如果n小于输入的长度，则截断输入。如果n大于输入的长度，则用零填充输入。如果没有给出n，则使用axis指定的轴上的输入长度。

axisint, optional

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

norm，optional

标准化模式。默认为“backward”，表示在正向变换上不进行标准化，在ifft上按1/n进行缩放。而“forward”则在正向变换上应用1/n因子。对于norm="ortho"，两个方向均按1/sqrt(n)进行缩放。

新版本 1.6.0 中添加了norm={"forward", "backward"}选项。

overwrite_xbool, optional

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

workersint, optional

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

planobject, optional

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

新版本 1.5.0 中的新增内容。

返回：

outcomplex ndarray

指定由axis指示的轴或最后一个轴（如果未指定axis）转换的截断或零填充输入。

引发：

IndexError

若axes大于x的最后一个轴。

另见

ifft

fft

fft2

二维 FFT。

fftn

N 维 FFT。

rfftn

实输入的 N 维 FFT。

fftfreq

给定 FFT 参数的频率分 bin。

next_fast_len

用于最有效转换的输入填充大小。

注意

FFT（快速傅里叶变换）指的是通过使用计算项中的对称性来高效计算离散傅里叶变换（DFT）的一种方法。当 n 是 2 的幂时，对称性最高，因此对于这些大小的变换效率最高。对于难以因式分解的大小，scipy.fft 使用 Bluestein 算法 [2]，因此计算复杂度永远不会超过 O(n log n)。通过使用 next_fast_len 来对输入进行零填充，可能会看到进一步的性能提升。

如果 x 是 1 维数组，则 fft 等效于

y[k] = np.sum(x * np.exp(-2j * np.pi * k * np.arange(n)/n)) 

频率项 f=k/n 在 y[k] 处找到。在 y[n/2] 处达到奈奎斯特频率，并绕到负频率项。因此，对于 8 点变换，结果的频率是 [0, 1, 2, 3, -4, -3, -2, -1]。要重新排列 fft 输出，使零频率分量居中，如 [-4, -3, -2, -1, 0, 1, 2, 3]，使用 fftshift。

变换可以使用单精度、双精度或扩展精度（长双精度）浮点数完成。半精度输入将转换为单精度，非浮点输入将转换为双精度。

如果 x 的数据类型是实数，则会自动使用“实 FFT”算法，大致减少计算时间的一半。为了进一步提高效率，可以使用 rfft，它执行相同的计算，但只输出对称频谱的一半。如果数据既是实数又是对称的，则 dct 可以再次将效率提升一倍，通过从信号的一半生成一半的频谱。

当指定 overwrite_x=True 时，x 引用的内存可能会被实现方式使用。这可能包括重用内存作为结果，但这并不保证。您不应依赖于变换后 x 的内容，因为这可能会在未来更改而没有警告。

workers 参数指定要将 FFT 计算拆分为的最大并行作业数。这将在 x 中执行独立的 1-D FFT。因此，x 必须至少是 2-D，并且非变换的轴必须足够大，以便分成块。如果 x 太小，则可能使用的作业数少于请求的数量。

参考文献

[1]

Cooley, James W. 和 John W. Tukey, 1965 年, “An algorithm for the machine calculation of complex Fourier series,” Math. Comput. 19: 297-301.

[2]

Bluestein, L., 1970 年, “A linear filtering approach to the computation of discrete Fourier transform”. IEEE Transactions on Audio and Electroacoustics. 18 (4): 451-455.

示例

>>> import scipy.fft
>>> import numpy as np
>>> scipy.fft.fft(np.exp(2j * np.pi * np.arange(8) / 8))
array([-2.33486982e-16+1.14423775e-17j,  8.00000000e+00-1.25557246e-15j,
 2.33486982e-16+2.33486982e-16j,  0.00000000e+00+1.22464680e-16j,
 -1.14423775e-17+2.33486982e-16j,  0.00000000e+00+5.20784380e-16j,
 1.14423775e-17+1.14423775e-17j,  0.00000000e+00+1.22464680e-16j]) 

在这个例子中，实数输入的 FFT 是 Hermitian 的，即在实部对称，在虚部反对称：

>>> from scipy.fft import fft, fftfreq, fftshift
>>> import matplotlib.pyplot as plt
>>> t = np.arange(256)
>>> sp = fftshift(fft(np.sin(t)))
>>> freq = fftshift(fftfreq(t.shape[-1]))
>>> plt.plot(freq, sp.real, freq, sp.imag)
[<matplotlib.lines.Line2D object at 0x...>,
 <matplotlib.lines.Line2D object at 0x...>]
>>> plt.show() 

scipy.fft.ifft

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

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

计算 1-D 逆离散傅里叶变换。

此函数计算由fft计算的 1-D n点离散傅里叶变换的逆变换。换句话说，ifft(fft(x)) == x在数值精度范围内成立。

输入应与fft返回的顺序相同，

• x[0]应包含零频率项，

• x[1:n//2]应包含正频率项，

• x[n//2 + 1:]应包含负频率项，按照从最负频率开始递增的顺序。

对于偶数个输入点，x[n//2]代表正和负 Nyquist 频率值的总和，因为这两者会混叠在一起。详情请参见fft。

参数：

xarray_like

输入数组，可以是复数。

nint, optional

输出的转换轴的长度。如果n小于输入的长度，则截断输入。如果n大于输入的长度，则用零填充输入。有关填充问题的说明，请参阅注释。

axisint, optional

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

norm, 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

指示的轴或最后一个轴上变换的截断或零填充输入。

异常：

IndexError

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

另请参见

fft

1-D（正向）FFT，其逆变换为ifft。

ifft2

2-D 逆傅里叶变换。

ifftn

N-D 逆傅里叶变换。

注：

如果输入参数n大于输入的大小，则在末尾附加零以进行填充。尽管这是常见的方法，但可能会导致意想不到的结果。如果需要不同的填充方式，则必须在调用ifft之前执行。

如果x是一个一维数组，那么ifft等效于

y[k] = np.sum(x * np.exp(2j * np.pi * k * np.arange(n)/n)) / len(x) 

与fft类似，ifft支持所有浮点类型，并且针对实数输入进行了优化。

示例

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

创建并绘制具有随机相位的带限信号：

>>> import matplotlib.pyplot as plt
>>> rng = np.random.default_rng()
>>> t = np.arange(400)
>>> n = np.zeros((400,), dtype=complex)
>>> n[40:60] = np.exp(1j*rng.uniform(0, 2*np.pi, (20,)))
>>> s = scipy.fft.ifft(n)
>>> plt.plot(t, s.real, 'b-', t, s.imag, 'r--')
[<matplotlib.lines.Line2D object at ...>, <matplotlib.lines.Line2D object at ...>]
>>> plt.legend(('real', 'imaginary'))
<matplotlib.legend.Legend object at ...>
>>> plt.show() 

scipy.fft.fft2

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

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

计算 2-D 离散傅里叶变换

此函数通过快速傅里叶变换（FFT）计算 M-D 数组中任何轴上的 N-D 离散傅里叶变换。默认情况下，变换在输入数组的最后两个轴上计算，即 2 维 FFT。

参数：

xarray_like

输入数组，可以是复数

s整数序列，可选

输出的形状（每个转换轴的长度）（s[0] 指代轴 0，s[1] 指代轴 1，以此类推）。这对应于 fft(x, n) 中的 n。沿每个轴，如果给定的形状小于输入的形状，则输入被裁剪。如果形状更大，则用零填充输入。如果未给出 s，则使用由 axes 指定的轴上的输入形状。

axes整数序列，可选

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

norm，可选

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

overwrite_xbool，可选

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

workersint，可选

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

plan对象，可选

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

自版本 1.5.0 新增。

返回：

out复数 ndarray

截断或零填充输入，沿 axes 指示的轴变换，或者如果未给出 axes 则为最后两个轴。

引发：

值错误

如果 s 和 axes 长度不同，或者未给出 axes 且 len(s) != 2。

索引错误

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

另请参阅

ifft2

逆 2-D FFT。

fft

1-D FFT。

fftn

N 维 FFT。

fftshift

将零频率项移至数组中心。对于 2-D 输入，交换第一和第三象限，第二和第四象限。

注释

fft2 仅仅是 fftn，但默认 axes 不同。

输出与fft类似，在变换后的轴的低阶角落包含零频率的项，这些轴的前半部分包含正频率项，轴的中间包含奈奎斯特频率的项，这些轴的后半部分以递减的负频率顺序包含负频率项。

查看fftn了解详细信息和绘图示例，以及fft了解使用的定义和约定。

例子

>>> import scipy.fft
>>> import numpy as np
>>> x = np.mgrid[:5, :5][0]
>>> scipy.fft.fft2(x)
array([[ 50\.  +0.j        ,   0\.  +0.j        ,   0\.  +0.j        , # may vary
 0\.  +0.j        ,   0\.  +0.j        ],
 [-12.5+17.20477401j,   0\.  +0.j        ,   0\.  +0.j        ,
 0\.  +0.j        ,   0\.  +0.j        ],
 [-12.5 +4.0614962j ,   0\.  +0.j        ,   0\.  +0.j        ,
 0\.  +0.j        ,   0\.  +0.j        ],
 [-12.5 -4.0614962j ,   0\.  +0.j        ,   0\.  +0.j        ,
 0\.  +0.j        ,   0\.  +0.j        ],
 [-12.5-17.20477401j,   0\.  +0.j        ,   0\.  +0.j        ,
 0\.  +0.j        ,   0\.  +0.j        ]]) 

scipy.fft.ifft2

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

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

计算 2-D 离散傅里叶变换的逆变换。

该函数通过快速傅里叶变换（FFT）在 M-D 数组中的任意数量的轴上计算 2-D 离散傅里叶变换的逆变换。换句话说，对于数字精度内，ifft2(fft2(x)) == x。默认情况下，逆变换计算在输入数组的最后两个轴上。

输入与 [ifft](https://docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.ifft.html#scipy.fft.ifft "scipy.fft.ifft"）返回的相同方式排序，即应在两个轴的低序角处具有零频率项，这些轴的前半部分具有正频率项，在这些轴的中间具有奈奎斯特频率项，并且这些轴的后半部分具有负频率项，按照递减负频率的顺序。

参数：

x：类似数组

输入数组，可以是复数。

s：整数序列，可选

输出的形状（每个轴的长度）（s[0] 指代轴 0，s[1] 指代轴 1，依此类推）。对应于 ifft(x, n) 的 n。沿每个轴，如果给定的形状小于输入的形状，则输入会被裁剪。如果形状更大，则用零填充输入。如果未给定 s，则使用 axes 指定的轴上的输入形状。关于 [ifft](https://docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.ifft.html#scipy.fft.ifft "scipy.fft.ifft"）的零填充问题，请参阅注释。

axes：整数序列，可选

要计算 FFT 的轴。如果未给定，则使用最后两个轴。

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

标准化模式（见 [fft](https://docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.fft.html#scipy.fft.fft "scipy.fft.fft"））。默认为“backward”。

overwrite_x：布尔值，可选

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

workers：整数，可选

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

plan：对象，可选

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

1.5.0 版本中的新功能。

返回：

out：复数 ndarray

被截断或零填充的输入，在 axes 指示的轴上进行变换，或者最后两个轴如果未给定 axes。

异常：

值错误

如果 s 和 axes 长度不同，或者未给定 axes 且 len(s) != 2。

索引错误

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

另请参阅

fft2

前向二维 FFT，其中ifft2 是其逆过程。

ifftn

N 维 FFT 的逆过程。

fft

一维 FFT。

ifft

一维逆 FFT。

注意

ifft2 只是具有不同 axes 默认值的ifftn。

详见ifftn 以及绘图示例，并参考用法和约定定义的fft。

零填充与ifft 类似，通过在指定维度的输入后附加零来完成。尽管这是常见的方法，但可能会导致意外结果。如果需要其他形式的零填充，则必须在调用ifft2 之前执行。

示例

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

scipy.fft.fftn

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

scipy.fft.fftn(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，可选

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

overwrite_x布尔型，可选

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

workers整数，可选

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

计划对象，可选

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

自版本 1.5.0 起新增。

返回：

out复数 ndarray

被截断或零填充的输入，在由axes指示的轴或由参数部分中解释的s和x的组合中进行了转换。

Raises：

ValueError

如果s和axes的长度不同。

IndexError

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

另请参见

ifftn

fftn的逆，逆 N-D FFT。

fft

1-D FFT，其定义和惯例。

rfftn

实输入的 N-D FFT。

fft2

2-D FFT。

fftshift

将零频率项移到数组中心。

注意事项

输出与 fft 类似，包含所有轴的低阶角的零频率项，所有轴的前半部分的正频率项，所有轴中间的奈奎斯特频率项，以及所有轴后半部分的负频率项，按照递减负频率的顺序排列。

例子

>>> import scipy.fft
>>> import numpy as np
>>> x = np.mgrid[:3, :3, :3][0]
>>> scipy.fft.fftn(x, axes=(1, 2))
array([[[ 0.+0.j,   0.+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]],
 [[ 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]]])
>>> scipy.fft.fftn(x, (2, 2), axes=(0, 1))
array([[[ 2.+0.j,  2.+0.j,  2.+0.j], # may vary
 [ 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
>>> rng = np.random.default_rng()
>>> [X, Y] = np.meshgrid(2 * np.pi * np.arange(200) / 12,
...                      2 * np.pi * np.arange(200) / 34)
>>> S = np.sin(X) + np.cos(Y) + rng.uniform(0, 1, X.shape)
>>> FS = scipy.fft.fftn(S)
>>> plt.imshow(np.log(np.abs(scipy.fft.fftshift(FS))**2))
<matplotlib.image.AxesImage object at 0x...>
>>> plt.show() 

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，可选

归一化模式（请参见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, 可选

标准化模式（参见 [fft](https://docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fft.fft.html#scipy.fft.fft "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，可选

标准化模式（参见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，可选

标准化模式（参见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，可选

归一化模式（参见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，可选

归一化模式（参见 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，可选

规范化模式（详见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, 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，可选

规范化模式（参见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，可选

归一化模式（参见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，可选

标准化模式（请参见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，可选

标准化模式（详见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，可选

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

n，可选

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

axis整数，可选

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

norm，可选

规范化模式（见注释）。默认为“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，可选项

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

n整数，可选项

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

axis整数，可选项

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

norm，可选项

归一化模式（参见注释）。默认为“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数组样式

输入数组。

类型，可选

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”。

覆盖 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类似数组

输入数组。

类型，可选

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”。

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，可选

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

n整数，可选

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

axis整数，可选

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

norm，可选

归一化模式（见笔记）。默认为“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，可选

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”。

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 

scipy.fft.idstn

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

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

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

参数：

xarray_like

输入数组。

type，可选

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

sint 或 int 数组或 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相应维度的大小。

axesint 或 int 数组或 None，可选

计算逆离散正弦变换（IDST）的轴。如果未给出，则使用最后len(s)个轴，或者如果未指定s，则使用所有轴。

norm，可选

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

overwrite_xbool，可选

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

workersint，可选

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

orthogonalizebool，可选

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

自 1.8.0 版新增。

返回：

y实数的 ndarray

转换后的输入数组。

另请参见

dstn

多维 DST

注释

有关 IDST 类型和归一化模式的完整详细信息以及参考资料，请参阅idst。

示例

>>> 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 

scipy.fft.fht

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

scipy.fft.fht(a, dln, mu, offset=0.0, bias=0.0)

计算快速 Hankel 变换。

使用 FFTLog 算法[1], [2]计算对数间隔周期序列的离散 Hankel 变换。

参数：

a类似数组（…，n）

实数周期性输入数组，均匀对数间隔。对于多维输入，变换在最后一个轴上执行。

dln浮点数

输入数组的均匀对数间隔。

mu浮点数

Hankel 变换的阶数，任意正数或负数。

offset浮点数，可选

输出数组均匀对数间隔的偏移量。

bias浮点数，可选

幂律偏差的指数，任意正数或负数。

返回：

A类似数组（…，n）

转换后的输出数组，为实数、周期性、均匀对数间隔，并且与输入数组具有相同的形状。

另请参阅

ifht

fht的倒数。

fhtoffset

返回fht的最佳偏移量。

注意

此函数计算 Hankel 变换的离散版本

[A(k) = \int_{0}^{\infty} ! a(r) , J_\mu(kr) , k , dr ;,]

其中(J_\mu)是阶数为(\mu)的贝塞尔函数。指数(\mu)可以是任意实数，正数或负数。

输入数组a是长度为(n)的周期序列，均匀对数间隔为dln，

[a_j = a(r_j) ;, \quad r_j = r_c \exp[(j-j_c) , \mathtt{dln}]]

关于点(r_c)的中心化。请注意，如果(n)为偶数，则中心索引(j_c = (n-1)/2)为半整数，因此(r_c)位于两个输入元素之间。同样，输出数组A也是长度为(n)的周期序列，也均匀对数间隔，间隔为dln

[A_j = A(k_j) ;, \quad k_j = k_c \exp[(j-j_c) , \mathtt{dln}]]

关于点(k_c)的中心化。

周期间隔的中心点(r_c)和(k_c)可以任意选择，但通常选择乘积(k_c r_c = k_j r_{n-1-j} = k_{n-1-j} r_j)为单位。可以使用offset参数来更改这一点，该参数控制输出数组的对数偏移(\log(k_c) = \mathtt{offset} - \log(r_c))。选择offset的最佳值可能会减少离散 Hankel 变换的振铃。

如果bias参数非零，则此函数计算有偏 Hankel 变换的离散版本

[A(k) = \int_{0}^{\infty} ! a_q(r) , (kr)^q , J_\mu(kr) , k , dr]

其中(q)是bias的值，而幂律偏置(a_q(r) = a(r) , (kr)^{-q})被应用于输入序列。如果存在某个值(q)使得(a_q(r))接近周期序列，则偏置变换有助于逼近(a(r))的连续变换，此时得到的(A(k))将接近连续变换。

参考文献

[1]

Talman J. D., 1978, J. Comp. Phys., 29, 35

[2] (1,2)

Hamilton A. J. S., 2000, MNRAS, 312, 257 (astro-ph/9905191)

示例

该示例是fftlogtest.f的适应版本，该文件提供在[2]中。它评估了积分

[\int^\infty_0 r^{\mu+1} \exp(-r²/2) J_\mu(k, r) k dr = k^{\mu+1} \exp(-k²/2) .]

>>> import numpy as np
>>> from scipy import fft
>>> import matplotlib.pyplot as plt 

变换的参数。

>>> mu = 0.0                     # Order mu of Bessel function
>>> r = np.logspace(-7, 1, 128)  # Input evaluation points
>>> dln = np.log(r[1]/r[0])      # Step size
>>> offset = fft.fhtoffset(dln, initial=-6*np.log(10), mu=mu)
>>> k = np.exp(offset)/r[::-1]   # Output evaluation points 

定义分析函数。

>>> def f(x, mu):
...  """Analytical function: x^(mu+1) exp(-x²/2)."""
...     return x**(mu + 1)*np.exp(-x**2/2) 

使用 FFTLog 在r处评估函数，并计算相应的k值。

>>> a_r = f(r, mu)
>>> fht = fft.fht(a_r, dln, mu=mu, offset=offset) 

对于这个例子，我们实际上可以计算分析响应（在这种情况下与输入函数相同）以进行比较，并计算相对误差。

>>> a_k = f(k, mu)
>>> rel_err = abs((fht-a_k)/a_k) 

绘制结果。

>>> figargs = {'sharex': True, 'sharey': True, 'constrained_layout': True}
>>> fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4), **figargs)
>>> ax1.set_title(r'$r^{\mu+1}\ \exp(-r²/2)$')
>>> ax1.loglog(r, a_r, 'k', lw=2)
>>> ax1.set_xlabel('r')
>>> ax2.set_title(r'$k^{\mu+1} \exp(-k²/2)$')
>>> ax2.loglog(k, a_k, 'k', lw=2, label='Analytical')
>>> ax2.loglog(k, fht, 'C3--', lw=2, label='FFTLog')
>>> ax2.set_xlabel('k')
>>> ax2.legend(loc=3, framealpha=1)
>>> ax2.set_ylim([1e-10, 1e1])
>>> ax2b = ax2.twinx()
>>> ax2b.loglog(k, rel_err, 'C0', label='Rel. Error (-)')
>>> ax2b.set_ylabel('Rel. Error (-)', color='C0')
>>> ax2b.tick_params(axis='y', labelcolor='C0')
>>> ax2b.legend(loc=4, framealpha=1)
>>> ax2b.set_ylim([1e-9, 1e-3])
>>> plt.show() 

scipy.fft.ifht

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

scipy.fft.ifht(A, dln, mu, offset=0.0, bias=0.0)

计算逆快速 Hankel 变换。

计算对数间隔周期序列的离散逆 Hankel 变换。这是 fht 的逆操作。

参数：

A 数组样式（…，n）

实数周期输入数组，均匀对数间隔。对于多维输入，变换在最后一个轴上执行。

dln 浮点数

输入数组的均匀对数间隔。

mu 浮点数

Hankel 变换的阶数，任意正或负实数。

offset 浮点数，可选

输出数组的均匀对数间隔的偏移量。

bias 浮点数，可选

幂律偏差的指数，任意正或负实数。

返回：

a 数组样式（…，n）

转换后的输出数组，为实数，周期性，均匀对数间隔，并且与输入数组具有相同的形状。

另请参阅

fht

快速 Hankel 变换的定义。

fhtoffset

返回 ifht 的最佳偏移量。

注释

此函数计算 Hankel 变换的离散版本。

[a(r) = \int_{0}^{\infty} ! A(k) , J_\mu(kr) , r , dk ;,]

其中 (J_\mu) 是阶数为 (\mu) 的贝塞尔函数。指数 (\mu) 可以是任意实数，正或负。

更多细节请参阅 fht。

scipy.fft.fftshift

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

scipy.fft.fftshift(x, axes=None)

将零频率分量移到频谱中心。

此函数交换所有列出的轴的一半空间（默认为全部）。请注意，仅当 len(x) 为偶数时，y[0] 才是奈奎斯特分量。

参数：

x 类似数组

输入数组。

axes 整数或形状元组，可选

要移动的轴。默认为 None，移动所有轴。

返回：

y 数组

移位后的数组。

另请参见

ifftshift

fftshift 的反函数。

示例

>>> freqs = np.fft.fftfreq(10, 0.1)
>>> freqs
array([ 0.,  1.,  2., ..., -3., -2., -1.])
>>> np.fft.fftshift(freqs)
array([-5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.]) 

仅沿第二轴移动零频率分量：

>>> freqs = np.fft.fftfreq(9, d=1./9).reshape(3, 3)
>>> freqs
array([[ 0.,  1.,  2.],
 [ 3.,  4., -4.],
 [-3., -2., -1.]])
>>> np.fft.fftshift(freqs, axes=(1,))
array([[ 2.,  0.,  1.],
 [-4.,  3.,  4.],
 [-1., -3., -2.]]) 

scipy.fft.ifftshift

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

scipy.fft.ifftshift(x, axes=None)

fftshift的逆操作。对于偶数长度的x，两者相同；对于奇数长度的x，两者相差一个样本。

参数：

x：array_like

输入数组。

axes：int 或形状元组，可选

用于计算的轴。默认为 None，表示所有轴都移动。

返回：

y：ndarray

移位后的数组。

另请参阅

fftshift

将零频率分量移到频谱中心。

示例

>>> freqs = np.fft.fftfreq(9, d=1./9).reshape(3, 3)
>>> freqs
array([[ 0.,  1.,  2.],
 [ 3.,  4., -4.],
 [-3., -2., -1.]])
>>> np.fft.ifftshift(np.fft.fftshift(freqs))
array([[ 0.,  1.,  2.],
 [ 3.,  4., -4.],
 [-3., -2., -1.]]) 

scipy.fft.fftshift

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

scipy.fft.fftshift(x, axes=None)

将零频率分量移动到频谱中心。

此函数交换所有列出的轴的半空间（默认为所有）。注意，如果 len(x) 是偶数，y[0] 仅为奈奎斯特分量。

参数：

x：array_like

输入数组。

axes：int 或形状元组，可选

要移动的轴。默认为 None，表示移动所有轴。

返回：

y：ndarray

移动后的数组。

参见

ifftshift

fftshift 的逆操作。

示例

>>> freqs = np.fft.fftfreq(10, 0.1)
>>> freqs
array([ 0.,  1.,  2., ..., -3., -2., -1.])
>>> np.fft.fftshift(freqs)
array([-5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.]) 

仅沿第二轴移动零频率分量：

>>> freqs = np.fft.fftfreq(9, d=1./9).reshape(3, 3)
>>> freqs
array([[ 0.,  1.,  2.],
 [ 3.,  4., -4.],
 [-3., -2., -1.]])
>>> np.fft.fftshift(freqs, axes=(1,))
array([[ 2.,  0.,  1.],
 [-4.,  3.,  4.],
 [-1., -3., -2.]]) 

scipy.fft.fftfreq

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

scipy.fft.fftfreq(n, d=1.0, *, xp=None, device=None)

返回离散傅里叶变换的样本频率。

返回的浮点数组 f 包含每个频率箱的频率中心，单位为每个采样间隔的循环次数（从零开始）。例如，如果采样间隔以秒为单位，则频率单位为循环/秒。

给定窗口长度 n 和样本间隔 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 

参数：

n整数

窗口长度。

d标量，可选

样本间隔（采样率的倒数）。默认为 1。

xp数组命名空间，可选

返回数组的命名空间。默认为 None，使用 NumPy。

设备device，可选

返回数组的设备。仅当 xp.fft.fftfreq 实现设备参数时有效。

返回：

f数组

长度为 n 的数组，包含样本频率。

示例

>>> signal = np.array([-2, 8, 6, 4, 1, 0, 3, 5], dtype=float)
>>> fourier = scipy.fft.fft(signal)
>>> n = signal.size
>>> timestep = 0.1
>>> freq = scipy.fft.fftfreq(n, d=timestep)
>>> freq
array([ 0\.  ,  1.25,  2.5 , ..., -3.75, -2.5 , -1.25]) 

scipy.fft.rfftfreq

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

scipy.fft.rfftfreq(n, d=1.0, *, xp=None, device=None)

返回离散傅里叶变换样本频率（用于 rfft、irfft 的用法）。

返回的浮点数组f包含每个频率箱的中心，以每单位采样间距的周期数表示（从零开始）。例如，如果采样间距以秒为单位，则频率单位为周期/秒。

给定窗口长度n和采样间距d：

f = [0, 1, ...,     n/2-1,     n/2] / (d*n)   if n is even
f = [0, 1, ..., (n-1)/2-1, (n-1)/2] / (d*n)   if n is odd 

与fftfreq（但类似于scipy.fftpack.rfftfreq）不同，尼奎斯特频率分量被视为正。

参数：

nint

窗口长度。

d标量，可选

采样间距（采样率的倒数）。默认为 1。

xp数组命名空间，可选

返回数组的命名空间。默认为 None，即使用 NumPy。

devicedevice, optional

返回数组的设备。仅当xp.fft.rfftfreq实现设备参数时有效。

返回：

fndarray

长度为n//2 + 1的数组，包含样本频率。

示例

>>> signal = np.array([-2, 8, 6, 4, 1, 0, 3, 5, -3, 4], dtype=float)
>>> fourier = scipy.fft.rfft(signal)
>>> n = signal.size
>>> sample_rate = 100
>>> freq = scipy.fft.fftfreq(n, d=1./sample_rate)
>>> freq
array([  0.,  10.,  20., ..., -30., -20., -10.])
>>> freq = scipy.fft.rfftfreq(n, d=1./sample_rate)
>>> freq
array([  0.,  10.,  20.,  30.,  40.,  50.]) 

scipy.fft.fhtoffset

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

scipy.fft.fhtoffset(dln, mu, initial=0.0, bias=0.0)

返回快速 Hankel 变换的最佳偏移量。

返回一个接近初始值的偏置，以满足对数间距ln、阶数mu和偏置bias的快速 Hankel 变换fht的低环绕条件[1]。

参数：

lnfloat

变换的均匀对数间距。

mufloat

Hankel 变换的阶数，任意正或负实数。

初始值float，可选

偏移量的初始值。 返回最接近的值以满足低环绕条件。

偏置float，可选

幂律偏置指数，任意正或负实数。

返回：

偏移量float

变换均匀对数间距的最佳偏移量，满足低环绕条件。

另请参见

fht

快速 Hankel 变换的定义。

参考文献

[1]

Hamilton A. J. S., 2000, MNRAS, 312, 257 (astro-ph/9905191)

示例

>>> from scipy.fft import fhtoffset
>>> dln = 0.1
>>> mu = 2.0
>>> initial = 0.5
>>> bias = 0.0
>>> offset = fhtoffset(dln, mu, initial, bias)
>>> offset
0.5454581477676637 

scipy.fft.next_fast_len

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

scipy.fft.next_fast_len(target, real=False)

查找输入数据到fft的下一个快速大小，用于零填充等。

SciPy 的 FFT 算法通过递归的分而治之策略获得其速度。这依赖于处理输入长度的小质因数的高效函数。因此，当使用 FFT 实现处理的质因数的复合数时，变换最快。如果对所有小于等于n的基数都有高效函数，则结果将是一个具有只有小于n的质因数的数x >= target。（也称为n-光滑数）

参数：

target整数

开始搜索的长度。必须是正整数。

real布尔型，可选

如果 FFT 涉及实数输入或输出（例如，rfft或hfft但不包括fft），默认为 False。

返回：

out整数

大于或等于target的最小快速长度。

注意

此函数的结果可能会随着性能考虑的变化而改变，例如，如果添加了新的质因数。

调用fft或ifft处理实数输入数据时，内部执行'R2C'变换。

示例

在特定机器上，质数长度的 FFT 需要 11.4 ms：

>>> from scipy import fft
>>> import numpy as np
>>> rng = np.random.default_rng()
>>> min_len = 93059  # prime length is worst case for speed
>>> a = rng.standard_normal(min_len)
>>> b = fft.fft(a) 

零填充到下一个正规长度可将计算时间减少到 1.6 ms，加快了 7.3 倍：

>>> fft.next_fast_len(min_len, real=True)
93312
>>> b = fft.fft(a, 93312) 

将大小舍入到下一个 2 的幂不是最优的，计算时间为 3.0 ms；比next_fast_len给出的大小长 1.9 倍：

>>> b = fft.fft(a, 131072) 

scipy.fft.set_workers

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

scipy.fft.set_workers(workers)

用于scipy.fft中默认工作线程数的上下文管理器

参数：

workersint

默认使用的工作线程数

示例

>>> import numpy as np
>>> from scipy import fft, signal
>>> rng = np.random.default_rng()
>>> x = rng.standard_normal((128, 64))
>>> with fft.set_workers(4):
...     y = signal.fftconvolve(x, x) 

离散傅立叶变换（scipy.fft）

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

快速傅立叶变换（FFT）

fft(x[, n, axis, norm, overwrite_x, ...])	计算一维离散傅立叶变换。
ifft(x[, n, axis, norm, overwrite_x, ...])	计算一维逆离散傅立叶变换。
fft2(x[, s, axes, norm, overwrite_x, ...])	计算二维离散傅立叶变换。
ifft2(x[, s, axes, norm, overwrite_x, ...])	计算二维逆离散傅立叶变换。
fftn(x[, s, axes, norm, overwrite_x, ...])	计算 N 维离散傅立叶变换。
ifftn(x[, s, axes, norm, overwrite_x, ...])	计算 N 维逆离散傅立叶变换。
rfft(x[, n, axis, norm, overwrite_x, ...])	计算实数输入的一维离散傅立叶变换。
irfft(x[, n, axis, norm, overwrite_x, ...])	计算 rfft 的逆变换。
rfft2(x[, s, axes, norm, overwrite_x, ...])	计算实数组的二维 FFT。
irfft2(x[, s, axes, norm, overwrite_x, ...])	计算 rfft2 的逆变换。
rfftn(x[, s, axes, norm, overwrite_x, ...])	计算实数输入的 N 维离散傅立叶变换。
irfftn(x[, s, axes, norm, overwrite_x, ...])	计算 rfftn 的逆变换
hfft(x[, n, axis, norm, overwrite_x, ...])	计算具有 Hermite 对称性的信号的 FFT，即实谱。
ihfft(x[, n, axis, norm, overwrite_x, ...])	计算具有 Hermite 对称性的信号的逆 FFT。
hfft2(x[, s, axes, norm, overwrite_x, ...])	计算 Hermitian 复数数组的二维 FFT。
ihfft2(x[, s, axes, norm, overwrite_x, ...])	计算实谱的 2-D 逆傅里叶变换。
hfftn(x[, s, axes, norm, overwrite_x, ...])	计算具有埃尔米特对称复输入的 N-D FFT，即具有实谱的信号。
ihfftn(x[, s, axes, norm, overwrite_x, ...])	计算实谱的 N-D 逆离散傅里叶变换。

离散正弦和余弦变换（DST 和 DCT）

dct(x[, type, n, axis, norm, overwrite_x, ...])	返回任意类型序列 x 的离散余弦变换。
idct(x[, type, n, axis, norm, overwrite_x, ...])	返回任意类型序列的逆离散余弦变换。
dctn(x[, type, s, axes, norm, overwrite_x, ...])	返回指定轴上的多维离散余弦变换。
idctn(x[, type, s, axes, norm, overwrite_x, ...])	返回指定轴上的多维逆离散余弦变换。
dst(x[, type, n, axis, norm, overwrite_x, ...])	返回任意类型序列 x 的离散正弦变换。
idst(x[, type, n, axis, norm, overwrite_x, ...])	返回任意类型序列的逆离散正弦变换。
dstn(x[, type, s, axes, norm, overwrite_x, ...])	返回指定轴上的多维离散正弦变换。
idstn(x[, type, s, axes, norm, overwrite_x, ...])	返回指定轴上的多维逆离散正弦变换。

快速汉克尔变换

fht(a, dln, mu[, offset, bias])	计算快速汉克尔变换。
ifht(A, dln, mu[, offset, bias])	计算快速汉克尔逆变换。

助手函数

fftshift(x[, axes])	将零频率分量移至频谱中心。
ifftshift(x[, axes])	fftshift 的逆操作。
fftfreq(n[, d, xp, device])	返回离散傅里叶变换的采样频率。
rfftfreq(n[, d, xp, device])	返回离散傅里叶变换的采样频率（用于 rfft、irfft 的使用）。
fhtoffset(dln, mu[, initial, bias])	返回快速 Hankel 变换的最佳偏移量。
next_fast_len(target[, real])	查找输入数据的下一个快速 FFT 大小，用于零填充等。
set_workers(workers)	默认工作线程数的上下文管理器，用于scipy.fft。
get_workers()	返回当前上下文中默认的工作线程数。

后端控制

set_backend(backend[, coerce, only])	上下文管理器，在固定范围内设置后端。
skip_backend(backend)	上下文管理器，在固定范围内跳过一个后端。
set_global_backend(backend[, coerce, only, ...])	设置全局 FFT 后端。
register_backend(backend)	注册一个后端以供永久使用。

scipy.fft.get_workers

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

scipy.fft.get_workers()

返回当前上下文中的默认工作线程数

Examples

>>> from scipy import fft
>>> fft.get_workers()
1
>>> with fft.set_workers(4):
...     fft.get_workers()
4 

scipy.fft.set_backend

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

scipy.fft.set_backend(backend, coerce=False, only=False)

在固定作用域内设置后端的上下文管理器。

进入 with 语句时，给定的后端将被添加到可用后端列表中，并具有最高优先级。退出时，后端将被重置为进入该作用域之前的状态。

参数：

backend

要使用的后端。可以是包含已知后端名称 {‘scipy’} 的 str，或者实现了 uarray 协议的对象。

coercebool，可选

是否允许对 x 参数进行昂贵的转换，例如将 NumPy 数组复制到 CuPy 后端的 GPU。暗示 only。

onlybool，可选

如果 only 设为 True，并且此后端返回 NotImplemented，那么将立即引发 BackendNotImplemented 错误。忽略任何优先级低于当前的后端。

示例

>>> import scipy.fft as fft
>>> with fft.set_backend('scipy', only=True):
...     fft.fft([1])  # Always calls the scipy implementation
array([1.+0.j]) 

scipy.fft.skip_backend

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

scipy.fft.skip_backend(backend)

在固定范围内跳过后端的上下文管理器。

在with语句的上下文中，给定的后端不会被调用。这包括本地和全局注册的后端。退出时，后端将被重新考虑。

参数：

后端

跳过的后端。可以是一个str，包含已知后端的名称{‘scipy’}，或者实现了 uarray 协议的对象。

示例

>>> import scipy.fft as fft
>>> fft.fft([1])  # Calls default SciPy backend
array([1.+0.j])
>>> with fft.skip_backend('scipy'):  # We explicitly skip the SciPy backend
...     fft.fft([1])                 # leaving no implementation available
Traceback (most recent call last):
  ...
BackendNotImplementedError: No selected backends had an implementation ... 

scipy.fft.set_global_backend

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

scipy.fft.set_global_backend(backend, coerce=False, only=False, try_last=False)

设置全局 fft 后端

此实用方法将永久替换默认后端。它将自动在后端列表中尝试，除非在后端上设置了 only 标志。这将是除了set_backend上下文管理器之外第一个尝试的后端。

Parameters:

后端

要使用的后端。可以是包含已知后端名称 {‘scipy’} 的 str，或实现 uarray 协议的对象。

coercebool

尝试此后端时是否强制转换输入类型。

onlybool

如果 True，如果失败，则不会再尝试更多后端。由 coerce=True 隐含。

try_lastbool

如果 True，在注册的后端之后尝试全局后端。

Raises:

ValueError: 如果后端未实现 numpy.scipy.fft。

Notes

这将覆盖先前设置的全局后端，默认情况下为 SciPy 实现。

Examples

我们可以设置全局 fft 后端：

>>> from scipy.fft import fft, set_global_backend
>>> set_global_backend("scipy")  # Sets global backend (default is "scipy").
>>> fft([1])  # Calls the global backend
array([1.+0.j]) 

scipy.fft.register_backend

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

scipy.fft.register_backend(backend)

注册一个永久使用的后端。

已注册的后端具有最低优先级，并将在全局后端之后尝试。

参数：

后端

要使用的后端。可以是包含已知后端名称{‘scipy’}的str，也可以是实现 uarray 协议的对象。

引发：

ValueError: 如果后端未实现numpy.scipy.fft。

示例

我们可以注册一个新的 fft 后端：

>>> from scipy.fft import fft, register_backend, set_global_backend
>>> class NoopBackend:  # Define an invalid Backend
...     __ua_domain__ = "numpy.scipy.fft"
...     def __ua_function__(self, func, args, kwargs):
...          return NotImplemented
>>> set_global_backend(NoopBackend())  # Set the invalid backend as global
>>> register_backend("scipy")  # Register a new backend
# The registered backend is called because
# the global backend returns `NotImplemented`
>>> fft([1])
array([1.+0.j])
>>> set_global_backend("scipy")  # Restore global backend to default 

旧版离散傅里叶变换（scipy.fftpack）

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

旧版

此子模块被视为旧版，并将不再接收更新。这也可能意味着它将在未来的 SciPy 版本中被移除。新代码应使用 scipy.fft。

快速傅里叶变换（FFT）

fft	返回实数或复数序列的离散傅里叶变换。
ifft	返回实数或复数序列的离散逆傅里叶变换。
fft2	2-D 离散傅里叶变换。
ifft2	返回实数或复数序列的二维离散逆傅里叶变换。
fftn	返回多维离散傅里叶变换。
ifftn	返回多维离散傅里叶变换的逆变换。
rfft	实数序列的离散傅里叶变换。
irfft	返回实数序列 x 的离散逆傅里叶变换。
dct	返回任意类型序列 x 的离散余弦变换。
idct	返回任意类型序列的逆离散余弦变换。
dctn	返回指定轴上的多维离散余弦变换。
idctn	返回指定轴上的多维离散余弦变换。
dst	返回任意类型序列 x 的离散正弦变换。
idst(x[, type, n, axis, norm, overwrite_x])	返回任意类型序列的逆离散正弦变换。
dstn(x[, type, shape, axes, norm, overwrite_x])	返回沿指定轴的多维离散正弦变换。
idstn(x[, type, shape, axes, norm, overwrite_x])	返回沿指定轴的多维离散正弦变换。

微分和伪微分算子

diff(x[, order, period, _cache])	返回周期序列 x 的第 k 阶导数（或积分）。
tilbert(x, h[, period, _cache])	返回周期序列 x 的 h-Tilbert 变换。
itilbert(x, h[, period, _cache])	返回周期序列 x 的逆 h-Tilbert 变换。
hilbert(x[, _cache])	返回周期序列 x 的 Hilbert 变换。
ihilbert(x)	返回周期序列 x 的逆 Hilbert 变换。
cs_diff(x, a, b[, period, _cache])	返回周期序列 x 的(a,b)-cosh/sinh 伪导数。
sc_diff(x, a, b[, period, _cache])	返回周期序列 x 的(a,b)-sinh/cosh 伪导数。
ss_diff(x, a, b[, period, _cache])	返回周期序列 x 的(a,b)-sinh/sinh 伪导数。
cc_diff(x, a, b[, period, _cache])	返回周期序列的(a,b)-cosh/cosh 伪导数。
shift(x, a[, period, _cache])	将周期序列 x 向右移动 a 个单位：y(u) = x(u+a)。

辅助函数

fftshift(x[, axes])	将零频率分量移动到频谱中心。
ifftshift(x[, axes])	fftshift的逆操作。
fftfreq(n[, d])	返回离散傅里叶变换的采样频率。
rfftfreq(n[, d])	DFT 样本频率（用于 rfft, irfft）。
next_fast_len(target)	查找输入数据的下一个快速大小，以用于 fft，例如零填充等。

注意 fftshift, ifftshift 和 fftfreq 是由 fftpack 暴露的 numpy 函数；应优先从 numpy 导入它们。

卷积 (scipy.fftpack.convolve)

convolve(x,omega,[swap_real_imag,overwrite_x])	convolve 的包装器。
convolve_z(x,omega_real,omega_imag,[overwrite_x])	convolve_z 的包装器。
init_convolution_kernel(...)	init_convolution_kernel 的包装器。
destroy_convolve_cache()

scipy.fftpack.fft

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

scipy.fftpack.fft(x, n=None, axis=-1, overwrite_x=False)

返回实数或复数序列的离散傅里叶变换。

返回的复数数组包含y(0), y(1),..., y(n-1)，其中

y(j) = (x * exp(-2*pi*sqrt(-1)*j*np.arange(n)/n)).sum()。

参数：

xarray_like

要进行傅里叶变换的数组。

nint，可选

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

axisint，可选

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

overwrite_xbool，可选

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

返回：

zcomplex ndarray

具有以下元素：

[y(0),y(1),..,y(n/2),y(1-n/2),...,y(-1)]        if n is even
[y(0),y(1),..,y((n-1)/2),y(-(n-1)/2),...,y(-1)]  if n is odd 

其中：

y(j) = sum[k=0..n-1] x[k] * exp(-sqrt(-1)*j*k* 2*pi/n), j = 0..n-1 

另请参阅

ifft

逆 FFT

rfft

实序列的 FFT

注意

结果的打包是“标准的”：如果A = fft(a, n)，那么A[0]包含零频率项，A[1:n/2]包含正频率项，A[n/2:]按递减负频率顺序包含负频率项。因此，对于 8 点变换，结果的频率为[0, 1, 2, 3, -4, -3, -2, -1]。要重新排列 fft 输出，使零频率分量居中，如[-4, -3, -2, -1, 0, 1, 2, 3]，请使用fftshift。

实现了单精度和双精度例程。半精度输入将被转换为单精度。非浮点输入将被转换为双精度。不支持长双精度输入。

当n是 2 的幂时，此函数效率最高，当n是质数时效率最低。

请注意，如果x是实数值，则A[j] == A[n-j].conjugate()。如果x是实数值且n是偶数，则A[n/2]是实数数值。

如果x的数据类型是实数，则会自动使用“实 FFT”算法，大致减半计算时间。为了进一步提高效率，可以使用rfft，它执行相同的计算，但只输出对称频谱的一半。如果数据既是实数又是对称的，则dct可以通过从信号的一半生成一半频谱再次将效率提高一倍。

示例

>>> import numpy as np
>>> from scipy.fftpack import fft, ifft
>>> x = np.arange(5)
>>> np.allclose(fft(ifft(x)), x, atol=1e-15)  # within numerical accuracy.
True 

scipy.fftpack.ifft

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fftpack.ifft.html#scipy.fftpack.ifft

scipy.fftpack.ifft(x, n=None, axis=-1, overwrite_x=False)

返回实数或复数序列的离散反向傅里叶变换。

返回的复数数组包含y(0), y(1),..., y(n-1)，其中

y(j) = (x * exp(2*pi*sqrt(-1)*j*np.arange(n)/n)).mean()。

参数：

x：array_like

要反转的转换数据。

n：整数，可选

逆傅里叶变换的长度。如果n < x.shape[axis]，则截断x。如果n > x.shape[axis]，则用零填充x。默认情况下结果为n = x.shape[axis]。

axis：整数，可选

进行 IFFT 计算的轴；默认在最后一个轴上进行（即axis=-1）。

overwrite_x：布尔值，可选

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

返回：

ifft：浮点数的 ndarray

逆离散里叶变换。

另请参阅

fft

正向傅里叶变换

注意事项

实 实现了单精度和双精度的例程。半精度输入将被转换为单精度。非浮点输入将被转换为双精度。不支持长双精度输入。

当n是 2 的幂时，此函数效率最高，当n是素数时效率最低。

如果x的数据类型是实数，则自动使用“实数 IFFT”算法，大致减少了计算时间的一半。

示例

>>> from scipy.fftpack import fft, ifft
>>> import numpy as np
>>> x = np.arange(5)
>>> np.allclose(ifft(fft(x)), x, atol=1e-15)  # within numerical accuracy.
True 

scipy.fftpack.fft2

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fftpack.fft2.html#scipy.fftpack.fft2

scipy.fftpack.fft2(x, shape=None, axes=(-2, -1), overwrite_x=False)

2-D 离散傅里叶变换。

返回二维参数 x 的二维离散傅里叶变换。

另请参阅

fftn

有关详细信息。

示例

>>> import numpy as np
>>> from scipy.fftpack import fft2, ifft2
>>> y = np.mgrid[:5, :5][0]
>>> y
array([[0, 0, 0, 0, 0],
 [1, 1, 1, 1, 1],
 [2, 2, 2, 2, 2],
 [3, 3, 3, 3, 3],
 [4, 4, 4, 4, 4]])
>>> np.allclose(y, ifft2(fft2(y)))
True 

scipy.fftpack.ifft2

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fftpack.ifft2.html#scipy.fftpack.ifft2

scipy.fftpack.ifft2(x, shape=None, axes=(-2, -1), overwrite_x=False)

2-D 离散逆傅里叶变换，适用于实数或复数序列。

返回任意类型序列 x 的逆 2-D 离散傅里叶变换。

更多信息请参见 ifft。

另请参阅

fft2, ifft

示例

>>> import numpy as np
>>> from scipy.fftpack import fft2, ifft2
>>> y = np.mgrid[:5, :5][0]
>>> y
array([[0, 0, 0, 0, 0],
 [1, 1, 1, 1, 1],
 [2, 2, 2, 2, 2],
 [3, 3, 3, 3, 3],
 [4, 4, 4, 4, 4]])
>>> np.allclose(y, fft2(ifft2(y)))
True 

scipy.fftpack.fftn

docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fftpack.fftn.html#scipy.fftpack.fftn

scipy.fftpack.fftn(x, shape=None, axes=None, overwrite_x=False)

返回多维离散傅立叶变换。

返回的数组包含：

y[j_1,..,j_d] = sum[k_1=0..n_1-1, ..., k_d=0..n_d-1]
   x[k_1,..,k_d] * prod[i=1..d] exp(-sqrt(-1)*2*pi/n_i * j_i * k_i) 

其中 d = len(x.shape)，n = x.shape。

参数：

x：类似数组

（N-D）要转换的数组。

shape：整数或整数数组或 None，可选

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

axes：整数或整数数组或 None，可选

应用变换的x的轴（如果shape不为 None，则为y）。默认值是所有轴。

overwrite_x：布尔值，可选

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

返回：

y：复数值 N 维 NumPy 数组

输入数组的（N-D）离散傅立叶变换。

另请参阅

ifftn

注意事项

如果x是实值，则y[..., j_i, ...] == y[..., n_i-j_i, ...].conjugate()。

实现了单精度和双精度例程。半精度输入将转换为单精度。非浮点输入将转换为双精度。不支持长双精度输入。

示例

>>> import numpy as np
>>> from scipy.fftpack import fftn, ifftn
>>> y = (-np.arange(16), 8 - np.arange(16), np.arange(16))
>>> np.allclose(y, fftn(ifftn(y)))
True 

scipy.fftpack.ifftn

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.fftpack.ifftn.html#scipy.fftpack.ifftn

scipy.fftpack.ifftn(x, shape=None, axes=None, overwrite_x=False)

返回多维离散傅立叶逆变换。

序列可以是任意类型。

返回的数组包含：

y[j_1,..,j_d] = 1/p * sum[k_1=0..n_1-1, ..., k_d=0..n_d-1]
   x[k_1,..,k_d] * prod[i=1..d] exp(sqrt(-1)*2*pi/n_i * j_i * k_i) 

其中 d = len(x.shape), n = x.shape, 以及 p = prod[i=1..d] n_i.

参数描述，请参阅 fftn。

参见

fftn

有关详细信息，请参阅。

示例

>>> from scipy.fftpack import fftn, ifftn
>>> import numpy as np
>>> y = (-np.arange(16), 8 - np.arange(16), np.arange(16))
>>> np.allclose(y, ifftn(fftn(y)))
True 

scipy.fftpack.rfft

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

scipy.fftpack.rfft(x, n=None, axis=-1, overwrite_x=False)

实序列的离散傅里叶变换。

参数：

x类似数组，实数值

要进行变换的数据。

nint，可选

定义傅里叶变换的长度。如果未指定n（默认），则n = x.shape[axis]。如果n < x.shape[axis]，x将被截断，如果n > x.shape[axis]，x将被零填充。

axis整数，可选

应用变换的轴线。默认为最后一个轴线。

overwrite_x布尔值，可选

如果设置为 true，则x的内容可以被覆盖。默认为 False。

返回值：

z实数数组

返回的实数数组包含：

[y(0),Re(y(1)),Im(y(1)),...,Re(y(n/2))]              if n is even
[y(0),Re(y(1)),Im(y(1)),...,Re(y(n/2)),Im(y(n/2))]   if n is odd 

其中：

y(j) = sum[k=0..n-1] x[k] * exp(-sqrt(-1)*j*k*2*pi/n)
j = 0..n-1 

另请参阅

fft，irfft，scipy.fft.rfft

注意事项

在数值精度范围内，y == rfft(irfft(y))。

实现了单精度和双精度例程。半精度输入将被转换为单精度。非浮点输入将被转换为双精度。不支持长双精度输入。

要获得具有复数数据类型的输出，请考虑使用更新的函数scipy.fft.rfft。

示例

>>> from scipy.fftpack import fft, rfft
>>> a = [9, -9, 1, 3]
>>> fft(a)
array([  4\. +0.j,   8.+12.j,  16\. +0.j,   8.-12.j])
>>> rfft(a)
array([  4.,   8.,  12.,  16.]) 

scipy.fftpack.irfft

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

scipy.fftpack.irfft(x, n=None, axis=-1, overwrite_x=False)

返回实序列 x 的逆离散傅里叶变换。

x的内容被解释为rfft函数的输出。

参数：

x类似数组

要反转的变换数据。

nint，可选

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

axisint，可选

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

overwrite_x布尔值，可选

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

返回：

irfft浮点数的 ndarray

逆离散傅里叶变换。

另请参阅

rfft，ifft，scipy.fft.irfft

注意事项

返回的实数组包含：

[y(0),y(1),...,y(n-1)] 

对于 n 为偶数的情况：

y(j) = 1/n (sum[k=1..n/2-1] (x[2*k-1]+sqrt(-1)*x[2*k])
                             * exp(sqrt(-1)*j*k* 2*pi/n)
            + c.c. + x[0] + (-1)**(j) x[n-1]) 

对于 n 为奇数：

y(j) = 1/n (sum[k=1..(n-1)/2] (x[2*k-1]+sqrt(-1)*x[2*k])
                             * exp(sqrt(-1)*j*k* 2*pi/n)
            + c.c. + x[0]) 

c.c. 表示前述表达式的复共轭。

有关输入参数的详细信息，请参见rfft。

考虑使用较新的函数scipy.fft.irfft处理（共轭对称）频域数据。

示例

>>> from scipy.fftpack import rfft, irfft
>>> a = [1.0, 2.0, 3.0, 4.0, 5.0]
>>> irfft(a)
array([ 2.6       , -3.16405192,  1.24398433, -1.14955713,  1.46962473])
>>> irfft(rfft(a))
array([1., 2., 3., 4., 5.]) 

scipy.fftpack.dct

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

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

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

参数:

x类似数组

输入数组。

type, 可选

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

n整数, 可选

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

axis整数, 可选

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

norm, 可选

归一化模式（见注意）。默认为 None。

overwrite_xbool, 可选

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

返回:

y实数的 ndarray

转换后的输入数组。

另见

idct

逆 DCT

注意

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

理论上有 8 种 DCT，但在 scipy 中只实现了前 4 种。‘The’ DCT 通常指 DCT 类型 2，而‘the’ Inverse DCT 通常指 DCT 类型 3。

Type I

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

[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)]

如果 norm='ortho'，x[0] 和 x[N-1] 被乘以缩放因子 (\sqrt{2})，而 y[k] 被乘以缩放因子 f

[\begin{split}f = \begin{cases} \frac{1}{2}\sqrt{\frac{1}{N-1}} & \text{如果 }k=0\text{ 或 }N-1, \ \frac{1}{2}\sqrt{\frac{2}{N-1}} & \text{否则} \end{cases}\end{split}]

1.2.0 版本新增：在 DCT-I 中进行正交化。

注意

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

Type II

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

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

如果 norm='ortho'，y[k] 被乘以缩放因子 f

[\begin{split}f = \begin{cases} \sqrt{\frac{1}{4N}} & \text{如果 }k=0, \ \sqrt{\frac{1}{2N}} & \text{否则} \end{cases}\end{split}]

使得对应的系数矩阵正交化 (O @ O.T = np.eye(N)).

Type III

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

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

或者对于 norm='ortho'

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

(未标准化的) DCT-III 是 (未标准化的) DCT-II 的逆，乘以 2N 的因子。正交化的 DCT-III 正好是正交化的 DCT-II 的逆。

Type IV

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

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

如果 norm='ortho'，y[k] 会乘以一个缩放因子 f

[f = \frac{1}{\sqrt{2N}}]

新版本 1.2.0 中：支持 DCT-IV。

References

[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]

Wikipedia，“离散余弦变换”，en.wikipedia.org/wiki/Discrete_cosine_transform

Examples

Type 1 DCT 对于实数、偶对称输入等效于 FFT（尽管更快）。 输出也是实数和偶对称的。 FFT 输入的一半用于生成 FFT 输出的一半：

>>> from scipy.fftpack 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.fftpack.idct

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

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

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

参数：

x类数组

输入数组。

type，可选

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

n整数，可选

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

axis整数，可选

进行 idct 的轴；默认值是最后一个轴（即，axis=-1）。

norm，可选

标准化模式（见注释）。默认为 None。

overwrite_x布尔值，可选

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

返回：

idct实数的 ndarray

转换后的输入数组。

另请参阅

dct

正向 DCT

注释

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

‘The’ IDCT 是类型 2 的 IDCT，它与类型 3 的 DCT 相同。

类型 1 的 IDCT 是类型 1 的 DCT，类型 2 的 IDCT 是类型 3 的 DCT，类型 3 的 IDCT 是类型 2 的 DCT。类型 4 的 IDCT 是类型 4 的 DCT。有关这些类型的定义，请参阅dct。

示例

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

>>> from scipy.fftpack 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) / 6
array([  4.,   3.,   5.,  10.]) 

scipy.fftpack.dctn

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

scipy.fftpack.dctn(x, type=2, shape=None, axes=None, norm=None, overwrite_x=False)

沿指定轴执行多维离散余弦变换。

参数：

x类似数组

输入数组。

type，可选

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

shapeint 或整数数组或 None，可选

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

axesint 或整数数组或 None，可选

计算 DCT 的轴。默认为所有轴。

norm，可选

标准化模式（参见注释）。默认为 None。

overwrite_xbool, optional

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

返回：

y实数的 ndarray

变换后的输入数组。

另见

idctn

反转的多维离散余弦变换

注释

关于 DCT 类型和标准化模式的详细信息以及参考文献，请参见 dct。

示例

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

scipy.fftpack.idctn

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

scipy.fftpack.idctn(x, type=2, shape=None, axes=None, norm=None, overwrite_x=False)

返回沿指定轴执行的多维离散余弦变换。

参数：

x类似数组

输入数组。

type，可选

离散余弦变换的类型（见注释）。默认类型为 2。

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

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

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

计算反离散余弦变换的轴。默认值为所有轴。

norm，可选

规范化模式（见注释）。默认为 None。

overwrite_x布尔值，可选

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

返回：

y实数的 ndarray

变换后的输入数组。

另请参阅

dctn

多维离散余弦变换

注释

关于 IDCT 类型和规范化模式的完整细节，以及参考资料，请参阅idct。

示例

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

scipy.fftpack.dst

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

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

返回任意类型序列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：{None, 'ortho'}，可选

归一化模式（见注释）。默认为 None。

overwrite_x：布尔值，可选

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

返回：

dst：实数组

转换后的输入数组。

另请参阅

idst

逆 DST

注释

对于单维数组x。

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

类型 I

DST-I 有多种定义；我们使用以下定义（对于norm=None）。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)]

注意，只有当输入大小>1 时，才支持 DST-I。 （未归一化的）DST-I 是其自身的逆，乘以因子2(N+1)。 归一化的 DST-I 恰好是其自身的逆。

类型 II

DST-II 有多种定义；我们使用以下定义（对于norm=None）。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)]

如果norm='ortho'，y[k]会乘以一个缩放因子f

[\begin{split}f = \begin{cases} \sqrt{\frac{1}{4N}} & \text{if }k = 0, \ \sqrt{\frac{1}{2N}} & \text{otherwise} \end{cases}\end{split}]

类型 III

DST-III 有多种定义，我们使用以下定义（对于norm=None）。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)]

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

从版本 0.11.0 开始。

类型 IV

DST-IV 有多种定义，我们使用以下定义（对于norm=None）。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)]

（未归一化的）DST-IV 是其自身的逆变换，除了一个因子 2N。正交化后的 DST-IV 正是其自身的逆变换。

自 1.2.0 版本新功能：支持 DST-IV。

参考文献

[1]

维基百科，“离散正弦变换”，zh.wikipedia.org/wiki/离散正弦变换

scipy.fftpack.idst

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

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

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

参数：

xarray_like

输入数组。

type，可选

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

nint，可选

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

axisint, optional

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

norm，可选

标准化模式（见注释）。默认为 None。

overwrite_xbool, optional

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

返回：

idstndarray of real

转换后的输入数组。

另请参见

dst

前向 DST

注释

‘The’ IDST 是类型 2 的 IDST，与类型 3 的 DST 相同。

类型 1 的 IDST 是类型 1 的 DST，类型 2 的 IDST 是类型 3 的 DST，类型 3 的 IDST 是类型 2 的 DST。关于这些类型的定义，请参见 dst。

自版本 0.11.0 新增。