目录
  • 文档 >
  • 模块代码 >
  • torch >
  • torch.signal.windows.windows
快捷键

torch.signal.windows.windows 的源代码

# mypy: 允许未类型化定义
来自 collections.abc 导入 迭代器
来自 数学 导入 平方根
来自 打字 导入 可调用, 可选, 类型变量

导入 火炬
来自 火炬 导入 张量
来自 torch._torch_docs 导入 工厂通用参数, 合并字典, 解析参数


__all__ = [
    巴特莱特,
    黑曼,
    余弦,
    指数,
    高斯,
    "通用余弦",
    "通用汉明",
    "汉明",
    "汉宁",
    凯撒,
    纳塔尔,
]

_T = 类型变量("_T")

窗口通用参数 = 合并字典(
    parse_kwargs(
        ""
M (int): 窗口长度。
换句话说，返回窗口的点数。
sym (bool, 可选): 如果为 `False`，则返回适用于频谱分析的周期性窗口。
如果为 `True`，则返回适用于滤波器设计的对称窗口。默认：`True`。
""
    ),
    工厂通用参数,
    {
        "归一化": "窗口已归一化至 1（最大值为 1）。然而，如果 "
        ":attr:`M` 是偶数且 :attr:`sym` 为 `True`。",
    },
)


def _添加文档字符串(*参数: 字符串) -> 可调用[[_T] _T]：
    r"""为给定的装饰函数添加文档字符串。"""

"""特别适用于文档字符串需要字符串插值时，例如使用
str.format()。"""
REMARK：如果文档字符串不需要字符串插值，请勿使用此功能。
只需编写常规的文档字符串即可。

参数：
args (str)：
"源代码"

    def 装饰器(o: _T) -> _T:
        o.__doc__ = "".加入(参数)
        返回 o

    返回 装饰器


def _窗口功能检查(
    函数名: 字符串, M: int, 数据类型: 火炬.数据类型, 布局: 火炬.布局
) -> 无:
    r执行所有定义窗口的常见检查。
此函数应在计算任何窗口之前调用。

参数：
function_name (str): 窗口函数的名称。
M (int): 窗口长度。
dtype (:class:`torch.dtype`): 返回张量的期望数据类型。
layout (:class:`torch.layout`): 返回张量的期望布局。
"源代码"
    如果 M < 0:
        提升 ValueError(
            f"{函数名}需要非负窗口长度，但得到 M={M}"
        )
    如果 布局 是 not 火炬.strided:
        提升 ValueError(
            f"{函数名}仅针对步长张量实现，得到：{布局}"
        )
    如果 dtype not 在 [火炬.float32, 火炬.float64]：
        提升 ValueError(
            f"{函数名}预期数据类型为 float32 或 float64，得到：{数据类型}"
        )



