JAX 中文文档（十三）（5）

JAX 中文文档（十三）（4）https://developer.aliyun.com/article/1559745

jax.numpy.fft.fft

原文：jax.readthedocs.io/en/latest/_autosummary/jax.numpy.fft.fft.html

jax.numpy.fft.fft(a, n=None, axis=-1, norm=None)

计算一维离散傅里叶变换。

numpy.fft.fft() 的 LAX-backend 实现。

下面是原始文档字符串。

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

参数：

• a (array_like) – 输入数组，可以是复数。
  
• n (int, optional) – 输出的变换轴的长度。如果 n 小于输入的长度，则会截取输入。如果 n 较大，则在末尾用零填充输入。如果未提供 n，则使用由 axis 指定的轴上的输入长度。
  
• axis (int, optional) – 计算 FFT 的轴。如果未给出，则使用最后一个轴。
  
• norm ({“backward”**, “ortho”**, “forward”}**, optional) – 规范化方式，可选。
  

返回值：

out – 截断或零填充的输入，沿由 axis 指示的轴进行变换，如果未指定 axis，则为最后一个轴。

返回类型：

复数 ndarray

参考文献

[CT]

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

jax.numpy.fft.fft2

原文：jax.readthedocs.io/en/latest/_autosummary/jax.numpy.fft.fft2.html

jax.numpy.fft.fft2(a, s=None, axes=(-2, -1), norm=None)

计算二维离散傅立叶变换。

numpy.fft.fft2()的 LAX 后端实现。

以下是原始文档字符串。

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

参数：

• a（array_like） – 输入数组，可以是复数
  
• s（整数序列，可选） –
  输出的形状（每个转换轴的长度）（s[0]指代轴 0，s[1]指代轴 1 等）。这对应于fft(x, n)中的n。沿着每个轴，如果给定的形状比输入小，则截断输入。如果大，则用零填充输入。
  自 2.0 版更改：如果为-1，则使用整个输入（无填充/修剪）。
  如果未提供s，则使用指定轴上输入的形状。
  自 2.0 版起已弃用：如果s不是None，则axes也不能是None。
  自 2.0 版起已弃用：s必须仅包含int，而不是None值。当前None值意味着在相应的一维变换中使用n的默认值，但此行为已弃用。
  
• axes（整数序列，可选） –
  计算 FFT 的轴。如果未给出，则使用最后两个轴。轴中的重复索引表示在该轴上执行多次变换。单元素序列表示执行一维 FFT。默认值：(-2, -1)。
  自 2.0 版起已弃用：如果指定了s，则要转换的相应轴不能为None。
  
• norm（{“backward”，“ortho”，“forward”}，可选）
  

返回：

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

返回类型：

复数ndarray

jax.numpy.fft.fftfreq

原文：jax.readthedocs.io/en/latest/_autosummary/jax.numpy.fft.fftfreq.html

jax.numpy.fft.fftfreq(n, d=1.0, *, dtype=None)

返回离散傅立叶变换的采样频率。

LAX 后端实现的numpy.fft.fftfreq()。

以下是原始文档字符串。

返回的浮点数数组 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（int）– 窗口长度。
  
• d（标量，可选）– 采样间距（采样率的倒数）。默认为 1。
  
• dtype（可选）– 返回频率的数据类型。如果未指定，将使用 JAX 的默认浮点数数据类型。
  

返回值：

f – 长度为 n 的包含采样频率的数组。

返回类型：

ndarray

jax.numpy.fft.fftn

原文：jax.readthedocs.io/en/latest/_autosummary/jax.numpy.fft.fftn.html

jax.numpy.fft.fftn(a, s=None, axes=None, norm=None)

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

numpy.fft.fftn() 的 LAX 后端实现。

原始文档字符串如下。

该函数通过快速傅里叶变换（FFT）在 M 维数组中的任意数量的轴上计算 N 维离散傅里叶变换。

参数：

• a（array_like） – 输入数组，可以是复数。
  
