操作

操作#

数组 arange(双精度浮点数开始, 双精度停止, 双精度步骤, 数据类型数据类型, 流或设备 s = {})#: 一个从start（可选）开始，到stop结束，步长为step（可选）的一维数字数组。

数组 arange(双精度浮点数开始, 双精度浮点数停止, 双精度浮点数步骤, 流或设备 s = {})#

数组 arange(双精度开始, 双精度停止, 数据类型数据类型, 流或设备 s = {})#

数组 arange(双精度开始, 双精度停止, 流或设备 s = {})#

数组 arange(双精度停止, 数据类型数据类型, 流或设备 s = {})#

数组 arange(双精度停止, 流或设备 s = {})#

数组 arange(整数开始, 整数停止, 整数步骤, 流或设备 s = {})#

数组 arange(整数开始, 整数停止, 流或设备 s = {})#

数组 arange(整型停止, 流或设备 s = {})#

数组 linspace(双精度开始, 双精度停止, 整型数字 = 50, 数据类型数据类型 = 浮点32, 流或设备 s = {})#: 一个一维数组，包含在范围 [start, stop] 内均匀分布的 num 个数字

数组转化数据类型(数组 a, 数据类型数据类型, 流或设备 s = {})#: 将数组转换为给定的数据类型。

数组 as_strided(数组 a, 形状形状, 步幅步幅, size_t 偏移量, 流或设备 s = {})#: 创建一个具有给定形状和步幅的数组视图。

数组复制(数组 a, 流或设备 s = {})#: 复制另一个数组。

数组完整(形状形状, 数组值, 数据类型数据类型, 流或设备 s = {})#: 用给定的值填充给定形状的数组。

数组完整(形状形状, 数组值, 流或设备 s = {})#

模板<类型名称 T> 数组完整(形状形状, T 值, 数据类型数据类型, 流或设备 s = {})#

模板<类型名称 T> 数组完整(形状形状, T 值, 流或设备 s = {})#

数组零(常量形状 &形状, 数据类型数据类型, 流或设备 s = {})#: 用零填充给定形状的数组。

联行数组零(常量形状 &形状, 流或设备 s = {})#

数组与零相同的数组(常量数组 &a, 流或设备 s = {})#

数组一(常量形状 &形状, 数据类型数据类型, 流或设备 s = {})#: 用1填充给定形状的数组。

在线数组一(常量形状 &形状, 流或设备 s = {})#

数组与给定的输入相同形状的全1数组(常量数组 &a, 流或设备 s = {})#

数组眼睛(整型 n, 整型米, 整型 k, 数据类型数据类型, 流或设备 s = {})#: 用指定的对角线k上的1填充给定形状（n,m）的数组，其余位置填充0。

联行数组眼睛(整型 n, 数据类型数据类型, 流或设备 s = {})#

联行数组眼睛(整型 n, 整型米, 流或设备 s = {})#

联行数组眼睛(整型 n, 整型米, 整型 k, 流或设备 s = {})#

联行数组眼睛(整型 n, 流或设备 s = {})#

数组身份(整型 n, 数据类型数据类型, 流或设备 s = {})#: 创建一个形状为 (n,n) 的零矩阵，并在主对角线上放置一。

联行数组身份(整型 n, 流或设备 s = {})#

数组三角形(整型 n, 整型米, 整型 k, 数据类型类型, 流或设备 s = {})#

联行数组三角形(整型 n, 数据类型类型, 流或设备 s = {})#

数组 tril(数组 x, 整型 k = 0, 流或设备 s = {})#

数组上三角矩阵(数组 x, 整型 k = 0, 流或设备 s = {})#

数组重塑(常量数组 &a, 形状形状, 流或设备 s = {})#: 将数组重塑为给定的形状。

数组反扁平化(常量数组 &a, 整型轴, 形状形状, 流或设备 s = {})#: 将轴展开为给定的形状。

数组扁平化(常量数组 &a, 整型开始轴, 整型结束轴 = -1, 流或设备 s = {})#: 将维度在范围 [start_axis, end_axis] 内展平。

数组扁平化(常量数组 &a, 流或设备 s = {})#: 将数组展平为一维。

数组哈达玛变换(常量数组 &a, 标准::可选的<浮点数> 缩放 = 标准::nullopt, 流或设备 s = {})#: 将数组乘以相应大小的Hadamard矩阵。

数组压缩(常量数组 &a, 常量标准::向量<整型> &坐标轴, 流或设备 s = {})#: 移除给定轴上的单一维度。

数组压缩(常量数组 &a, 整型轴, 流或设备 s = {})#: 移除给定轴上的单一维度。

数组挤压(常量数组 &a, 流或设备 s = {})#: 移除所有单一维度。

数组扩展维度(常量数组 &a, 常量标准::向量<整型> &坐标轴, 流或设备 s = {})#: 在给定的轴上添加一个单例维度。

数组扩展维度(常量数组 &a, 整型轴, 流或设备 s = {})#: 在给定轴上添加一个单例维度。

数组切片(常量数组 &a, 形状开始, 形状停止, 形状步幅, 流或设备 s = {})#: 切片一个数组。

在线数组切片(常量数组 &a, 标准::初始化器列表<整型> 开始, 形状停止, 形状步幅, 流或设备 s = {})#

数组切片(常量数组 &a, 形状开始, 形状停止, 流或设备 s = {})#: 在每个维度上以步幅1切片数组。