[文档]@_add_docstr(
    r""
计算具有指数波形的窗口。
也称为泊松窗口。

指数窗口定义为如下：

.. 数学表达式
    w_n = \exp{\left(-\frac{|n - c|}{\tau}\right)}

其中 `c` 是窗口的 ``中心``。
    """,
    r""

{归一化}

参数：
    {M}

关键字参数:
窗口中心位置（浮点数，可选）：窗口中心将位于此处。
默认值：如果 sym 为 False，则为 `M / 2`，否则为 `(M - 1) / 2`。
tau（浮点数，可选）：衰减值。
tau 通常与百分比相关联，这意味着该值应该是
在区间（0，100]内变化。如果 tau 为 100，则认为是均匀窗口。
默认：1.0。
    {sym}
    {dtype}
{布局}
{设备}
{需要梯度}

示例::

>>> 生成大小为 10 的对称指数窗，衰减值为 1.0。
>>> # 中心位于 (M - 1) / 2，其中 M 为 10。
    >>> torch.signal.windows.exponential(10)
    tensor([0.0111, 0.0302, 0.0821, 0.2231, 0.6065, 0.6065, 0.2231, 0.0821, 0.0302, 0.0111])

>>> # 生成周期性指数窗口和衰减因子为 .5
    >>> torch.signal.windows.exponential(10, sym=False,tau=.5)
    tensor([4.5400e-05, 3.3546e-04, 2.4788e-03, 1.8316e-02, 1.3534e-01, 1.0000e+00, 1.3534e-01, 1.8316e-02, 2.4788e-03, 3.3546e-04])
    """.格式(
        **窗口常用参数
    ),
)
def 指数(
    M: int,
    *,
    中心: 可选[float] = 无,
    淘: 浮点数 = 1.0,
    sym: 布尔类型 = True,
    数据类型: 可选[火炬.数据类型] = 无,
    布局: 火炬.布局 = 火炬.strided,
    设备: 可选[火炬.设备] = 无,
    需要梯度: 布尔类型 = 错误,
) -> 张量:
    如果 dtype 是 无:
        dtype = 火炬.获取默认数据类型()

    窗口函数检查(指数, M, 数据类型, 布局)

    如果 塔乌 ≤ 0:
        提升 ValueError(f"τ必须为正，但得到："{淘}而不是。)

    如果 符号 和 中心 是 not 无:
        提升 ValueError(中心必须为 None 以实现对称窗口)

    如果 M == 0:
        返回 火炬.空的(
            (0,), 数据类型=数据类型, 布局=布局, 设备=设备, 需要梯度=requires_grad
        )

    如果 中心 是 无:
        中心 = (M 如果 not 符号 和 M > 1 否则 M - 1) / 2.0

    常量 = 1 / 塔乌

    k = 火炬.线性空间(
        开始=-中心 * 恒定,
        结束=(-中心 + (M - 1)) * 恒定,
        步骤=M,
        数据类型=数据类型,
        布局=布局,
        设备=设备,
        需要梯度=需要梯度,
    )

    返回 火炬.exp(-火炬.绝对值(k))




[文档]@_add_docstr(
    r""
计算一个简单的余弦波形窗口，遵循 SciPy 相同的实现。
此窗口也称为正弦窗口。

余弦窗口的定义如下：

.. 数学表达式
w_n = sin(π(n + 0.5)/M)

该公式与典型的余弦窗口公式不同，它在分子中引入了 0.5 项，
从而改变了样本位置。这种调整使得窗口的起始和结束值不为零。

""",
    r""

{归一化}

参数：
    {M}

关键字参数:
{符号}
{数据类型}
{布局}
{设备}
    {requires_grad}

示例::

>>> 生成对称余弦窗。
    >>> torch.signal.windows.cosine(10)
    tensor([0.1564, 0.4540, 0.7071, 0.8910, 0.9877, 0.9877, 0.8910, 0.7071, 0.4540, 0.1564])

>>> 生成周期余弦窗口。
    >>> torch.signal.windows.cosine(10, sym=False)
    tensor([0.1423, 0.4154, 0.6549, 0.8413, 0.9595, 1.0000, 0.9595, 0.8413, 0.6549, 0.4154])
""".格式(
        **窗口常用参数,
    ),
)
def 余弦(
    M: int,
    *,
    sym: 布尔类型 = True,
    数据类型: 可选[火炬.数据类型] = 无,
    布局: 火炬.布局 = 火炬.strided,
    设备: 可选[火炬.设备] = 无,
    需要梯度: 布尔类型 = 错误,
) -> 张量:
    如果 dtype 是 无:
        dtype = 火炬.获取默认数据类型()

    窗口函数检查(余弦, M, 数据类型, 布局)

    如果 M == 0:
        返回 火炬.空的(
            (0,), 数据类型=数据类型, 布局=布局, 设备=设备, 需要梯度=requires_grad
        )

    开始 = 0.5
    常量 = 火炬.圆周率 / (M + 1 如果 not 符号 和 M > 1 否则 M)

    k = 火炬.线性空间(
        开始=开始 * 恒定,
        结束=(开始 + (M - 1)) * 恒定,
        步骤=M,
        数据类型=数据类型,
        布局=布局,
        设备=设备,
        需要梯度=需要梯度,
    )

    返回 火炬.sin(k)




