SciPy 1.12 中文文档（七）

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

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{1, 2, 3, 4}，可选

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", "ortho", "forward"}，可选

归一化模式（见注释）。默认为“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{object, ‘scipy’}

要使用的后端。可以是包含已知后端名称 {‘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语句的上下文中，给定的后端不会被调用。这包括本地和全局注册的后端。退出时，后端将被重新考虑。

参数：

后端{object, ‘scipy’}

跳过的后端。可以是一个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:

后端{object, ‘scipy’}

要使用的后端。可以是包含已知后端名称 {‘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)

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

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

参数：

后端{object, ‘scipy’}

要使用的后端。可以是包含已知后端名称{‘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{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{None, ‘ortho’}, 可选

归一化模式（见注意）。默认为 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{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{None, ‘ortho’}，可选

标准化模式（见注释）。默认为 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{1, 2, 3, 4}，可选

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, ‘ortho’}，可选

标准化模式（参见注释）。默认为 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{1, 2, 3, 4}，可选

离散余弦变换的类型（见注释）。默认类型为 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, ‘ortho’}，可选

规范化模式（见注释）。默认为 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{1, 2, 3, 4}，可选

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

nint，可选

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

axisint, optional

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

norm{None, ‘ortho’}，可选

标准化模式（见注释）。默认为 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 新增。

scipy.fftpack.dstn

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

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

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

参数：

x 类似数组。

输入数组。

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

DST 的类型（见注释）。默认类型为 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，可选。

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

norm {None, ‘ortho’}，可选。

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

overwrite_x 布尔值，可选。

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

返回：

y 实数的 ndarray。

变换后的输入数组。

另见

idstn

多维逆正弦变换。

注释

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

示例

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