数组切片(常量数组 &a, 常量数组 &开始, 标准::向量<整型> 坐标轴, 形状切片大小, 流或设备 s = {})#: 使用动态起始索引对数组进行切片。

数组切片更新(常量数组 &源, 常量数组 &更新, 形状开始, 形状停止, 形状步幅, 流或设备 s = {})#: 从源数组中更新一个切片。

数组切片更新(常量数组 &源, 常量数组 &更新, 形状开始, 形状停止, 流或设备 s = {})#: 从源数组中更新一个切片，每个维度的步幅为1。

数组切片更新(常量数组 &源, 常量数组 &更新, 常量数组 &开始, 标准::向量<整型> 坐标轴, 流或设备 s = {})#: 使用动态起始索引更新源数组的一个切片。

标准::向量<数组> 拆分(常量数组 &a, 整型切分数, 整型轴, 流或设备 s = {})#: 沿着给定轴将数组分割成子数组。

标准::向量<数组> 分割(常量数组 &a, 整型 num_splits, 流或设备 s = {})#

标准::向量<数组> 分割(常量数组 &a, 常量形状 &索引, 整型轴, 流或设备 s = {})#

标准::向量<数组> 拆分(常量数组 &a, 常量形状 &索引, 流或设备 s = {})#

标准::向量<数组> 网格生成(常量标准::向量<数组> &数组, 布尔型稀疏 = 假, 常量标准::字符串 &索引 = “xy”, 流或设备 s = {})#: 从坐标向量生成坐标数组的向量。

数组剪辑(常量数组 &a, 常量标准::可选的<数组> &最小值 = 标准::nullopt, 常量标准::可选的<数组> &a_max = 标准::nullopt, 流或设备 s = {})#: 裁剪（限制）数组中的值。

数组连接(标准::向量<数组> 数组, 整型轴, 流或设备 s = {})#: 沿给定轴连接数组。

数组连接(标准::向量<数组> 数组, 流或设备 s = {})#

数组堆栈(常量标准::向量<数组> &数组, 整型轴, 流或设备 s = {})#: 沿着新轴堆叠数组。

数组堆栈(常量标准::向量<数组> &数组, 流或设备 s = {})#

数组重复(常量数组 &arr, 整型重复, 整型轴, 流或设备 s = {})#: 沿轴重复数组。

数组重复(常量数组 &arr, 整型重复, 流或设备 s = {})#

数组标题(常量数组 &arr, 标准::向量<整型> 重复次数, 流或设备 s = {})#

数组转置(常量数组 &a, 标准::向量<整型> 坐标轴, 流或设备 s = {})#: 根据给定的轴重新排列维度。

在线数组转置(常量数组 &a, 标准::初始化器列表<整型> 坐标轴, 流或设备 s = {})#

数组交换轴(常量数组 &a, 整型轴1, 整型轴2, 流或设备 s = {})#: 交换数组的两个轴。

数组移动轴(常量数组 &a, 整型源, 整型目的地, 流或设备 s = {})#: 移动数组的一个轴。

数组填充(常量数组 &a, 常量标准::向量<整型> &坐标轴, 常量形状 &低垫片大小, 常量形状 &高垫大小, 常量数组 &填充值 = 数组(0), 常量标准::字符串 &模式 = “常量”, 流或设备 s = {})#: 用常数值填充数组。

数组填充(常量数组 &a, 常量标准::向量<标准::对<整型, 整型>> &填充宽度, 常量数组 &填充值 = 数组(0), 常量标准::字符串 &模式 = “常量”, 流或设备 s = {})#: 在所有轴上用常数值填充数组。

数组填充(常量数组 &a, 常量标准::对<整型，整型> &填充宽度, 常量数组 &填充值 = 数组(0), 常量标准::字符串 &模式 = “常量”, 流或设备 s = {})#

数组填充(常量数组 &a, 整型填充宽度, 常量数组 &填充值 = 数组(0), 常量标准::字符串 &模式 = “常量”, 流或设备 s = {})#

数组转置(常量数组 &a, 流或设备 s = {})#: 以相反的顺序排列维度。

数组广播到(常量数组 &a, 常量形状 &形状, 流或设备 s = {})#: 将数组广播到给定的形状。

标准::向量<数组> 广播数组(常量标准::向量<数组> &输入, 流或设备 s = {})#: 将一个数组向量相互广播。