[文档]@_add_docstr(
    r""
计算具有高斯波形的窗口。

高斯窗口定义如下：

.. 数学表达式
    w_n = \exp{\left(-\left(\frac{n}{2\sigma}\right)^2\right)}
    """,
    r""

{规范化}

参数：
    {M}

关键字参数:
std (float, 可选): 高斯的标准差。它控制窗口的宽度或狭窄程度。
默认：1.0。
    {sym}
    {dtype}
    {layout}
{设备}
{需要梯度}

示例::

>>> 生成标准差为 1.0 的对称高斯窗口。
    >>> torch.signal.windows.gaussian(10)
    tensor([4.0065e-05, 2.1875e-03, 4.3937e-02, 3.2465e-01, 8.8250e-01, 8.8250e-01, 3.2465e-01, 4.3937e-02, 2.1875e-03, 4.0065e-05])

>>> 生成周期高斯窗口，标准差为 0.9。
    >>> torch.signal.windows.gaussian(10, sym=False,std=0.9)
    tensor([1.9858e-07, 5.1365e-05, 3.8659e-03, 8.4658e-02, 5.3941e-01, 1.0000e+00, 5.3941e-01, 8.4658e-02, 3.8659e-03, 5.1365e-05])
""".格式(
        **窗口通用参数,
    ),
)
def 高斯(
    M: int,
    *,
    标准的: 浮点数 = 1.0,
    sym: 布尔类型 = True,
    数据类型: 可选[火炬.数据类型] = 无,
    布局: 火炬.布局 = 火炬.strided,
    设备: 可选[火炬.设备] = 无,
    需要梯度: 布尔类型 = 错误,
) -> 张量:
    如果 dtype 是 无:
        dtype = 火炬.获取默认数据类型()

    _窗口函数检查(高斯, M, 数据类型, 布局)

    如果 标准差 ≤ 0:
        提升 ValueError(f标准差必须是正数，却得到了：{标准的}而不是。)

    如果 M == 0:
        返回 火炬.空的(
            (0,), 数据类型=数据类型, 布局=布局, 设备=设备, 需要梯度=requires_grad
        )

    开始 = -(M 如果 not 符号 和 M > 1 否则 M - 1) / 2.0

    常量 = 1 / (标准差 * 平方根(2))

    k = 火炬.线性空间(
        开始=开始 * 恒定,
        结束=(开始 + (M - 1)) * 恒定,
        步骤=M,
        数据类型=数据类型,
        布局=布局,
        设备=设备,
        需要梯度=需要梯度,
    )

    返回 火炬.exp(-(k**2))




[文档]@_add_docstr(
    r""
计算凯撒窗

凯撒窗口定义为如下：

.. 数学表达式
w_n = I_0(β√(1 - (n - N/2) / (N/2))^2) / I_0(β)

其中 ``I_0`` 是第一类零阶修正贝塞尔函数（参见 :func:`torch.special.i0`）
``N = M - 1 if sym else M``。
    """,
    r""

{规范化}

参数：
    {M}

关键字参数:
beta (浮点数，可选): 窗口形状参数。必须为非负数。默认：12.0
    {sym}
    {dtype}
    {layout}
{设备}
{需要梯度}

示例::

>>> 生成标准差为 1.0 的对称高斯窗口。
    >>> torch.signal.windows.kaiser(5)
    tensor([4.0065e-05, 2.1875e-03, 4.3937e-02, 3.2465e-01, 8.8250e-01, 8.8250e-01, 3.2465e-01, 4.3937e-02, 2.1875e-03, 4.0065e-05])
>>> 生成周期高斯窗口，标准差为 0.9。
    >>> torch.signal.windows.kaiser(5, sym=False,std=0.9)
    tensor([1.9858e-07, 5.1365e-05, 3.8659e-03, 8.4658e-02, 5.3941e-01, 1.0000e+00, 5.3941e-01, 8.4658e-02, 3.8659e-03, 5.1365e-05])
""".格式(
        **窗口通用参数,
    ),
)
def 凯撒(
    M: int,
    *,
    测试版: 浮点数 = 12.0,
    sym: 布尔类型 = True,
    数据类型: 可选[火炬.数据类型] = 无,
    布局: 火炬.布局 = 火炬.strided,
    设备: 可选[火炬.设备] = 无,
    需要梯度: 布尔类型 = 错误,
) -> 张量:
    如果 dtype 是 无:
        dtype = 火炬.获取默认数据类型()

    _窗口函数检查("凯撒", M, 数据类型, 布局)

    如果 测试版 < 0:
        提升 ValueError(f"beta 必须非负，得到："{测试版}而不是。)

    如果 M == 0:
        返回 火炬.空的(
            (0,), 数据类型=数据类型, 布局=布局, 设备=设备, 需要梯度=requires_grad
        )

    如果 M == 1:
        返回 火炬.一(
            (1,), 数据类型=数据类型, 布局=布局, 设备=设备, 需要梯度=requires_grad
        )

    避免 NaN，请将`beta`转换为适当的类型。
    测试版 = 火炬.张量(测试版, 数据类型=数据类型, 设备=设备)

    开始 = -测试版
    常量 = 2.0 * 测试版 / (M 如果 not 符号 否则 M - 1)
    末端 = 火炬.最小(测试版, 开始 + (M - 1) * 恒定)

    k = 火炬.线性空间(
        开始=开始,
        结束=结束,
        步骤=M,
        数据类型=数据类型,
        布局=布局,
        设备=设备,
        需要梯度=需要梯度,
    )

    返回 火炬.i0(火炬.平方根(测试版 * 测试版 - 火炬.pow(k, 2))) / 火炬.i0(测试版)