• s（整数序列，可选） –
  输出的各个转换轴的形状（s[0] 指代轴 0，s[1] 指代轴 1，等等）。这对应于 fft(x, n) 中的 n。沿任何轴，如果给定的形状比输入的小，则输入会被裁剪。如果形状比输入大，则输入将用零填充。
  在版本 2.0 中更改：如果是 -1，则使用整个输入（无填充/修剪）。
  如果未给出 s，则沿 axes 指定的轴使用输入的形状。
  从版本 2.0 开始弃用：如果 s 不是 None，则轴也不能是 None。
  从版本 2.0 开始弃用：s 必须仅包含 int 值，而不能是 None 值。当前 None 值意味着在相应的 1-D 变换中使用默认值 n，但此行为已弃用。
  
• axes（整数序列，可选） –
  要计算 FFT 的轴。如果未给出，则使用最后 len(s) 个轴，或者如果 s 也未指定，则使用所有轴。在 axes 中重复的索引意味着该轴上的变换执行多次。
  从版本 2.0 开始弃用：如果指定了 s，则必须显式指定要转换的对应轴。
  
• norm（{“backward”，“ortho”，“forward”}，可选）
  

返回：

out – 被截断或零填充的输入，在由 axes 指示的轴上进行转换，或者根据上述参数部分中的 s 和 a 的组合。

返回类型：

复数 ndarray

jax.numpy.fft.fftshift

原文：jax.readthedocs.io/en/latest/_autosummary/jax.numpy.fft.fftshift.html

jax.numpy.fft.fftshift(x, axes=None)

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

LAX 后端实现的 numpy.fft.fftshift()。

以下是原始文档字符串。

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

参数：

• x（array_like） – 输入数组。
  
• axes（int 或 形状元组，可选） – 要进行移位的轴。默认为 None，即移动所有轴。
  

返回值：

y – 移位后的数组。

返回类型：

ndarray

jax.numpy.fft.hfft

原文：jax.readthedocs.io/en/latest/_autosummary/jax.numpy.fft.hfft.html

jax.numpy.fft.hfft(a, n=None, axis=-1, norm=None)

计算具有 Hermitian 对称性（即实数

numpy.fft.hfft()的 LAX 后端实现。

下面是原始文档字符串。

谱。

参数：

• a（array_like） – 输入数组。
  
• n（int，可选） – 输出的转换轴的长度。对于 n 个输出点，需要n//2 + 1个输入点。如果输入比这个长，则裁剪。如果输入比这个短，则用零填充。如果未提供 n，则取为2*(m-1)，其中 m 是由轴指定的输入的长度。
  
• axis（int，可选） – 计算 FFT 的轴。如果未指定，则使用最后一个轴。
  
• norm（{“backward”**, “ortho”**, *“forward”}**，可选）
  

返回：

out – 被截断或用零填充的输入，在由 axis 指示的轴上变换，如果未指定 axis，则在最后一个轴上变换。转换轴的长度为 n，如果未提供 n，则为2*m - 2，其中 m 是输入的转换轴的长度。为了得到奇数个输出点，必须指定 n，例如在典型情况下为2*m - 1，

返回类型：

ndarray

jax.numpy.fft.ifft

原文：jax.readthedocs.io/en/latest/_autosummary/jax.numpy.fft.ifft.html

jax.numpy.fft.ifft(a, n=None, axis=-1, norm=None)

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

numpy.fft.ifft() 的 LAX 后端实现。

下面是原始文档字符串。

此函数计算由 fft 计算的一维 n 点离散傅里叶变换的逆变换。换句话说，ifft(fft(a)) == a，在数值精度范围内成立。有关算法和定义的一般描述，请参阅 numpy.fft。

输入应按 fft 返回的方式排序，即，

• a[0] 应包含零频率项，
  