数组相等(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 返回布尔数组，其中每个元素为 (a == b)。

在线数组运算符==(常量数组 &a, 常量数组 &b)#

模板<类型名称 T> 数组运算符==(T a, 常量数组 &b)#

模板<类型名称 T> 数组操作符==(常量数组 &a, T b)#

数组不等于(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 返回布尔数组，其中每个元素为 (a != b)。

在线数组运算符!=(常量数组 &a, 常量数组 &b)#

模板<类型名称 T> 数组运算符!=(T a, 常量数组 &b)#

模板<类型名称 T> 数组操作符!=(常量数组 &a, T b)#

数组更大(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 返回一个布尔数组，其中每个元素表示 (a > b) 的结果。

在线数组运算符>(常量数组 &a, 常量数组 &b)#

模板<类型名称 T> 数组操作符>(T a, 常量数组 &b)#

模板<类型名称 T> 数组操作符>(常量数组 &a, T b)#

数组大于等于(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 返回一个布尔数组，其中每个元素表示 (a >= b) 的结果。

在线数组运算符>=(常量数组 &a, 常量数组 &b)#

模板<类型名称 T> 数组运算符>=(T a, 常量数组 &b)#

模板<类型名称 T> 数组操作符>=(常量数组 &a, T b)#

数组更少(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 返回一个布尔数组，其中每个元素表示 (a < b) 的结果。

在线数组操作符<(常量数组 &a, 常量数组 &b)#

模板<类型名称 T> 数组操作符<(T a, 常量数组 &b)#

模板<类型名称 T> 数组运算符<(常量数组 &a, T b)#

数组小于或等于(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 返回一个布尔数组，其中每个元素表示 (a <= b)。

在线数组操作符<=(常量数组 &a, 常量数组 &b)#

模板<类型名称 T> 数组运算符<=(T a, 常量数组 &b)#

模板<类型名称 T> 数组操作符<=(常量数组 &a, T b)#

数组数组相等(常量数组 &a, 常量数组 &b, 布尔型等于_nan, 流或设备 s = {})#: 如果两个数组具有相同的形状和元素，则为True。

在线数组数组相等(常量数组 &a, 常量数组 &b, 流或设备 s = {})#

数组是非数字(常量数组 &a, 流或设备 s = {})#

数组是无穷大(常量数组 &a, 流或设备 s = {})#

数组是有限的(常量数组 &a, 流或设备 s = {})#

数组是正无穷大(常量数组 &a, 流或设备 s = {})#

数组 isneginf(常量数组 &a, 流或设备 s = {})#

数组其中(常量数组 &条件, 常量数组 &x, 常量数组 &y, 流或设备 s = {})#: 根据条件从x或y中选择。

数组将nan转换为数字(常量数组 &a, 浮点数非数字 = 0.0f, 常量标准::可选的<浮点数> posinf = 标准::nullopt, 常量标准::可选的<浮点数> neginf = 标准::nullopt, 流或设备 s = {})#: 用有限数字替换NaN和无穷大。

数组所有(常量数组 &a, 布尔型保持维度, 流或设备 s = {})#: 如果数组中的所有元素都为真（或非零），则为真。

在线数组所有(常量数组 &a, 流或设备 s = {})#

数组全接近(常量数组 &a, 常量数组 &b, 双精度相对容忍度 = 1e-5, 双精度 atol = 1e-8, 布尔型等于_nan = 假, 流或设备 s = {})#: 如果两个数组在指定的容差范围内相等，则为True。

数组相似(常量数组 &a, 常量数组 &b, 双精度相对容忍度 = 1e-5, 双精度 atol = 1e-8, 布尔型等于_nan = 假, 流或设备 s = {})#: 返回一个布尔数组，其中两个数组在指定的容差范围内逐元素相等。

数组所有(常量数组 &a, 常量标准::向量<整型> &坐标轴, 布尔型保持维度 = 假, 流或设备 s = {})#

沿着给定的轴减少输入。

如果所有相应的输入都为真，则输出值为真。

数组所有(常量数组 &a, 整型轴, 布尔型保持维度 = 假, 流或设备 s = {})#

沿给定轴减少输入。

如果所有相应的输入都为真，则输出值为真。

数组任何(常量数组 &a, 布尔型保持维度, 流或设备 s = {})#: 如果数组中的任何元素为真（或非零），则为真。

在线数组任何(常量数组 &a, 流或设备 s = {})#

数组任何(常量数组 &a, 常量标准::向量<整型> &坐标轴, 布尔型保持维度 = 假, 流或设备 s = {})#

沿着给定的轴减少输入。

如果任何相应的输入为真，则输出值为真。

数组任何(常量数组 &a, 整型轴, 布尔型保持维度 = 假, 流或设备 s = {})#

沿着给定轴减少输入。

如果任何相应的输入为真，则输出值为真。

数组求和(常量数组 &a, 布尔型保持维度, 流或设备 s = {})#: 对数组的元素求和。

在线数组总和(常量数组 &a, 流或设备 s = {})#

数组总和(常量数组 &a, 常量标准::向量<整型> &坐标轴, 布尔型保持维度 = 假, 流或设备 s = {})#: 沿给定轴对数组的元素求和。

数组和(常量数组 &a, 整型轴, 布尔型保持维度 = 假, 流或设备 s = {})#: 沿给定轴对数组的元素求和。

数组平均值(常量数组 &a, 布尔型保持维度, 流或设备 s = {})#: 计算数组中元素的平均值。

在线数组均值(常量数组 &a, 流或设备 s = {})#

数组均值(常量数组 &a, 常量标准::向量<整型> &坐标轴, 布尔型保持维度 = 假, 流或设备 s = {})#: 计算数组元素沿给定轴的平均值。

数组均值(常量数组 &a, 整型轴, 布尔型保持维度 = 假, 流或设备 s = {})#: 计算数组元素沿给定轴的平均值。

数组变量(常量数组 &a, 布尔型保持维度, 整型自由度 = 0, 流或设备 s = {})#: 计算数组中元素的方差。

在线数组变量(常量数组 &a, 流或设备 s = {})#

数组变量(常量数组 &a, 常量标准::向量<整型> &坐标轴, 布尔型保持维度 = 假, 整型自由度 = 0, 流或设备 s = {})#: 计算数组中元素沿给定轴的方差。

数组变量(常量数组 &a, 整型轴, 布尔型保持维度 = 假, 整型自由度 = 0, 流或设备 s = {})#: 计算数组中元素沿给定轴的方差。

数组标准(常量数组 &a, 布尔型保持维度, 整型自由度 = 0, 流或设备 s = {})#: 计算数组中元素的标准差。

在线数组标准(常量数组 &a, 流或设备 s = {})#

数组标准(常量数组 &a, 常量标准::向量<整型> &坐标轴, 布尔型保持维度 = 假, 整型自由度 = 0, 流或设备 s = {})#: 计算数组中元素沿给定轴的标准差。

数组标准(常量数组 &a, 整型轴, 布尔型保持维度 = 假, 整型自由度 = 0, 流或设备 s = {})#: 计算数组元素沿给定轴的标准差。

数组 prod(常量数组 &a, 布尔型保持维度, 流或设备 s = {})#: 数组中所有元素的乘积。

在线数组产品(常量数组 &a, 流或设备 s = {})#

数组产品(常量数组 &a, 常量标准::向量<整型> &坐标轴, 布尔型保持维度 = 假, 流或设备 s = {})#: 沿给定轴计算数组元素的乘积。

数组产品(常量数组 &a, 整型轴, 布尔型保持维度 = 假, 流或设备 s = {})#: 沿给定轴计算数组元素的乘积。

数组最大值(常量数组 &a, 布尔型保持维度, 流或设备 s = {})#: 数组中所有元素的最大值。

在线数组最大值(常量数组 &a, 流或设备 s = {})#

数组最大值(常量数组 &a, 常量标准::向量<整型> &坐标轴, 布尔型保持维度 = 假, 流或设备 s = {})#: 数组元素沿给定轴的最大值。

数组最大值(常量数组 &a, 整型轴, 布尔型保持维度 = 假, 流或设备 s = {})#: 数组沿给定轴的元素的最大值。

数组最小值(常量数组 &a, 布尔型保持维度, 流或设备 s = {})#: 数组中所有元素的最小值。

在线数组最小值(常量数组 &a, 流或设备 s = {})#

数组最小值(常量数组 &a, 常量标准::向量<整型> &坐标轴, 布尔型保持维度 = 假, 流或设备 s = {})#: 数组沿给定轴的元素的最小值。

数组最小值(常量数组 &a, 整型轴, 布尔型保持维度 = 假, 流或设备 s = {})#: 沿给定轴数组元素的最小值。

数组最小值索引(常量数组 &a, 布尔型保持维度, 流或设备 s = {})#: 返回数组中最小值的索引。

在线数组最小值索引(常量数组 &a, 流或设备 s = {})#

数组最小值索引(常量数组 &a, 整型轴, 布尔型保持维度 = 假, 流或设备 s = {})#: 返回沿给定轴的最小值的索引。

数组最大值索引(常量数组 &a, 布尔型保持维度, 流或设备 s = {})#: 返回数组中最大值的索引。

在线数组 argmax(常量数组 &a, 流或设备 s = {})#

数组最大值索引(常量数组 &a, 整型轴, 布尔型保持维度 = 假, 流或设备 s = {})#: 返回沿给定轴的最大值的索引。

数组排序(常量数组 &a, 流或设备 s = {})#: 返回展平数组的排序副本。

数组排序(常量数组 &a, 整型轴, 流或设备 s = {})#: 返回沿给定轴排序后的数组副本。

数组排序索引(常量数组 &a, 流或设备 s = {})#: 返回对展平数组进行排序的索引。

数组排序索引(常量数组 &a, 整型轴, 流或设备 s = {})#: 返回沿给定轴对数组进行排序的索引。

数组分区(常量数组 &a, 整型第 k 个, 流或设备 s = {})#: 返回扁平化数组的分区副本，使得较小的第k个元素排在前面。

数组分区(常量数组 &a, 整型第 k 个, 整型轴, 流或设备 s = {})#: 返回数组沿给定轴的分区副本，使得较小的第k个元素排在前面。

数组 argpartition(常量数组 &a, 整型第 k 个, 流或设备 s = {})#: 返回将扁平化数组分区的索引，使得较小的第k个元素排在前面。

数组 argpartition(常量数组 &a, 整型第 k 个, 整型轴, 流或设备 s = {})#: 返回沿给定轴分区数组的索引，使得较小的第k个元素排在前面。

数组 topk(常量数组 &a, 整型 k, 流或设备 s = {})#: 返回展平数组中的前k个元素。

数组 topk(常量数组 &a, 整型 k, 整型轴, 流或设备 s = {})#: 返回数组沿给定轴的前k个元素。

数组对数和指数(常量数组 &a, 布尔型保持维度, 流或设备 s = {})#: 数组中所有元素的logsumexp。

在线数组对数和指数的和(常量数组 &a, 流或设备 s = {})#

数组对数和指数的总和(常量数组 &a, 常量标准::向量<整型> &坐标轴, 布尔型保持维度 = 假, 流或设备 s = {})#: 沿给定轴计算数组元素的logsumexp。

数组对数和指数求和(常量数组 &a, 整型轴, 布尔型保持维度 = 假, 流或设备 s = {})#: 沿给定轴计算数组元素的logsumexp。

数组绝对值(常量数组 &a, 流或设备 s = {})#: 数组中元素的绝对值。

数组负数(常量数组 &a, 流或设备 s = {})#: 对数组取反。

数组运算符-(常量数组 &a)#

数组签名(常量数组 &a, 流或设备 s = {})#: 数组中元素的符号。

数组逻辑非(常量数组 &a, 流或设备 s = {})#: 数组的逻辑非。

数组逻辑与(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 两个数组的逻辑与。

数组运算符&&(常量数组 &a, 常量数组 &b)#

数组逻辑或(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 两个数组的逻辑或。

数组操作符||(常量数组 &a, 常量数组 &b)#

数组倒数(常量数组 &a, 流或设备 s = {})#: 数组中元素的倒数（1/x）。

数组添加(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 添加两个数组。

数组运算符+(常量数组 &a, 常量数组 &b)#

模板<类型名称 T> 数组运算符+(T a, 常量数组 &b)#

模板<类型名称 T> 数组操作符+(常量数组 &a, T b)#

数组减去(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 减去两个数组。

数组运算符-(常量数组 &a, 常量数组 &b)#

模板<类型名称 T> 数组运算符-(T a, 常量数组 &b)#

模板<类型名称 T> 数组运算符-(常量数组 &a, T b)#

数组乘法(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 将两个数组相乘。

数组操作符*(常量数组 &a, 常量数组 &b)#

模板<类型名称 T> 数组运算符*(T a, 常量数组 &b)#

模板<类型名称 T> 数组运算符*(常量数组 &a, T b)#

数组除以(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 将两个数组相除。

数组操作符/(常量数组 &a, 常量数组 &b)#

数组操作符/(双精度 a, 常量数组 &b)#

数组运算符/(常量数组 &a, 双精度 b)#

标准::向量<数组> divmod(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 计算逐元素的商和余数。

数组向下除法(常量数组 &a, 常量数组 &b, 流或设备 s = {})#

计算整数除法。

相当于执行 floor(a / x)。

数组余数(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 计算逐元素的除法余数。

数组操作符%(常量数组 &a, 常量数组 &b)#

模板<类型名称 T> 数组操作符%(T a, 常量数组 &b)#

模板<类型名称 T> 数组运算符%(常量数组 &a, T b)#

数组最大值(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 两个数组之间的逐元素最大值。

数组最小值(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 两个数组之间的逐元素最小值。

数组向下取整(常量数组 &a, 流或设备 s = {})#: 对数组的元素进行向下取整。

数组向上取整(常量数组 &a, 流或设备 s = {})#: 对数组的元素进行向上取整。

数组平方(常量数组 &a, 流或设备 s = {})#: 对数组的元素进行平方运算。

数组指数(常量数组 &a, 流或设备 s = {})#: 数组元素的指数。

数组正弦(常量数组 &a, 流或设备 s = {})#: 数组中元素的正弦值。

数组余弦(常量数组 &a, 流或设备 s = {})#: 数组中元素的余弦值。

数组正切(常量数组 &a, 流或设备 s = {})#: 数组中元素的正切值。

数组反正弦(常量数组 &a, 流或设备 s = {})#: 数组中各元素的反正弦值。

数组反余弦(常量数组 &a, 流或设备 s = {})#: 数组中各元素的反余弦值。

数组反正切(常量数组 &a, 流或设备 s = {})#: 数组中元素的反正切值。

数组反正切2(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 两个数组比率的反正切。

数组双曲正弦(常量数组 &a, 流或设备 s = {})#: 数组中元素的双曲正弦值。

数组双曲余弦(常量数组 &a, 流或设备 s = {})#: 数组中元素的双曲余弦值。

数组双曲正切(常量数组 &a, 流或设备 s = {})#: 数组中元素的双曲正切值。

数组反双曲正弦函数(常量数组 &a, 流或设备 s = {})#: 数组中元素的反双曲正弦。

数组反双曲余弦(常量数组 &a, 流或设备 s = {})#: 数组中元素的反双曲余弦。

数组双曲正切反函数(常量数组 &a, 流或设备 s = {})#: 数组中元素的反双曲正切。

数组度数(常量数组 &a, 流或设备 s = {})#: 将数组中的元素从弧度转换为度。

数组弧度(常量数组 &a, 流或设备 s = {})#: 将数组的元素从度转换为弧度。

数组对数(常量数组 &a, 流或设备 s = {})#: 数组中元素的自然对数。

数组 log2(常量数组 &a, 流或设备 s = {})#: 数组中元素的以2为底的对数。

数组对数10(常量数组 &a, 流或设备 s = {})#: 数组中元素的以10为底的对数。

数组对数加一(常量数组 &a, 流或设备 s = {})#: 数组中元素加一后的自然对数：log(1 + a)。

数组对数加法扩展(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 数组中一个元素的Log-add-exp：log(exp(a) + exp(b))。

数组 sigmoid(常量数组 &a, 流或设备 s = {})#: 数组的逐元素逻辑Sigmoid函数：1 / (1 + exp(-x)。

数组误差函数(常量数组 &a, 流或设备 s = {})#: 计算数组中元素的误差函数。

数组 erfinv(常量数组 &a, 流或设备 s = {})#: 计算数组中元素的逆误差函数。

数组 expm1(常量数组 &a, 流或设备 s = {})#: 计算数组中元素的expm1函数。

数组停止梯度(常量数组 &a, 流或设备 s = {})#: 停止梯度的流动。

数组四舍五入(常量数组 &a, 整型小数位数, 流或设备 s = {})#: 四舍五入一个浮点数。

在线数组四舍五入(常量数组 &a, 流或设备 s = {})#

数组矩阵乘法(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 矩阵-矩阵乘法。

数组收集(常量数组 &a, 常量标准::向量<数组> &索引, 常量标准::向量<整型> &坐标轴, 常量形状 &切片大小, 流或设备 s = {})#: 根据索引和切片收集数组条目。

在线数组收集(常量数组 &a, 常量数组 &索引, 整型轴, 常量形状 &切片大小, 流或设备 s = {})#

数组 kron(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 计算两个数组的克罗内克积。

数组获取(常量数组 &a, 常量数组 &索引, 整型轴, 流或设备 s = {})#: 在指定轴的给定索引处获取数组切片。

数组采取(常量数组 &a, 整型索引, 整型轴, 流或设备 s = {})#

数组获取(常量数组 &a, 常量数组 &索引, 流或设备 s = {})#: 将数组视为扁平化，获取给定索引处的数组条目。

数组获取(常量数组 &a, 整型索引, 流或设备 s = {})#

数组沿轴提取(常量数组 &a, 常量数组 &索引, 整型轴, 流或设备 s = {})#: 沿着轴获取给定索引的数组条目。

数组在轴上放置(常量数组 &a, 常量数组 &索引, 常量数组 &值, 整型轴, 流或设备 s = {})#: 将值沿轴放入给定索引的数组中。

数组散点添加轴(常量数组 &a, 常量数组 &索引, 常量数组 &值, 整型轴, 流或设备 s = {})#: 将值沿轴添加到给定索引处的数组中。

数组散点图(常量数组 &a, 常量标准::向量<数组> &索引, 常量数组 &更新, 常量标准::向量<整型> &坐标轴, 流或设备 s = {})#

对给定的索引进行散点更新。

参数 indices 和 axes 决定了 a 中哪些位置会被 updates 中的值更新。为了简化，假设 indices 是一维的，indices[i] 是轴 axes[i] 上的索引，updates 中的值将应用于这些索引。注意，indices 中的每个数组都被分配到一个对应的轴，因此 indices.size() == axes.size()。如果没有提供索引/轴对，则假定该轴上的索引为零。

注意 updates 的秩必须等于广播后的 indices 的秩与 a 的秩之和。换句话说，假设 indices 中的数组具有相同的形状，updates.ndim() == indices[0].ndim() + a.ndim()。updates 的前导维度对应于索引，剩余的 a.ndim() 维度是将应用于 a 中给定位置的值。

例如：

auto in = zeros({4, 4}, float32);
auto indices = array({2});
auto updates = reshape(arange(1, 3, float32), {1, 1, 2});
std::vector<int> axes{0};

auto out = scatter(in, {indices}, updates, axes);

将产生：

array([[0, 0, 0, 0],
       [0, 0, 0, 0],
       [1, 2, 0, 0],
       [0, 0, 0, 0]], dtype=float32)

这将两个元素的行向量 [1, 2] 从 a 的 (2, 0) 位置开始散布。

向indices添加另一个元素将分散到a的另一个位置。我们还必须为新索引添加另一个更新：

auto in = zeros({4, 4}, float32);
auto indices = array({2, 0});
auto updates = reshape(arange(1, 5, float32), {2, 1, 2});
std::vector<int> axes{0};

auto out = scatter(in, {indices}, updates, axes):

将产生：

array([[3, 4, 0, 0],
       [0, 0, 0, 0],
       [1, 2, 0, 0],
       [0, 0, 0, 0]], dtype=float32)

为了控制散点图在附加轴上的位置，向indices添加另一个索引数组，并向axes添加另一个轴：

auto in = zeros({4, 4}, float32);
auto indices = std::vector{array({2, 0}), array({1, 2})};
auto updates = reshape(arange(1, 5, float32), {2, 1, 2});
std::vector<int> axes{0, 1};

auto out = scatter(in, indices, updates, axes);

将产生：

array([[0, 0, 3, 4],
      [0, 0, 0, 0],
      [0, 1, 2, 0],
      [0, 0, 0, 0]], dtype=float32)

索引中的项目被一起广播。这意味着：

auto indices = std::vector{array({2, 0}), array({1})};

等同于：

auto indices = std::vector{array({2, 0}), array({1, 1})};

注意，scatter 不会对索引和更新进行边界检查。对 a 的越界访问是未定义的，通常会导致意外的或无效的内存写入。

在线数组散点图(常量数组 &a, 常量数组 &索引, 常量数组 &更新, 整型轴, 流或设备 s = {})#

数组 scatter_add(常量数组 &a, 常量标准::向量<数组> &索引, 常量数组 &更新, 常量标准::向量<整型> &坐标轴, 流或设备 s = {})#: 对给定索引进行散点并添加更新。

在线数组 scatter_add(常量数组 &a, 常量数组 &索引, 常量数组 &更新, 整型轴, 流或设备 s = {})#

数组散点产品(常量数组 &a, 常量标准::向量<数组> &索引, 常量数组 &更新, 常量标准::向量<整型> &坐标轴, 流或设备 s = {})#: 对给定索引进行分散和乘积更新。

在线数组散点图产品(常量数组 &a, 常量数组 &索引, 常量数组 &更新, 整型轴, 流或设备 s = {})#

数组散点最大值(常量数组 &a, 常量标准::向量<数组> &索引, 常量数组 &更新, 常量标准::向量<整型> &坐标轴, 流或设备 s = {})#: 将散点和最大更新应用于给定的线性索引。

在线数组散点图最大值(常量数组 &a, 常量数组 &索引, 常量数组 &更新, 整型轴, 流或设备 s = {})#

数组散点最小值(常量数组 &a, 常量标准::向量<数组> &索引, 常量数组 &更新, 常量标准::向量<整型> &坐标轴, 流或设备 s = {})#: 对给定的线性索引进行分散和最小更新。

在线数组散点最小值(常量数组 &a, 常量数组 &索引, 常量数组 &更新, 整型轴, 流或设备 s = {})#

数组平方根(常量数组 &a, 流或设备 s = {})#: 对数组的元素进行平方根运算。

数组平方根倒数(常量数组 &a, 流或设备 s = {})#: 对数组的元素进行平方根和倒数运算。

数组 softmax(常量数组 &a, 常量标准::向量<整型> &坐标轴, 布尔型精确 = 假, 流或设备 s = {})#: 数组的Softmax。

数组 softmax(常量数组 &a, 布尔型精准 = 假, 流或设备 s = {})#: 数组的Softmax。

在线数组 softmax(常量数组 &a, 整型轴, 布尔型精确 = 假, 流或设备 s = {})#: 数组的Softmax。

数组功率(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 将a的元素逐个提升到b的幂。

数组累加和(常量数组 &a, 整型轴, 布尔型反转 = 假, 布尔型包容性的 = 真, 流或设备 s = {})#: 数组的累积和。

数组累计乘积(常量数组 &a, 整型轴, 布尔型反转 = 假, 布尔型包容性的 = 真, 流或设备 s = {})#: 数组的累积乘积。

数组累积最大值(常量数组 &a, 整型轴, 布尔型反转 = 假, 布尔型包容性的 = 真, 流或设备 s = {})#: 数组的累积最大值。

数组最小累积(常量数组 &a, 整型轴, 布尔型反转 = 假, 布尔型包容性的 = 真, 流或设备 s = {})#: 数组的累积最小值。

数组卷积通用(数组输入, 数组重量, 标准::向量<整型> 步幅 = {}, 标准::向量<整型> 填充下部 = {}, 标准::向量<整型> 填充高度 = {}, 标准::向量<整型> 核扩张 = {}, 标准::向量<整型> 输入膨胀 = {}, 整型分组 = 1, 布尔型翻转 = 假, 流或设备 s = {})#: 使用滤波器进行一般卷积。

在线数组通用卷积(常量数组 &输入, 常量数组 &重量, 标准::向量<整型> 步幅 = {}, 标准::向量<整型> 内边距 = {}, 标准::向量<整型> 核扩张 = {}, 标准::向量<整型> 输入膨胀 = {}, 整型分组 = 1, 布尔型翻转 = 假, 流或设备 s = {})#: 使用滤波器进行一般卷积。

数组一维卷积(常量数组 &输入, 常量数组 &重量, 整型步幅 = 1, 整型内边距 = 0, 整型扩张 = 1, 整型分组 = 1, 流或设备 s = {})#: 使用滤波器进行一维卷积

数组卷积二维(常量数组 &输入, 常量数组 &重量, 常量标准::对<整型，整型> &步幅 = {1， 1}, 常量标准::对<整型，整型> &内边距 = {0， 0}, 常量标准::对<整型，整型> &扩张 = {1， 1}, 整型分组 = 1, 流或设备 s = {})#: 使用滤波器进行2D卷积

数组三维卷积(常量数组 &输入, 常量数组 &重量, 常量标准::元组<整型，整型，整型> &步幅 = {1， 1， 1}, 常量标准::元组<整型，整型，整型> &内边距 = {0， 0， 0}, 常量标准::元组<整型，整型，整型> &扩张 = {1， 1， 1}, 整型分组 = 1, 流或设备 s = {})#: 使用滤波器进行3D卷积

数组 conv_transpose1d(常量数组 &输入, 常量数组 &重量, 整型步幅 = 1, 整型内边距 = 0, 整型扩张 = 1, 整型分组 = 1, 流或设备 s = {})#: 使用滤波器进行1D转置卷积

数组反卷积二维(常量数组 &输入, 常量数组 &重量, 常量标准::对<整型，整型> &步幅 = {1， 1}, 常量标准::对<整型，整型> &内边距 = {0， 0}, 常量标准::对<整型，整型> &扩张 = {1， 1}, 整型分组 = 1, 流或设备 s = {})#: 使用滤波器的2D转置卷积

数组卷积转置3D(常量数组 &输入, 常量数组 &重量, 常量标准::元组<整型，整型，整型> &步幅 = {1， 1， 1}, 常量标准::元组<整型，整型，整型> &内边距 = {0， 0， 0}, 常量标准::元组<整型，整型，整型> &扩张 = {1， 1， 1}, 整型分组 = 1, 流或设备 s = {})#: 带有滤波器的3D转置卷积

数组量化矩阵乘法(数组 x, 数组 w, 数组比例, 数组偏差, 布尔型转置 = 真, 整型组大小 = 64, 整型位 = 4, 流或设备 s = {})#: 量化矩阵乘法将x与量化矩阵w相乘。

标准::元组<数组，数组，数组> 量化(常量数组 &w, 整型组大小 = 64, 整型位 = 4, 流或设备 s = {})#: 沿着矩阵的最后一个轴进行量化。

数组去量化(常量数组 &w, 常量数组 &比例, 常量数组 &偏差, 整型组大小 = 64, 整型位 = 4, 流或设备 s = {})#: 反量化由quantize()生成的矩阵

数组 gather_qmm(常量数组 &x, 常量数组 &w, 常量数组 &比例, 常量数组 &偏差, 标准::可选的<数组> 左侧索引 = 标准::nullopt, 标准::可选的<数组> rhs_indices = 标准::nullopt, 布尔型转置 = 真, 整型组大小 = 64, 整型位 = 4, 流或设备 s = {})#: 使用矩阵级收集计算矩阵乘积。

数组张量点积(常量数组 &a, 常量数组 &b, 常量整型轴 = 2, 流或设备 s = {})#: 返回a和b在多个维度上的收缩。

数组张量点积(常量数组 &a, 常量数组 &b, 常量标准::向量<整型> &坐标轴_a, 常量标准::向量<整型> &轴_b, 流或设备 s = {})#

数组外层(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 计算两个向量的外积。

数组内部(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 计算两个向量的内积。

数组加法矩阵乘法(数组 c, 数组 a, 数组 b, 常量浮点数 &阿尔法 = 1.f, 常量浮点数 &贝塔 = 1.f, 流或设备 s = {})#: 计算 D = beta * C + alpha * (A @ B)

数组 block_masked_mm(数组 a, 数组 b, 整型块大小, 标准::可选的<数组> 掩码输出 = 标准::nullopt, 标准::可选的<数组> mask_lhs = 标准::nullopt, 标准::可选的<数组> mask_rhs = 标准::nullopt, 流或设备 s = {})#: 计算带有块掩码的矩阵乘积。

数组 gather_mm(数组 a, 数组 b, 标准::可选的<数组> 左侧索引 = 标准::nullopt, 标准::可选的<数组> rhs_indices = 标准::nullopt, 流或设备 s = {})#: 计算矩阵乘积与矩阵级收集。

数组对角线(常量数组 &a, 整型偏移量 = 0, 整型轴1 = 0, 整型轴2 = 1, 流或设备 s = {})#: 提取对角线或构造对角线数组。

数组对角线(常量数组 &a, 整型 k = 0, 流或设备 s = {})#: 从二维数组中提取对角线或创建对角矩阵。

数组跟踪(常量数组 &a, 整型偏移量, 整型轴1, 整型轴2, 数据类型数据类型, 流或设备 s = {})#: 返回给定数组中沿指定对角线的和。

数组跟踪(常量数组 &a, 整型偏移量, 整型轴1, 整型轴2, 流或设备 s = {})#

数组跟踪(常量数组 &a, 流或设备 s = {})#

标准::向量<数组> 依赖(常量标准::向量<数组> &输入, 常量标准::向量<数组> &依赖项)#

实现恒等函数，但允许向其他数组注入依赖项。

这确保了在计算此函数的输出时，这些其他数组已经被计算。

数组至少 1 天(常量数组 &a, 流或设备 s = {})#: 将数组转换为至少ndim数组

标准::向量<数组> 至少1天(常量标准::向量<数组> &a, 流或设备 s = {})#

数组至少二维(常量数组 &a, 流或设备 s = {})#

标准::向量<数组> 至少二维(常量标准::向量<数组> &a, 流或设备 s = {})#

数组至少_三维(常量数组 &a, 流或设备 s = {})#

标准::向量<数组> 至少3d(常量标准::向量<数组> &a, 流或设备 s = {})#

数组元素数量(常量数组 &a, 标准::向量<整型> 坐标轴, 布尔型反转的, 数据类型数据类型 = 整型32, 流或设备 s = {})#

提取沿某些轴的元素数量作为标量数组。

用于允许形状依赖的无形状编译（双关语）。

数组共轭(常量数组 &a, 流或设备 s = {})#

数组按位与(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 按位与。

数组操作符&(常量数组 &a, 常量数组 &b)#

数组位运算或(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 按位或运算。

数组操作符|(常量数组 &a, 常量数组 &b)#

数组按位异或(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 按位异或。

数组运算符^(常量数组 &a, 常量数组 &b)#

数组左移(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 将位向左移动。

数组操作符<<(常量数组 &a, 常量数组 &b)#

数组右移(常量数组 &a, 常量数组 &b, 流或设备 s = {})#: 将位向右移动。

数组运算符>>(常量数组 &a, 常量数组 &b)#

数组位运算取反(常量数组 &a, 流或设备 s = {})#: 反转位。

数组运算符~(常量数组 &a)#

数组查看(常量数组 &a, 常量数据类型 &数据类型, 流或设备 s = {})#

数组滚动(常量数组 &a, 整型移位, 流或设备 s = {})#: 沿着一个轴滚动元素并将它们引入另一侧。

数组掷骰子(常量数组 &a, 常量形状 &移位, 流或设备 s = {})#

数组滚动(常量数组 &a, 整型移位, 整型轴, 流或设备 s = {})#

数组掷骰子(常量数组 &a, 整型移位, 常量标准::向量<整型> &坐标轴, 流或设备 s = {})#

数组轮流(常量数组 &a, 常量形状 &移位, 整型轴, 流或设备 s = {})#

数组滚动(常量数组 &a, 常量形状 &移位, 常量标准::向量<整型> &坐标轴, 流或设备 s = {})#

数组实际(常量数组 &a, 流或设备 s = {})#

数组图像(常量数组 &a, 流或设备 s = {})#

数组连续的(常量数组 &a, 布尔型允许列优先 = 假, 流或设备 s = {})#

操作

目录

操作#