[文档]@_add_docstr(
    r""
计算汉明窗。

哈明窗定义为如下：

.. 数学表达式
w_n = α - β * cos(2πn / (M - 1))
    """,
    r""

{归一化}

参数：
    {M}

关键字参数:
    {sym}
alpha（浮点数，可选）：上述方程中的系数 :math:`α`。
beta（浮点数，可选）：上述方程中的系数 :math:`β`。
    {dtype}
    {layout}
    {device}
    {requires_grad}

示例::

>>> # 生成对称汉明窗口。
    >>> torch.signal.windows.hamming(10)
    tensor([0.0800, 0.1876, 0.4601, 0.7700, 0.9723, 0.9723, 0.7700, 0.4601, 0.1876, 0.0800])

>>> # 生成周期性汉明窗口。
    >>> torch.signal.windows.hamming(10, sym=False)
    tensor([0.0800, 0.1679, 0.3979, 0.6821, 0.9121, 1.0000, 0.9121, 0.6821, 0.3979, 0.1679])
""".格式(
        **窗口常用参数
    ),
)
def 汉明窗函数(
    M: int,
    *,
    sym: 布尔类型 = True,
    数据类型: 可选[火炬.数据类型] = 无,
    布局: 火炬.布局 = 火炬.strided,
    设备: 可选[火炬.设备] = 无,
    需要梯度: 布尔类型 = 错误,
) -> 张量:
    返回 一般汉明(
        M,
        sym=sym,
        数据类型=数据类型,
        布局=布局,
        设备=设备,
        需要梯度=需要梯度,
    )




[文档]@_add_docstr(
    r""
计算汉宁窗。

汉宁窗口定义为如下：

.. 数学表达式
w_n = 1/2 * [1 - cos(2πn/(M - 1))] =
sin^2(πn/(M - 1))
    """,
    r""

{归一化}

参数：
    {M}

关键字参数:
    {sym}
    {dtype}
    {layout}
{设备}
{需要梯度}

示例::

>>> 生成对称汉宁窗。
    >>> torch.signal.windows.hann(10)
    tensor([0.0000, 0.1170, 0.4132, 0.7500, 0.9698, 0.9698, 0.7500, 0.4132, 0.1170, 0.0000])

>>> 生成周期汉宁窗。
    >>> torch.signal.windows.hann(10, sym=False)
    tensor([0.0000, 0.0955, 0.3455, 0.6545, 0.9045, 1.0000, 0.9045, 0.6545, 0.3455, 0.0955])
""".格式(
        **窗口通用参数
    ),
)
def 汉恩(
    M: int,
    *,
    sym: 布尔类型 = True,
    数据类型: 可选[火炬.数据类型] = 无,
    布局: 火炬.布局 = 火炬.strided,
    设备: 可选[火炬.设备] = 无,
    需要梯度: 布尔类型 = 错误,
) -> 张量:
    返回 通用汉明(
        M,
        阿尔法=0.5,
        sym=sym,
        数据类型=数据类型,
        布局=布局,
        设备=设备,
        需要梯度=需要梯度,
    )