• a[1:n//2] 应包含正频率项，
  
• a[n//2 + 1:] 应包含负频率项，按最负频率开始的递增顺序排列。
  

对于偶数个输入点，A[n//2] 表示正和负奈奎斯特频率值的总和，因为这两者被混合在一起。有关详细信息，请参阅 numpy.fft。

Parameters:

• a (array_like) – 输入数组，可以是复数。
  
• n (int, 可选) – 输出的转换轴的长度。如果 n 小于输入的长度，则对输入进行裁剪。如果大于输入，则用零填充。如果未给出 n，则使用由 axis 指定的轴的输入长度。有关填充问题的注释，请参阅注释。
  
• axis (int, 可选) – 计算逆离散傅里叶变换的轴。如果未给出，则使用最后一个轴。
  
• norm ({“backward”**, “ortho”**, “forward”}**, 可选)
  

Returns:

out – 沿由 axis 指定的轴变换后的截断或零填充输入，或者如果未指定 axis，则为最后一个轴。

Return type:

复数 ndarray

jax.numpy.fft.ifft2

原文：jax.readthedocs.io/en/latest/_autosummary/jax.numpy.fft.ifft2.html

jax.numpy.fft.ifft2(a, s=None, axes=(-2, -1), norm=None)

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

LAX 后端实现的 numpy.fft.ifft2()。

下面是原始的文档字符串。

此函数通过快速傅里叶变换（FFT）在 M 维数组中的任意数量的轴上计算二维离散傅里叶逆变换。换句话说，ifft2(fft2(a)) == a，在数值精度内成立。默认情况下，计算逆变换是在输入数组的最后两个轴上进行的。

输入的顺序与 fft2 返回的顺序相同，即应该在两个轴的低阶角落中有零频率项，这两个轴的第一半中有正频率项，中间有奈奎斯特频率项，并且两个轴的后半部分中有负频率项，按照递减负频率的顺序。

参数：

• a (类似数组) – 输入数组，可以是复数。
  
• s (整数序列, 可选) –
  输出的形状（每个轴的长度）(s[0] 对应轴 0，s[1] 对应轴 1，依此类推)。这对应于 ifft(x, n) 的 n。沿每个轴，如果给定形状比输入小，则对输入进行裁剪。如果形状更大，则用零填充输入。
  自版本 2.0 起已更改：如果为 -1，则使用整个输入（无填充/修剪）。
  如果未给出 s，则使用由 axes 指定的轴上的输入形状。有关 ifft 零填充问题的问题，请参见注释。
  自版本 2.0 起已废弃：若 s 不为 None，则 axes 也不能为 None。
  自版本 2.0 起已废弃：s 必须只包含 int 值，不能包含 None 值。目前 None 值意味着在对应的一维变换中使用默认值 n，但此行为已被弃用。
  
• axes (整数序列, 可选) –
  用于计算 FFT 的轴。如果未指定，则使用最后两个轴。在 axes 中重复的索引表示对该轴执行多次变换。一个元素的序列表示执行一维 FFT。默认值：(-2, -1)。
  自版本 2.0 起已废弃：若指定了 s，则要转换的相应轴不能为 None。
  
• norm ({“backward”, “ortho”, “forward”}, 可选)
  

返回：

out – 在由 axes 指示的轴上变换的截断或零填充输入，或如果未给出 axes，则在最后两个轴上变换。

返回类型：

复数 ndarray

jax.numpy.fft.ifftn

jax.readthedocs.io/en/latest/_autosummary/jax.numpy.fft.ifftn.html

jax.numpy.fft.ifftn(a, s=None, axes=None, norm=None)

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

[numpy.fft.ifftn()的 LAX 后端实现](https://numpy.org/doc/stable/reference/generated/numpy.fft.ifftn.html#numpy.fft.ifftn （“在 NumPy v2.0 中”）)。

以下是原始文档字符串。

该函数通过快速傅里叶变换（FFT）在 M 维数组中的任意数量的轴上，计算 N 维福里叶变换的逆。换句话说，ifftn(fftn(a)) == a在数值精度内成立。有关使用的定义和约定的描述，请参见 numpy.fft。

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

参数：

• a (array_like) – 输入数组，可以是复数。
  
• s (整数的序列，可选) –
  输出的形状（每个转换轴的长度）(s[0]指轴 0，s[1]指轴 1，以此类推）。这对应于ifft(x, n)的n。沿任何轴，如果给定的形状小于输入的形状，则会对输入进行裁剪。如果大于输入，则用零填充输入。
  在版本 2.0 中更改：如果为-1，则使用整个输入（无填充/修剪）。
  如果未给出s，则使用由 axes 指定的轴的输入形状。参见关于 ifft 零填充问题的注释。
  从版本 2.0 开始已弃用：如果s不是None，则轴也不能是None。
  从版本 2.0 开始已弃用：s必须只包含int，而不是None值。None值当前表示在相应的 1-D 变换中使用n的默认值，但此行为已弃用。
  
• axes (整数的序列，可选) –
  计算逆离散傅里叶变换的轴。如果未给出，则使用最后的len(s)轴，或者如果也未指定s，则使用所有轴。轴中的重复索引意味着在该轴上执行多次逆变换。
  从版本 2.0 开始已弃用：如果指定了s，则必须明确指定要转换的相应轴。
  
• norm ({“backward”**, “ortho”**, “forward”}**, 可选)
  

返回：

out – 截断或用零填充的输入，沿着由 axes 指示的轴，或由上面参数节中解释的 s 或 a 的组合。

返回类型：

复数的 ndarray

jax.numpy.fft.ifftshift

原文：jax.readthedocs.io/en/latest/_autosummary/jax.numpy.fft.ifftshift.html

jax.numpy.fft.ifftshift(x, axes=None)

fftshift 的反操作。对于偶数长度的 x，它们是相同的。

LAX 后端实现的 numpy.fft.ifftshift()。

以下是原始文档字符串。

函数对于奇数长度的 x 会有一个样本的差异。

参数：

• x (array_like) – 输入数组。
  
• axes (int 或 形状元组*,* 可选) – 用于计算的轴。默认为 None，即对所有轴进行移位。
  

返回值：

y – 移位后的数组。

返回类型：

ndarray

jax.numpy.fft.ihfft

原文：jax.readthedocs.io/en/latest/_autosummary/jax.numpy.fft.ihfft.html

jax.numpy.fft.ihfft(a, n=None, axis=-1, norm=None)

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

LAX 后端实现的numpy.fft.ihfft()。

以下是原始文档字符串。

参数：

• a (array_like) – 输入数组。
  
• n (int, optional) – 逆 FFT 的长度，即用于输入的变换轴上的点数。如果 n 小于输入的长度，则输入被截断。如果大于输入，则用零填充。如果未给出 n，则使用由轴指定的输入的长度。
  
• axis (int, optional) – 计算逆 FFT 的轴。如果未给出，则使用最后一个轴。
  
• norm ({“backward”**, “ortho”**, “forward”}**, optional)
  

返回：

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

返回类型：

复数 ndarray

jax.numpy.fft.irfft

原文：jax.readthedocs.io/en/latest/_autosummary/jax.numpy.fft.irfft.html

jax.numpy.fft.irfft(a, n=None, axis=-1, norm=None)

计算 rfft 的逆操作。

numpy.fft.irfft() 的 LAX 后端实现。

以下为原始文档字符串。

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

输入应该是由 rfft 返回的形式，即实部的零频率项，后跟复数正频率项，按频率递增的顺序排列。由于实输入的离散傅立叶变换是共轭对称的，负频率项被视为对应正频率项的复共轭。

参数：

• a (array_like) – 输入数组。
  
• n (int, optional) – 输出的转换轴的长度。对于 n 个输出点，需要 n//2+1 个输入点。如果输入长于此，它将被截断。如果输入短于此，则用零填充。如果未给出 n，则取 2*(m-1)，其中 m 是由轴指定的输入的长度。
  
• axis (int, optional) – 计算逆 FFT 的轴。如果未给出，则使用最后一个轴。
  
• norm ({“backward”**, “ortho”**, “forward”}**, optional)
  

返回：

out – 被截断或零填充的输入，沿着指定的轴变换，如果未指定轴，则沿最后一个轴。转换后的轴的长度为 n，或者如果未给出 n，则为 2*(m-1)，其中 m 是输入的转换轴的长度。要获得奇数个输出点，必须指定 n。

返回类型：

ndarray

jax.numpy.fft.irfft2

原文：jax.readthedocs.io/en/latest/_autosummary/jax.numpy.fft.irfft2.html

jax.numpy.fft.irfft2(a, s=None, axes=(-2, -1), norm=None)

计算 rfft2 的逆。

numpy.fft.irfft2() 的 LAX-backend 实现。

以下为原始文档注释。

参数：

• a (array_like) – 输入数组
  
• s (ints 序列，可选) –
  逆 FFT 输出的形状。
  自 2.0 版本更改：如果为 -1，则使用整个输入（无填充/修剪）。
  自 2.0 版本弃用：如果 s 不为 None，则轴也不能为 None。
  自 2.0 版本弃用：s 必须仅包含 int 值，而不是 None 值。当前的 None 值意味着在相应的 1-D 变换中使用 n 的默认值，但此行为已弃用。
  
• axes (ints 序列，可选) –
  要计算逆 fft 的轴。默认：(-2, -1)，即最后两个轴。
  自 2.0 版本弃用：如果指定了 s，则要转换的相应轴不能为 None。
  
• norm ({“backward”**, “ortho”**, “forward”}**, 可选)
  

返回：

out – 逆实 2-D FFT 的结果。

返回类型：

ndarray

jax.numpy.fft.irfftn

原文：jax.readthedocs.io/en/latest/_autosummary/jax.numpy.fft.irfftn.html

jax.numpy.fft.irfftn(a, s=None, axes=None, norm=None)

计算 rfftn 的逆。

numpy.fft.irfftn()的 LAX 后端实现.

以下是原始文档字符串。

此函数通过快速傅里叶变换（FFT）计算 N 维实输入的逆离散傅里叶变换，涵盖 M 维数组中的任意数量轴。换句话说，irfftn(rfftn(a), a.shape)在数值精度范围内等于a。（a.shape对于 irfft 是必要的，就像对于 irfft 一样，出于同样的原因。）

输入应按与由 rfftn 返回的相同方式排序，即对于最终变换轴的 irfft，以及对于所有其他轴的 ifftn。

参数：

• a（类似数组） – 输入数组。
  
• s（整数序列，可选的） –
  输出的形状（每个转换轴的长度）（s[0]指轴 0，s[1]指轴 1 等）。s也是沿此轴使用的输入点数，除了最后一个轴，输入的点数为s[-1]//2+1。沿任何轴，如果s指示的形状比输入小，则输入被裁剪。如果更大，则用零填充输入。
  自版本 2.0 更改：如果为-1，则使用整个输入（无填充/修剪）。
  如果未给出s，则沿着由axes指定的轴使用输入的形状。除了最后一个轴被视为2*(m-1)，其中m是沿该轴的输入长度。
  自版本 2.0 起不推荐使用：如果s不为None，则axes也不得为None。
  自版本 2.0 起不推荐使用：s必须只包含整数，而不能包含None值。目前None值意味着在相应的 1-D 变换中使用默认值n，但此行为已弃用。
  
• axes（整数序列，可选的） –
  要计算逆 FFT 的轴。如果未给出，则使用最后的len(s)个轴，或者如果也未指定s，则使用所有轴。在axes中重复的索引意味着在该轴上执行多次逆变换。
  自版本 2.0 起不推荐使用：如果指定了s，则必须显式指定要转换的相应轴。
  
• norm（{“backward”，* “ortho”，* “forward”}，可选的）
  

返回：

out – 经过轴指示的变换，截断或填充零的输入，或者通过参数部分上述的 s 或 a 的组合进行变换。每个转换后轴的长度由相应的 s 的元素给出，或者如果未给出 s，则在除最后一个轴外的每个轴上都是输入的长度。当未给出 s 时，最终变换轴上的输出长度为 2*(m-1)，其中 m 是输入的最终变换轴的长度。要在最终轴上得到奇数个输出点，必须指定 s。

Return type:

ndarray

jax.numpy.fft.rfft

原文：jax.readthedocs.io/en/latest/_autosummary/jax.numpy.fft.rfft.html

jax.numpy.fft.rfft(a, n=None, axis=-1, norm=None)

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

numpy.fft.rfft()的 LAX 后端实现。

下面是原始文档字符串。

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

Parameters:

• a (array_like) – 输入数组
  
• n (int, 可选) – 输入中变换轴上要使用的点数。如果 n 小于输入的长度，则截取输入。如果 n 大于输入长度，则用零填充输入。如果未给出 n，则使用由 axis 指定的轴上的输入长度。
  
• axis (int, 可选) – 执行 FFT 的轴。如果未给出，则使用最后一个轴。
  
• norm ({“backward”**, “ortho”**, “forward”}**, 可选)
  

Returns:

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

Return type:

复数的 ndarray

jax.numpy.fft.rfft2

原文：jax.readthedocs.io/en/latest/_autosummary/jax.numpy.fft.rfft2.html

jax.numpy.fft.rfft2(a, s=None, axes=(-2, -1), norm=None)

计算实数组的二维 FFT。

numpy.fft.rfft2() 的 LAX 后端实现。

下面是原始文档字符串。

参数：

• a（数组） – 输入数组，被视为实数。
  
• s（整数序列，可选） –
  FFT 的形状。
  2.0 版本中更改：如果是 -1，则使用整个输入（无填充/修剪）。
  自 2.0 版本起弃用：如果 s 不是 None，则轴也不能是 None。
  自 2.0 版本起弃用：s 必须仅包含 int 值，而非 None 值。目前 None 值意味着在相应的一维变换中使用 n 的默认值，但此行为已弃用。
  
• axes（整数序列，可选） –
  要计算 FFT 的轴。默认值：(-2, -1)。
  自 2.0 版本起弃用：如果指定了 s，则要转换的相应轴不能为 None。
  
• norm（{“backward”**, “ortho”**, “forward”}，可选）
  

返回：

out – 实数 2-D FFT 的结果。

返回类型：

ndarray

jax.numpy.fft.rfftfreq

原文：jax.readthedocs.io/en/latest/_autosummary/jax.numpy.fft.rfftfreq.html

jax.numpy.fft.rfftfreq(n, d=1.0, *, dtype=None)

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

numpy.fft.rfftfreq() 的 LAX 后端实现。

以下是原始文档字符串。

（用于 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），将奈奎斯特频率分量视为正值。

参数:

• n (int – 窗口长度。
  
• d (标量, 可选) – 采样间隔（采样率的倒数）。默认为 1。
  
• dtype (可选) – 返回频率的数据类型。如果未指定，则使用 JAX 的默认浮点数数据类型。
  

返回:

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

返回类型:

ndarray

jax.numpy.fft.rfftn

原文：jax.readthedocs.io/en/latest/_autosummary/jax.numpy.fft.rfftn.html

jax.numpy.fft.rfftn(a, s=None, axes=None, norm=None)

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

numpy.fft.rfftn() 的 LAX 后端实现.

以下为原始文档字符串。

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

参数：

• a（类数组） - 输入数组，假定为实数。
  
• s（整数序列，可选） -
  要使用的输入的每个转换轴上的形状（长度）。(s[0] 是指轴 0，s[1] 是指轴 1，依此类推）。对于 rfft(x, n)，s 的最后一个元素对应于 n，而对于其余轴，它对应于 fft(x, n) 的 n。沿着任何轴，如果给定的形状小于输入的形状，则输入被裁剪。如果它更大，则输入被填充为零。
  版本 2.0 中的更改：如果为-1，则使用整个输入（无填充/修剪）。
  如果未给出 s，则使用由轴指定的输入的形状。
  自版本 2.0 起弃用：如果 s 不是 None，则轴也不能是 None。
  自版本 2.0 起弃用：s 必须仅包含整数，不能是 None 值。目前 None 值意味着对应 1-D 变换中 n 的默认值，但此行为已弃用。
  
• axes（整数序列，可选） -
  用于计算 FFT 的轴。如果未给出，则使用最后 len(s) 个轴，如果也未指定 s，则使用所有轴。
  自版本 2.0 起弃用：如果指定了 s，则必须显式指定要转换的对应轴。
  
• norm（{“backward”， “ortho”， “forward”}，可选）
  

返回：

out – 通过轴指示的轴或由参数部分上述 s 和 a 的组合截断或零填充的输入，最后一个转换轴的长度将为 s[-1]//2+1，而其余转换的轴将具有根据 s 或保持与输入不变的长度。

返回类型：

复数 ndarray