[文档]@_add_docstr(
    r""
计算布莱克曼窗口。

布莱克曼窗口定义为如下：

.. 数学表达式
    w_n = 0.42 - 0.5 \cos \left( \frac{2 \pi n}{M - 1} \right) + 0.08 \cos \left( \frac{4 \pi n}{M - 1} \right)
    """,
    r""

{规范化}

参数：
    {M}

关键字参数:
    {sym}
    {dtype}
{布局}
{设备}
{需要梯度}

示例::

>>> # 生成对称的布莱克曼窗。
    >>> torch.signal.windows.blackman(5)
    tensor([-1.4901e-08,  3.4000e-01,  1.0000e+00,  3.4000e-01, -1.4901e-08])

>>> 生成周期性的 Blackman 窗口。
    >>> torch.signal.windows.blackman(5, sym=False)
    tensor([-1.4901e-08,  2.0077e-01,  8.4923e-01,  8.4923e-01,  2.0077e-01])
""".格式(
        **窗口通用参数
    ),
)
def 黑曼窗函数(
    M: int,
    *,
    sym: 布尔类型 = True,
    数据类型: 可选[火炬.数据类型] = 无,
    布局: 火炬.布局 = 火炬.strided,
    设备: 可选[火炬.设备] = 无,
    需要梯度: 布尔类型 = 错误,
) -> 张量:
    如果 dtype 是 无:
        dtype = 火炬.获取默认数据类型()

    窗口函数检查(黑曼窗, M, 数据类型, 布局)

    返回 一般余弦(
        M,
        a=[0.42, 0.5, 0.08]
        sym=sym,
        数据类型=数据类型,
        布局=布局,
        设备=设备,
        需要梯度=需要梯度,
    )




[文档]@_add_docstr(
    r""
计算巴特利特窗。

巴特利特窗定义为如下：

.. 数学表达式
w_n = 1 - |2n/(M - 1) - 1| = {cases}
        \frac{2n}{M - 1} & \text{if } 0 \leq n \leq \frac{M - 1}{2} \\
        2 - \frac{2n}{M - 1} & \text{if } \frac{M - 1}{2} < n < M \\ \end{cases}
    """,
    r""

{标准化}

参数：
    {M}

关键字参数:
{符号}
{数据类型}
{布局}
{设备}
    {requires_grad}

示例::

>>> 生成对称的 Bartlett 窗。
    >>> torch.signal.windows.bartlett(10)
    tensor([0.0000, 0.2222, 0.4444, 0.6667, 0.8889, 0.8889, 0.6667, 0.4444, 0.2222, 0.0000])

>>> 生成周期性 Bartlett 窗。
    >>> torch.signal.windows.bartlett(10, sym=False)
    tensor([0.0000, 0.2000, 0.4000, 0.6000, 0.8000, 1.0000, 0.8000, 0.6000, 0.4000, 0.2000])
""".格式(
        **窗口通用参数
    ),
)
def 巴特莱特(
    M: int,
    *,
    sym: 布尔类型 = True,
    数据类型: 可选[火炬.数据类型] = 无,
    布局: 火炬.布局 = 火炬.strided,
    设备: 可选[火炬.设备] = 无,
    需要梯度: 布尔类型 = 错误,
) -> 张量:
    如果 dtype 是 无:
        dtype = 火炬.获取默认数据类型()

    窗口函数检查(巴特莱特, M, 数据类型, 布局)

    如果 M == 0:
        返回 火炬.空的(
            (0,), 数据类型=数据类型, 布局=布局, 设备=设备, 需要梯度=requires_grad
        )

    如果 M == 1:
        返回 火炬.一(
            (1,), 数据类型=数据类型, 布局=布局, 设备=设备, 需要梯度=requires_grad
        )

    开始 = -1
    常量 = 2 / (M 如果 not 符号 否则 M - 1)

    k = 火炬.线性空间(
        开始=开始,
        结束=开始 + (M - 1) * 恒定,
        步骤=M,
        数据类型=数据类型,
        布局=布局,
        设备=设备,
        需要梯度=需要梯度,
    )

    返回 1 - 火炬.绝对值(k)




[文档]@_add_docstr(
    r""
计算通用余弦窗。

一般余弦窗定义为如下：

.. 数学表达式
    w_n = \sum^{M-1}_{i=0} (-1)^i a_i \cos{ \left( \frac{2 \pi i n}{M - 1}\right)}
    """,
    r""

{规范化}

参数：
    {M}

关键字参数:
一个 (可迭代的)：与每个余弦函数关联的系数。
    {sym}
    {dtype}
    {layout}
    {device}
    {requires_grad}

示例::

>>> 生成具有 3 个系数的对称通用余弦窗。
    >>> torch.signal.windows.general_cosine(10, a=[0.46, 0.23, 0.31], sym=True)
    tensor([0.5400, 0.3376, 0.1288, 0.4200, 0.9136, 0.9136, 0.4200, 0.1288, 0.3376, 0.5400])

>>> 生成具有 2 个系数的周期性通用余弦窗。
    >>> torch.signal.windows.general_cosine(10, a=[0.5, 1 - 0.5], sym=False)
    tensor([0.0000, 0.0955, 0.3455, 0.6545, 0.9045, 1.0000, 0.9045, 0.6545, 0.3455, 0.0955])
""".格式(
        **窗口通用参数
    ),
)
def 通用余弦窗函数(
    M,
    *,
    a: 迭代器,
    sym: 布尔类型 = True,
    数据类型: 可选[火炬.数据类型] = 无,
    布局: 火炬.布局 = 火炬.strided,
    设备: 可选[火炬.设备] = 无,
    需要梯度: 布尔类型 = 错误,
) -> 张量:
    如果 dtype 是 无:
        dtype = 火炬.获取默认数据类型()

    窗口函数检查(一般余弦, M, 数据类型, 布局)

    如果 M == 0:
        返回 火炬.空的(
            (0,), 数据类型=数据类型, 布局=布局, 设备=设备, 需要梯度=requires_grad
        )

    如果 M == 1:
        返回 火炬.一(
            (1,), 数据类型=数据类型, 布局=布局, 设备=设备, 需要梯度=requires_grad
        )

    如果 not isinstance(a, 迭代器):
        提升 类型错误(系数必须是一个列表/元组)

    如果 not a:
        提升 ValueError(系数不能为空)

    常量 = 2 * 火炬.圆周率 / (M 如果 not 符号 否则 M - 1)

    k = 火炬.线性空间(
        开始=0,
        结束=(M - 1) * 恒定,
        步骤=M,
        数据类型=数据类型,
        布局=布局,
        设备=设备,
        需要梯度=需要梯度,
    )

    a_i = 火炬.张量(
        [-1) ** i * w 为 i, w 在 列举(a)]，
        设备=设备,
        数据类型=数据类型,
        需要梯度=需要梯度,
    )
    i = 火炬.arange(
        a_i.shape[0]
        数据类型=a_i.数据类型,
        设备=a_i.设备,
        需要梯度=a_i.需要梯度,
    )
    返回 (a_i.展平(-1) * 火炬.余弦(i.展平(-1) * k)).总和(0)




[文档]@_add_docstr(
    r""
计算通用汉明窗。

通用汉明窗的定义如下：

.. 数学表达式
w_n = α - (1 - α) cos{ \left( \frac{2πn}{M-1} \right)}
    """,
    r""

{归一化}

参数：
    {M}

关键字参数:
alpha (浮点数，可选): 窗口系数。默认：0.54。
{符号}
{数据类型}
{布局}
{设备}
    {requires_grad}

示例::

>>> 生成一个对称的汉明窗口，基于通用汉明窗口。
    >>> torch.signal.windows.general_hamming(10, sym=True)
    tensor([0.0800, 0.1876, 0.4601, 0.7700, 0.9723, 0.9723, 0.7700, 0.4601, 0.1876, 0.0800])

>>> 生成一个周期性的汉宁窗口，类似于通用汉明窗口。
    >>> torch.signal.windows.general_hamming(10, alpha=0.5, sym=False)
    tensor([0.0000, 0.0955, 0.3455, 0.6545, 0.9045, 1.0000, 0.9045, 0.6545, 0.3455, 0.0955])
""".格式(
        **窗口通用参数
    ),
)
def 一般汉明(
    M,
    *,
    阿尔法: 浮点数 = 0.54,
    sym: 布尔类型 = True,
    数据类型: 可选[火炬.数据类型] = 无,
    布局: 火炬.布局 = 火炬.strided,
    设备: 可选[火炬.设备] = 无,
    需要梯度: 布尔类型 = 错误,
) -> 张量:
    返回 一般余弦(
        M,
        a=[阿尔法, 1.0 - 阿尔法]
        sym=sym,
        数据类型=数据类型,
        布局=布局,
        设备=设备,
        需要梯度=需要梯度,
    )




[文档]@_add_docstr(
    r""
根据 Nuttall 计算最小 4 项 Blackman-Harris 窗

.. 数学表达式
    w_n = 1 - 0.36358 \cos{(z_n)} + 0.48917 \cos{(2z_n)} - 0.13659 \cos{(3z_n)} + 0.01064 \cos{(4z_n)}

其中 :math:`z_n = \frac{2 \pi n}{M}`.
    """,
    ""

{规范化}

参数：
    {M}

关键字参数:
    {sym}
    {dtype}
{布局}
{设备}
{需要梯度}

参考文献：

- A. Nuttall, "一些具有非常好的旁瓣行为的窗口,"
《IEEE 声学、语音与信号处理汇刊》，第 29 卷，第 1 期，第 84-91 页
1981 年 2 月。https://doi.org/10.1109/TASSP.1981.1163506

- Heinzel G. 等人，《通过离散傅里叶变换（DFT）进行频谱和频谱密度估计》
包括一个全面的窗口函数列表和一些新的平顶窗口"
2002 年 2 月 15 日 https://holometer.fnal.gov/GH_FFT.pdf

示例::

>>> 生成对称的 Nutall 窗口。
    >>> torch.signal.windows.general_hamming(5, sym=True)
    tensor([3.6280e-04, 2.2698e-01, 1.0000e+00, 2.2698e-01, 3.6280e-04])

>>> # 生成周期性 Nuttall 窗。
    >>> torch.signal.windows.general_hamming(5, sym=False)
    tensor([3.6280e-04, 1.1052e-01, 7.9826e-01, 7.9826e-01, 1.1052e-01])
""".格式(
        **window_common_args
    ),
)
def nuttall(
    M: int,
    *,
    sym: 布尔类型 = True,
    数据类型: 可选[火炬.数据类型] = 无,
    布局: 火炬.布局 = 火炬.strided,
    设备: 可选[火炬.设备] = 无,
    需要梯度: 布尔类型 = 错误,
) -> 张量:
    返回 general_cosine(
        M,
        a=[0.3635819, 0.4891775, 0.1365995, 0.0106411]
        sym=sym,
        数据类型=数据类型,
        布局=布局,
        设备=设备,
        需要梯度=需要梯度,
    )

© 版权所有 PyTorch 贡献者。

使用 Sphinx 构建，并使用 Read the Docs 提供的主题。

文档

查看 PyTorch 的全面开发者文档

查看文档

教程

深入了解初学者和高级开发者的教程

查看教程

资源

查找开发资源，获取您的疑问解答

查看资源

为了分析流量并优化您的体验，我们在本网站上使用 cookies。通过点击或导航，您同意允许我们使用 cookies。作为本网站的当前维护者，适用 Facebook 的 Cookies 政策。了解更多信息，包括关于可用控制的信息：Cookies 政策。