语言

Tensor 类

定义

提供张量运算的方法。

public ref class Tensor abstract sealed
public static class Tensor
type Tensor = class
Public Module Tensor
继承
Tensor

方法

名称 说明
Abs<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

获取每个元素的 ReadOnlyTensorSpan<T> 绝对值,并返回具有结果的新 TensorSpan<T> 元素。

Abs<T>(ReadOnlyTensorSpan<T>)

获取每个元素的 Tensor<T> 绝对值,并返回具有结果的新 Tensor<T> 元素。

Acos<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

获取每个元素的 Tensor<T> 反余弦值,并返回具有结果的新 Tensor<T> 值。

Acos<T>(ReadOnlyTensorSpan<T>)

获取每个元素的 Tensor<T> 反余弦值,并返回具有结果的新 Tensor<T> 值。

Acosh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

获取每个元素的 TensorSpan<T> 反双曲余弦值,并返回 TensorSpan<T> 结果的新值。

Acosh<T>(ReadOnlyTensorSpan<T>)

获取每个元素的 ReadOnlyTensorSpan<T> 反双曲余弦值,并返回 Tensor<T> 结果的新值。

AcosPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

采用反双曲余弦除以每个元素的 TensorSpan<T> pi,并返回 TensorSpan<T> 结果的新值。

AcosPi<T>(ReadOnlyTensorSpan<T>)

采用反双曲余弦除以每个元素的 Tensor<T> pi,并返回 Tensor<T> 结果的新值。

Add<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

在两个张量之间执行元素相加。

Add<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

在两个张量之间执行元素相加。

Add<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

在张量和标量之间执行元素相加。

Add<T>(ReadOnlyTensorSpan<T>, T)

在张量和标量之间执行元素相加。

Asin<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

获取每个元素的 ReadOnlyTensorSpan<T> 反罪,并返回一个新 TensorSpan<T> 元素的结果。

Asin<T>(ReadOnlyTensorSpan<T>)

获取每个元素的 ReadOnlyTensorSpan<T> 反罪,并返回一个新 Tensor<T> 元素的结果。

Asinh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

获取每个元素的 ReadOnlyTensorSpan<T> 反双曲正弦值,并返回 TensorSpan<T> 结果的新值。

Asinh<T>(ReadOnlyTensorSpan<T>)

获取每个元素的 ReadOnlyTensorSpan<T> 反双曲正弦值,并返回 Tensor<T> 结果的新值。

AsinPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

采用反双曲正弦除以每个元素的 ReadOnlyTensorSpan<T> pi,并返回 TensorSpan<T> 结果的新值。

AsinPi<T>(ReadOnlyTensorSpan<T>)

采用反双曲正弦除以每个元素的 ReadOnlyTensorSpan<T> pi,并返回 Tensor<T> 结果的新值。

AsReadOnlyTensorSpan<T>(T[], Int32, ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

使用指定的长度和步幅,对从指定起始索引开始的目标数组部分创建一个新的张量。

AsReadOnlyTensorSpan<T>(T[], ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

使用指定的长度和步幅,对从指定起始索引开始的目标数组部分创建一个新的张量。

AsReadOnlyTensorSpan<T>(T[], ReadOnlySpan<IntPtr>)

用于更轻松地从数组创建 TensorSpan 的扩展方法。

AsReadOnlyTensorSpan<T>(T[])

在整个目标数组上创建新的张量。

AsTensorSpan<T>(T[], Int32, ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

在从“start”索引开始并以“end”索引(独占)结尾的目标数组部分创建一个新的跨度。

AsTensorSpan<T>(T[], ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

提供张量运算的方法。

AsTensorSpan<T>(T[], ReadOnlySpan<IntPtr>)

用于更轻松地从数组创建 TensorSpan 的扩展方法。

AsTensorSpan<T>(T[])

在目标数组的整个范围上创建新范围。

Atan<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

获取每个元素的 ReadOnlyTensorSpan<T> 反正切值,并返回具有结果的新 TensorSpan<T> 元素。

Atan<T>(ReadOnlyTensorSpan<T>)

获取每个元素的 ReadOnlyTensorSpan<T> 反正切值,并返回具有结果的新 Tensor<T> 元素。

Atan2<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

获取两个输入 ReadOnlyTensorSpan<T> 的反正切值,并返回结果中的新 TensorSpan<T> 值。

Atan2<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

获取两个输入 ReadOnlyTensorSpan<T> 的反正切值,并返回结果中的新 Tensor<T> 值。

Atan2<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

获取两个输入 ReadOnlyTensorSpan<T> 的反正切值,并返回结果中的新 TensorSpan<T> 值。

Atan2<T>(ReadOnlyTensorSpan<T>, T)

获取两个输入 ReadOnlyTensorSpan<T> 的反正切值,并返回结果中的新 Tensor<T> 值。

Atan2<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

获取两个输入 ReadOnlyTensorSpan<T> 的反正切值,并返回结果中的新 TensorSpan<T> 值。

Atan2<T>(T, ReadOnlyTensorSpan<T>)

获取两个输入 ReadOnlyTensorSpan<T> 的反正切值,并返回结果中的新 Tensor<T> 值。

Atan2Pi<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

获取两个输入 ReadOnlyTensorSpan<T>的反正切值,将每个元素除以 pi,并返回结果中的新 TensorSpan<T> 值。

Atan2Pi<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

获取两个输入 ReadOnlyTensorSpan<T>的反正切值,将每个元素除以 pi,并返回结果中的新 Tensor<T> 值。

Atan2Pi<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

获取两个输入 ReadOnlyTensorSpan<T>的反正切值,将每个元素除以 pi,并返回结果中的新 TensorSpan<T> 值。

Atan2Pi<T>(ReadOnlyTensorSpan<T>, T)

获取两个输入 ReadOnlyTensorSpan<T>的反正切值,将每个元素除以 pi,并返回结果中的新 TensorSpan<T> 值。

Atan2Pi<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

获取两个输入 ReadOnlyTensorSpan<T>的反正切值,将每个元素除以 pi,并返回结果中的新 TensorSpan<T> 值。

Atan2Pi<T>(T, ReadOnlyTensorSpan<T>)

获取两个输入 ReadOnlyTensorSpan<T>的反正切值,将每个元素除以 pi,并返回结果中的新 TensorSpan<T> 值。

Atanh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

获取每个元素的 ReadOnlyTensorSpan<T> 反双曲正切值,并返回 TensorSpan<T> 结果的新值。

Atanh<T>(ReadOnlyTensorSpan<T>)

获取每个元素的 ReadOnlyTensorSpan<T> 反双曲正切值,并返回 Tensor<T> 结果的新值。

AtanPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

采用反双曲正切除以每个元素 ReadOnlyTensorSpan<T> 的 pi,并返回 TensorSpan<T> 结果的新值。

AtanPi<T>(ReadOnlyTensorSpan<T>)

采用反双曲正切除以每个元素 ReadOnlyTensorSpan<T> 的 pi,并返回 Tensor<T> 结果的新值。

Average<T>(ReadOnlyTensorSpan<T>)

返回张量中 x 元素的平均值。

BitwiseAnd<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

在两个张量之间按位执行。

BitwiseAnd<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

在两个张量之间按位执行。

BitwiseAnd<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

在张量和标量之间按位执行。

BitwiseAnd<T>(ReadOnlyTensorSpan<T>, T)

在张量和标量之间按位执行。

BitwiseOr<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

在两个张量之间执行按位或两个张量。

BitwiseOr<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

在两个张量之间执行按位或两个张量。

BitwiseOr<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

在张量和标量之间按位执行。

BitwiseOr<T>(ReadOnlyTensorSpan<T>, T)

在张量和标量之间按位执行。

Broadcast<T>(ReadOnlyTensorSpan<T>, ReadOnlySpan<IntPtr>)

将数据从 source 新形状 lengths广播。 创建新的 Tensor<T> 内存并分配新的内存。 如果形状与新形状 source 不兼容,则会引发异常。

Broadcast<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

将数据从 source 与最小可广播形状兼容 lengthsSource。 创建新的 Tensor<T> 内存并分配新的内存。

BroadcastTo<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

将数据从中 source 广播到 destination。

BroadcastTo<T>(Tensor<T>, TensorSpan<T>)

将数据从中 source 广播到 destination。

BroadcastTo<T>(TensorSpan<T>, TensorSpan<T>)

将数据从中 source 广播到 destination。

Cbrt<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算输入 ReadOnlyTensorSpan<T> 的以元素表示的多维数据集根,并返回具有结果的新 TensorSpan<T> 项。

Cbrt<T>(ReadOnlyTensorSpan<T>)

计算输入 ReadOnlyTensorSpan<T> 的以元素表示的多维数据集根,并返回具有结果的新 Tensor<T> 项。

Ceiling<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算输入 ReadOnlyTensorSpan<T> 的元素级上限,并返回具有结果的新 TensorSpan<T> 值。

Ceiling<T>(ReadOnlyTensorSpan<T>)

计算输入 ReadOnlyTensorSpan<T> 的元素级上限,并返回具有结果的新 Tensor<T> 值。

Concatenate<T>(ReadOnlySpan<Tensor<T>>, TensorSpan<T>)

沿现有轴联接张量序列。

Concatenate<T>(ReadOnlySpan<Tensor<T>>)

沿现有轴联接张量序列。

ConcatenateOnDimension<T>(Int32, ReadOnlySpan<Tensor<T>>, TensorSpan<T>)

沿现有轴联接张量序列。

ConcatenateOnDimension<T>(Int32, ReadOnlySpan<Tensor<T>>)

沿现有轴联接张量序列。

ConvertChecked<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>, TensorSpan<TTo>)

source复制到新的TensorSpan<T>值,并将每个TFrom值转换为值TTo。

ConvertChecked<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>)

source复制到新的ReadOnlyTensorSpan<T>值,并将每个TFrom值转换为值TTo。

ConvertSaturating<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>, TensorSpan<TTo>)

source复制到新的TensorSpan<T>值,并将每个TFrom值转换为值TTo。

ConvertSaturating<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>)

source复制到新的ReadOnlyTensorSpan<T>值,并将每个TFrom值转换为值TTo。

ConvertTruncating<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>, TensorSpan<TTo>)

source复制到新的TensorSpan<T>值,并将每个TFrom值转换为值TTo。

ConvertTruncating<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>)

source复制到新的ReadOnlyTensorSpan<T>值,并将每个TFrom值转换为值TTo。

CopySign<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算将符号从一个数字复制到指定张量中的另一个数字的元素结果,并返回具有结果的新 TensorSpan<T> 值。

CopySign<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

计算将符号从一个数字复制到指定张量中的另一个数字的元素结果,并返回具有结果的新 Tensor<T> 值。

CopySign<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

计算将符号从一个数字复制到指定张量中的另一个数字的元素结果,并返回具有结果的新张量。

CopySign<T>(ReadOnlyTensorSpan<T>, T)

计算将符号从一个数字复制到指定张量中的另一个数字的元素结果,并返回具有结果的新张量。

Cos<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

获取每个元素的 ReadOnlyTensorSpan<T> 余弦值,并返回具有结果的新 TensorSpan<T> 元素。

Cos<T>(ReadOnlyTensorSpan<T>)

获取每个元素的 ReadOnlyTensorSpan<T> 余弦值,并返回具有结果的新 Tensor<T> 元素。

Cosh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

获取每个元素的 ReadOnlyTensorSpan<T> 双曲余弦值,并返回具有结果的新 TensorSpan<T> 值。

Cosh<T>(ReadOnlyTensorSpan<T>)

获取每个元素的 ReadOnlyTensorSpan<T> 双曲余弦值,并返回具有结果的新 Tensor<T> 值。

CosineSimilarity<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

计算余弦相似性 x 与 y.

CosPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中值的元素余弦值,该余弦值已乘以 Pi,并返回结果中的新 TensorSpan<T> 值。

CosPi<T>(ReadOnlyTensorSpan<T>)

计算指定张量中值的元素余弦值,该余弦值已乘以 Pi,并返回结果中的新 Tensor<T> 值。

Create<T>(T[], Int32, ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

使用指定的长度和步幅,对从指定起始索引开始的目标数组部分创建一个新的张量。

Create<T>(T[], ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

使用指定的长度和步幅,对从指定起始索引开始的目标数组部分创建一个新的张量。

Create<T>(T[], ReadOnlySpan<IntPtr>)

使用指定的长度在目标数组部分上创建新的张量。

Create<T>(T[])

在整个目标数组上创建新的张量。

CreateFromShape<T>(ReadOnlySpan<IntPtr>, Boolean)

创建具有指定长度的新张量。

CreateFromShape<T>(ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>, Boolean)

创建具有指定长度和步幅的新张量。

CreateFromShapeUninitialized<T>(ReadOnlySpan<IntPtr>, Boolean)

创建具有指定长度和步幅的新张量。

CreateFromShapeUninitialized<T>(ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>, Boolean)

创建具有指定长度和步幅的新张量。 如果 pinned 为 true,则会永久固定基础缓冲区,否则不会固定基础缓冲区。 基础缓冲区未初始化。

Decrement<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

对张量执行递减。

Decrement<T>(ReadOnlyTensorSpan<T>)

对张量执行递减。

DegreesToRadians<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中每个度数到弧度之间的元素级转换,并返回具有结果的新张量。

DegreesToRadians<T>(ReadOnlyTensorSpan<T>)

计算指定张量中每个度数到弧度之间的元素级转换,并返回具有结果的新张量。

Distance<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

计算 Euclidean 空间中两个点之间的距离,指定为非空的相等长度的数字张量。

Divide<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

执行两个张量之间的按元素划分。

Divide<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

执行两个张量之间的按元素划分。

Divide<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

在张量和标量之间执行按元素划分。

Divide<T>(ReadOnlyTensorSpan<T>, T)

在张量和标量之间执行按元素划分。

Divide<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

在张量和标量之间执行按元素划分。

Divide<T>(T, ReadOnlyTensorSpan<T>)

在张量和标量之间执行按元素划分。

Dot<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

计算包含数字的两个张量的点积。

Equals<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

比较两 ReadOnlyTensorSpan<T> 个元素是否相等。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果元素相等,则返回值为 true;如果元素不相等,则返回 TensorSpan<T> false。/>

Equals<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

比较两 ReadOnlyTensorSpan<T> 个元素是否相等。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果元素相等,则返回值为 true;如果元素不相等,则返回 TensorSpan<T> false。/>

Equals<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)

比较两 ReadOnlyTensorSpan<T> 个元素是否相等。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果元素相等,则返回值为 true;如果元素不相等,则返回 TensorSpan<T> false。/>

Equals<T>(ReadOnlyTensorSpan<T>, T)

比较两 ReadOnlyTensorSpan<T> 个元素是否相等。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果元素相等,则返回值为 true;如果元素不相等,则返回 TensorSpan<T> false。/>

EqualsAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看其所有元素 x 是否相 y等。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果所有Boolean元素都为 eqaul,x则返回y值为 true。

EqualsAll<T>(ReadOnlyTensorSpan<T>, T)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看其所有元素 x 是否相 y等。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果所有Boolean元素都为 eqaul,x则返回y值为 true。

EqualsAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

比较两ReadOnlyTensorSpan<T>个元素的元素,以查看其是否等于x任何元素y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果任何元素相Boolean等x,则返回y值为 true。

EqualsAny<T>(ReadOnlyTensorSpan<T>, T)

比较两ReadOnlyTensorSpan<T>个元素的元素,以查看其是否等于x任何元素y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果任何元素相Boolean等x,则返回y值为 true。

Exp<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算在指定张量中提高 e 到单精度浮点数幂的元素级结果。

Exp<T>(ReadOnlyTensorSpan<T>)

计算在指定张量中提高 e 到单精度浮点数幂的元素级结果。

Exp10<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算将 10 提升到指定张量中的数字幂的元素运算结果。

Exp10<T>(ReadOnlyTensorSpan<T>)

计算将 10 提升到指定张量中的数字幂的元素运算结果。

Exp10M1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算将 10 提升到指定张量中的数字幂的元素运算结果,减去 1。

Exp10M1<T>(ReadOnlyTensorSpan<T>)

计算将 10 提升到指定张量中的数字幂的元素运算结果,减去 1。

Exp2<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算将 2 提升到指定张量中的数字幂的元素运算结果。

Exp2<T>(ReadOnlyTensorSpan<T>)

计算将 2 提升到指定张量中的数字幂的元素运算结果。

Exp2M1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算将 2 提升到指定张量中的数字幂的元素运算结果,减去 1。

Exp2M1<T>(ReadOnlyTensorSpan<T>)

计算将 2 提升到指定张量中的数字幂的元素运算结果,减去 1。

ExpM1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算在指定张量中向数幂(减 1)的 e 按元素计算结果。

ExpM1<T>(ReadOnlyTensorSpan<T>)

计算在指定张量中向数幂(减 1)的 e 按元素计算结果。

FillGaussianNormalDistribution<T>(TensorSpan<T>, Random)

用高斯正态分布中的随机数据填充给定 TensorSpan<T> 数据。 Random 可以选择提供种子设定。

FillUniformDistribution<T>(TensorSpan<T>, Random)

用统一分布中的随机数据填充给定 TensorSpan<T> 数据。 Random 可以选择提供种子设定。

FilteredUpdate<T>(TensorSpan<T>, ReadOnlyTensorSpan<Boolean>, ReadOnlyTensorSpan<T>)

使用tensorvalues真实位置filter更新张量。 如果维度不相同,则会引发异常。

FilteredUpdate<T>(TensorSpan<T>, ReadOnlyTensorSpan<Boolean>, T)

使用tensorvalue真实位置filter更新张量。

Floor<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中的按元素计算数字的下限。

Floor<T>(ReadOnlyTensorSpan<T>)

计算指定张量中的按元素计算数字的下限。

GreaterThan<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看哪些元素 x 大于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果元素Tensor<T>大于x,则返回值为 true;如果元素不是,则返回 y false。/>

GreaterThan<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看哪些元素 x 大于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果元素Tensor<T>大于x,则返回值为 true;如果元素不是,则返回 y false。/>

GreaterThan<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)

比较一个 ReadOnlyTensorSpan<T> 元素以查看哪些元素大于 y。 如果元素Tensor<T>大于x,则返回值为 true;如果元素不是,则返回 y false。/>

GreaterThan<T>(ReadOnlyTensorSpan<T>, T)

比较一个 ReadOnlyTensorSpan<T> 元素以查看哪些元素大于 y。 如果元素Tensor<T>大于x,则返回值为 true;如果元素不是,则返回 y false。/>

GreaterThan<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

x比较以查看哪些元素大于 y。 如果元素Tensor<T>大于x,则返回值为 true;如果元素不是,则返回 y false。/>

GreaterThan<T>(T, ReadOnlyTensorSpan<T>)

x比较以查看哪些元素大于 y。 如果元素Tensor<T>大于x,则返回值为 true;如果元素不是,则返回 y false。/>

GreaterThanAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看其所有元素 x 是否大于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果所有Boolean元素都大于x,则返回y值为 true。

GreaterThanAll<T>(ReadOnlyTensorSpan<T>, T)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看其所有元素 x 是否大于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果所有Boolean元素都大于x,则返回y值为 true。

GreaterThanAll<T>(T, ReadOnlyTensorSpan<T>)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看其所有元素 y 是否大于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果所有Boolean元素都大于y,则返回y值为 true。

GreaterThanAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

比较两ReadOnlyTensorSpan<T>个元素的元素,以查看其是否大于x任何元素y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果任何Boolean元素大于x,则返回y值为 true。

GreaterThanAny<T>(ReadOnlyTensorSpan<T>, T)

比较两ReadOnlyTensorSpan<T>个元素的元素,以查看其是否大于x任何元素y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果任何Boolean元素大于x,则返回y值为 true。

GreaterThanAny<T>(T, ReadOnlyTensorSpan<T>)

比较两ReadOnlyTensorSpan<T>个元素的元素,以查看其是否大于y任何元素x。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果任何Boolean元素大于y,则返回x值为 true。

GreaterThanOrEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

比较两 ReadOnlyTensorSpan<T> 个元素,以查看哪些元素 x 大于或等于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果元素Tensor<T>大于x,则返回值为 true;如果元素不是,则返回 y false。/>

GreaterThanOrEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

比较两 ReadOnlyTensorSpan<T> 个元素,以查看哪些元素 x 大于或等于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果元素Tensor<T>大于x,则返回值为 true;如果元素不是,则返回 y false。/>

GreaterThanOrEqual<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)

比较一个 ReadOnlyTensorSpan<T> 元素以查看哪些元素大于或等于 y。 如果元素Tensor<T>大于x,则返回值为 true;如果元素不是,则返回 y false。/>

GreaterThanOrEqual<T>(ReadOnlyTensorSpan<T>, T)

比较一个 ReadOnlyTensorSpan<T> 元素以查看哪些元素大于或等于 y。 如果元素Tensor<T>大于x,则返回值为 true;如果元素不是,则返回 y false。/>

GreaterThanOrEqual<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

x比较以查看哪些元素大于或等于 y。 如果元素Tensor<T>大于x,则返回值为 true;如果元素不是,则返回 y false。/>

GreaterThanOrEqual<T>(T, ReadOnlyTensorSpan<T>)

x比较以查看哪些元素大于或等于 y。 如果元素Tensor<T>大于x,则返回值为 true;如果元素不是,则返回 y false。/>

GreaterThanOrEqualAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看其所有元素 x 是否大于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果所有Boolean元素都大于x,则返回y值为 true。

GreaterThanOrEqualAll<T>(ReadOnlyTensorSpan<T>, T)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看其所有元素 x 是否大于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果所有Boolean元素都大于x,则返回y值为 true。

GreaterThanOrEqualAll<T>(T, ReadOnlyTensorSpan<T>)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看其所有元素 y 是否大于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果所有Boolean元素都大于y,则返回y值为 true。

GreaterThanOrEqualAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

比较两ReadOnlyTensorSpan<T>个元素的元素,以查看其是否大于x任何元素y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果任何Boolean元素大于x,则返回y值为 true。

GreaterThanOrEqualAny<T>(ReadOnlyTensorSpan<T>, T)

比较两ReadOnlyTensorSpan<T>个元素的元素,以查看其是否大于x任何元素y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果任何Boolean元素大于x,则返回y值为 true。

GreaterThanOrEqualAny<T>(T, ReadOnlyTensorSpan<T>)

比较两ReadOnlyTensorSpan<T>个元素的元素,以查看其是否大于y任何元素x。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果任何Boolean元素大于y,则返回x值为 true。

Hypot<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

从两个张量(表示右角三角形中较短边的长度)计算元素的虚构值。 如果形状不相同,则它们将广播到最小的兼容形状。

Hypot<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

从两个张量(表示右角三角形中较短边的长度)计算元素的虚构值。 如果形状不相同,则它们将广播到最小的兼容形状。

Ieee754Remainder<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中的数字的元素余数。

Ieee754Remainder<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

计算指定张量中的数字的元素余数。

Ieee754Remainder<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

计算指定张量中的数字的元素余数。

Ieee754Remainder<T>(ReadOnlyTensorSpan<T>, T)

计算指定张量中的数字的元素余数。

Ieee754Remainder<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中的数字的元素余数。

Ieee754Remainder<T>(T, ReadOnlyTensorSpan<T>)

计算指定张量中的数字的元素余数。

ILogB<T>(ReadOnlyTensorSpan<T>, TensorSpan<Int32>)

计算指定张量中数字的元素整数对数。

ILogB<T>(ReadOnlyTensorSpan<T>)

计算指定张量中数字的元素整数对数。

Increment<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

对张量执行增量。

Increment<T>(ReadOnlyTensorSpan<T>)

对张量执行增量。

IndexOfMax<T>(ReadOnlyTensorSpan<T>)

搜索指定张量中最大数字的索引。

IndexOfMaxMagnitude<T>(ReadOnlyTensorSpan<T>)

搜索指定张量中具有最大数量级的数字的索引。

IndexOfMin<T>(ReadOnlyTensorSpan<T>)

搜索指定张量中最小数字的索引。

IndexOfMinMagnitude<T>(ReadOnlyTensorSpan<T>)

在指定的张量中搜索具有最小数量级的数字的索引。

LeadingZeroCount<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中的元素前导数字零计数。

LeadingZeroCount<T>(ReadOnlyTensorSpan<T>)

计算指定张量中的元素前导数字零计数。

LessThan<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看哪些元素 x 小于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果元素中的Tensor<T>元素小于,则返回值为 true;如果元素不是x,则返回 y false。/>

LessThan<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看哪些元素 x 小于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果元素中的Tensor<T>元素小于,则返回值为 true;如果元素不是x,则返回 y false。/>

LessThan<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)

比较一个 Tensor<T> 元素,以查看哪些元素小于 y。 如果元素中的Tensor<T>元素小于,则返回值为 true;如果元素不是x,则返回 y false。/>

LessThan<T>(ReadOnlyTensorSpan<T>, T)

比较一个 Tensor<T> 元素,以查看哪些元素小于 y。 如果元素中的Tensor<T>元素小于,则返回值为 true;如果元素不是x,则返回 y false。/>

LessThan<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

比较一个 Tensor<T> 元素,以查看哪些元素小于 y。 如果元素中的Tensor<T>元素小于,则返回值为 true;如果元素不是x,则返回 y false。/>

LessThan<T>(T, ReadOnlyTensorSpan<T>)

比较一个 Tensor<T> 元素,以查看哪些元素小于 y。 如果元素中的Tensor<T>元素小于,则返回值为 true;如果元素不是x,则返回 y false。/>

LessThanAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看其所有元素 x 是否小于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果所有Boolean元素都小于x,则返回y值为 true。

LessThanAll<T>(ReadOnlyTensorSpan<T>, T)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看其所有元素 x 是否小于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果所有Boolean元素都小于x,则返回y值为 true。

LessThanAll<T>(T, ReadOnlyTensorSpan<T>)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看其所有元素 y 是否小于 x。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果所有Boolean元素都小于y,则返回x值为 true。

LessThanAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看其任何元素 x 是否小于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果任何元素中的Boolean元素小于x,则返回y值为 true。

LessThanAny<T>(ReadOnlyTensorSpan<T>, T)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看其任何元素 x 是否小于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果任何元素中的Boolean元素小于x,则返回y值为 true。

LessThanAny<T>(T, ReadOnlyTensorSpan<T>)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看其任何元素 y 是否小于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果任何元素中的Boolean元素小于y,则返回y值为 true。

LessThanOrEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看哪些元素 x 小于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果元素中的Tensor<T>元素小于,则返回值为 true;如果元素不是x,则返回 y false。/>

LessThanOrEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看哪些元素 x 小于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果元素中的Tensor<T>元素小于,则返回值为 true;如果元素不是x,则返回 y false。/>

LessThanOrEqual<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)

比较一个 Tensor<T> 元素,以查看哪些元素小于 y。 如果元素中的Tensor<T>元素小于,则返回值为 true;如果元素不是x,则返回 y false。/>

LessThanOrEqual<T>(ReadOnlyTensorSpan<T>, T)

比较一个 Tensor<T> 元素,以查看哪些元素小于 y。 如果元素中的Tensor<T>元素小于,则返回值为 true;如果元素不是x,则返回 y false。/>

LessThanOrEqual<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

比较一个 Tensor<T> 元素,以查看哪些元素小于 y。 如果元素中的Tensor<T>元素小于,则返回值为 true;如果元素不是x,则返回 y false。/>

LessThanOrEqual<T>(T, ReadOnlyTensorSpan<T>)

比较一个 Tensor<T> 元素,以查看哪些元素小于 y。 如果元素中的Tensor<T>元素小于,则返回值为 true;如果元素不是x,则返回 y false。/>

LessThanOrEqualAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看其所有元素 x 是否小于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果所有Boolean元素都小于x,则返回y值为 true。

LessThanOrEqualAll<T>(ReadOnlyTensorSpan<T>, T)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看其所有元素 x 是否小于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果所有Boolean元素都小于x,则返回y值为 true。

LessThanOrEqualAll<T>(T, ReadOnlyTensorSpan<T>)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看其所有元素 y 是否小于 x。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果所有Boolean元素都小于y,则返回x值为 true。

LessThanOrEqualAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看其任何元素 x 是否小于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果任何元素中的Boolean元素小于x,则返回y值为 true。

LessThanOrEqualAny<T>(ReadOnlyTensorSpan<T>, T)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看其任何元素 x 是否小于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果任何元素中的Boolean元素小于x,则返回y值为 true。

LessThanOrEqualAny<T>(T, ReadOnlyTensorSpan<T>)

比较两 ReadOnlyTensorSpan<T> 个元素的元素,以查看其任何元素 y 是否小于 y。 如果形状不相同,则张量在进行比较之前将广播到最小可广播大小。 如果任何元素中的Boolean元素小于y,则返回y值为 true。

Log<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

将指定张量中的数字的元素对数计算到另一个指定张量中的指定基数。

Log<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

将指定张量中的数字的元素对数计算到另一个指定张量中的指定基数。

Log<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

将指定张量中的数字的元素对数计算到另一个指定张量中的指定基数。

Log<T>(ReadOnlyTensorSpan<T>, T)

将指定张量中的数字的元素对数计算到另一个指定张量中的指定基数。

Log<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

获取每个元素 ReadOnlyTensorSpan<T> 的自然对数,并返回 TensorSpan<T> 结果的新值。

Log<T>(ReadOnlyTensorSpan<T>)

获取每个元素 ReadOnlyTensorSpan<T> 的自然对数,并返回 Tensor<T> 结果的新值。

Log10<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

获取每个元素 ReadOnlyTensorSpan<T> 的基数 10 对数,并返回具有结果的新 TensorSpan<T> 元素。

Log10<T>(ReadOnlyTensorSpan<T>)

获取每个元素 ReadOnlyTensorSpan<T> 的基数 10 对数,并返回具有结果的新 Tensor<T> 元素。

Log10P1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

获取基数 10 对数加上每个元素 ReadOnlyTensorSpan<T> 的 1 个,并返回 TensorSpan<T> 结果的新值。

Log10P1<T>(ReadOnlyTensorSpan<T>)

获取基数 10 对数加上每个元素 ReadOnlyTensorSpan<T> 的 1 个,并返回 Tensor<T> 结果的新值。

Log2<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

获取每个元素 ReadOnlyTensorSpan<T> 的 base 2 对数,并返回结果为新 TensorSpan<T> 项。

Log2<T>(ReadOnlyTensorSpan<T>)

获取每个元素 ReadOnlyTensorSpan<T> 的 base 2 对数,并返回结果为新 Tensor<T> 项。

Log2P1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

获取基础 2 对数加上每个元素 ReadOnlyTensorSpan<T> 的 1 个,并返回一个新 TensorSpan<T> 结果。

Log2P1<T>(ReadOnlyTensorSpan<T>)

获取基础 2 对数加上每个元素 ReadOnlyTensorSpan<T> 的 1 个,并返回一个新 Tensor<T> 结果。

LogP1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

采用自然对数加上每个元素 ReadOnlyTensorSpan<T> 的 1,并返回一个新 TensorSpan<T> 结果。

LogP1<T>(ReadOnlyTensorSpan<T>)

采用自然对数加上每个元素 ReadOnlyTensorSpan<T> 的 1,并返回一个新 Tensor<T> 结果。

Max<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中数字的按元素计算的最大值。

Max<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

计算指定张量中数字的按元素计算的最大值。

Max<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

计算指定张量中数字的按元素计算的最大值。

Max<T>(ReadOnlyTensorSpan<T>, T)

计算指定张量中数字的按元素计算的最大值。

Max<T>(ReadOnlyTensorSpan<T>)

搜索指定张量中的最大数字。

MaxMagnitude<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中具有最大数量级的元素级数。

MaxMagnitude<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

计算指定张量中具有最大数量级的元素级数。

MaxMagnitude<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

计算指定张量中具有最大数量级的元素级数。

MaxMagnitude<T>(ReadOnlyTensorSpan<T>, T)

计算指定张量中具有最大数量级的元素级数。

MaxMagnitude<T>(ReadOnlyTensorSpan<T>)

在指定的张量中搜索具有最大数量级的数字。

MaxMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中具有最大数量级的元素级数。

MaxMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

计算指定张量中具有最大数量级的元素级数。

MaxMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

计算指定张量中具有最大数量级的元素级数。

MaxMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, T)

计算指定张量中具有最大数量级的元素级数。

MaxMagnitudeNumber<T>(ReadOnlyTensorSpan<T>)

在指定的张量中搜索具有最大数量级的数字。

MaxNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中数字的按元素计算的最大值。

MaxNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

计算指定张量中数字的按元素计算的最大值。

MaxNumber<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

计算指定张量中数字的按元素计算的最大值。

MaxNumber<T>(ReadOnlyTensorSpan<T>, T)

计算指定张量中数字的按元素计算的最大值。

MaxNumber<T>(ReadOnlyTensorSpan<T>)

搜索指定张量中的最大数字。

Min<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中数字的按元素计算的最小值。

Min<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

计算指定张量中数字的按元素计算的最小值。

Min<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

计算指定张量中数字的按元素计算的最小值。

Min<T>(ReadOnlyTensorSpan<T>, T)

计算指定张量中数字的按元素计算的最小值。

Min<T>(ReadOnlyTensorSpan<T>)

搜索指定张量中的最小数字。

MinMagnitude<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中具有最小数量级的元素级数。

MinMagnitude<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

计算指定张量中具有最小数量级的元素级数。

MinMagnitude<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

计算指定张量中具有最小数量级的元素级数。

MinMagnitude<T>(ReadOnlyTensorSpan<T>, T)

计算指定张量中具有最小数量级的元素级数。

MinMagnitude<T>(ReadOnlyTensorSpan<T>)

在指定的张量中搜索具有最小数量级的数字。

MinMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中具有最小数量级的元素级数。

MinMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

计算指定张量中具有最小数量级的元素级数。

MinMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

计算指定张量中具有最小数量级的元素级数。

MinMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, T)

计算指定张量中具有最小数量级的元素级数。

MinMagnitudeNumber<T>(ReadOnlyTensorSpan<T>)

在指定的张量中搜索具有最小数量级的数字。

MinNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中数字的按元素计算的最小值。

MinNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

计算指定张量中数字的按元素计算的最小值。

MinNumber<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

计算指定张量中数字的按元素计算的最小值。

MinNumber<T>(ReadOnlyTensorSpan<T>, T)

计算指定张量中数字的按元素计算的最小值。

MinNumber<T>(ReadOnlyTensorSpan<T>)

搜索指定张量中的最小数字。

Multiply<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

在两个张量之间执行元素乘法。

Multiply<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

在两个张量之间执行元素乘法。

Multiply<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

在张量和标量之间执行元素乘法。

Multiply<T>(ReadOnlyTensorSpan<T>, T)

在张量和标量之间执行元素乘法。

Negate<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

对张量执行元素一元求反。

Negate<T>(ReadOnlyTensorSpan<T>)

对张量执行元素一元求反。

Norm<T>(ReadOnlyTensorSpan<T>)

采用 ReadOnlyTensorSpan<T> 规范并返回结果。

OnesComplement<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

对张量执行一个补充。

OnesComplement<T>(ReadOnlyTensorSpan<T>)

对张量执行一个补充。

PermuteDimensions<T>(Tensor<T>, ReadOnlySpan<Int32>)

根据tensor参数交换张量的尺寸dimensions。 如果 tensor 为 1D 张量,它将返回 tensor。 否则,它会通过分配新内存来创建新的 Tensor<T> 轴排序。

PopCount<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中的按元素计算数字的计数。

PopCount<T>(ReadOnlyTensorSpan<T>)

计算指定张量中的按元素计算数字的计数。

Pow<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中某一数字的元素幂,该数值在另一个指定的张量中引发为一个数字。

Pow<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

计算指定张量中某一数字的元素幂,该数值在另一个指定的张量中引发为一个数字。

Pow<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

计算指定张量中某一数字的元素幂,该数值在另一个指定的张量中引发为一个数字。

Pow<T>(ReadOnlyTensorSpan<T>, T)

计算指定张量中某一数字的元素幂,该数值在另一个指定的张量中引发为一个数字。

Pow<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中某一数字的元素幂,该数值在另一个指定的张量中引发为一个数字。

Pow<T>(T, ReadOnlyTensorSpan<T>)

计算指定张量中某一数字的元素幂,该数值在另一个指定的张量中引发为一个数字。

Product<T>(ReadOnlyTensorSpan<T>)

计算指定非空数值张量中的所有元素的乘积。

RadiansToDegrees<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量到度中的每个弧度的元素级转换。

RadiansToDegrees<T>(ReadOnlyTensorSpan<T>)

计算指定张量到度中的每个弧度的元素级转换。

Reciprocal<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中的数字的元素倒数。

Reciprocal<T>(ReadOnlyTensorSpan<T>)

计算指定张量中的数字的元素倒数。

Reshape<T>(ReadOnlyTensorSpan<T>, ReadOnlySpan<IntPtr>)

将 tensor 张量重新调整为指定的 lengths张量。 如果其中一个长度为 -1,则会自动计算该长度。 不会更改基础内存的长度,也不会分配新内存。 如果新形状与旧形状不兼容,则会引发异常。

Reshape<T>(Tensor<T>, ReadOnlySpan<IntPtr>)

将 tensor 张量重新调整为指定的 lengths张量。 如果其中一个长度为 -1,则会自动计算该长度。 不会更改基础内存的长度,也不会分配新内存。 如果新形状与旧形状不兼容,则会引发异常。

Reshape<T>(TensorSpan<T>, ReadOnlySpan<IntPtr>)

将 tensor 张量重新调整为指定的 lengths张量。 如果其中一个长度为 -1,则会自动计算该长度。 不会更改基础内存的长度,也不会分配新内存。 如果新形状与旧形状不兼容,则会引发异常。

Resize<T>(Tensor<T>, ReadOnlySpan<IntPtr>)

Tensor<T>创建新的内存,分配新的内存,并从中复制数据tensor。 如果最后一个形状在忽略该点后的所有数据都较小。

ResizeTo<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

从 tensor中复制数据。 如果最后一个形状在忽略该点后的所有数据都较小。 如果最终形状更大,则用默认值 T填充 。

ResizeTo<T>(Tensor<T>, TensorSpan<T>)

从 tensor中复制数据。 如果最后一个形状在忽略该点后的所有数据都较小。 如果最终形状更大,则用默认值 T填充 。

ResizeTo<T>(TensorSpan<T>, TensorSpan<T>)

从 tensor中复制数据。 如果最后一个形状在忽略该点后的所有数据都较小。 如果最终形状更大,则用默认值 T填充 。

Reverse<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

反转 . tensor中的元素顺序。 张量的形状会保留,但元素重新排序。

Reverse<T>(ReadOnlyTensorSpan<T>)

反转 . tensor中的元素顺序。 张量的形状会保留,但元素重新排序。

ReverseDimension<T>(ReadOnlyTensorSpan<T>, Int32)

沿给定维度反转元素 tensor 的顺序。 张量的形状会保留,但元素重新排序。 dimension 如果未提供,则默认为 -1,这会反转整个张量。

ReverseDimension<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>, Int32)

沿给定轴反转元素 tensor 的顺序。 张量的形状会保留,但元素重新排序。 dimension 如果未提供,则默认为 -1,这将反转整个范围。

RootN<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

计算指定张量中值的元素第 n 个根。

RootN<T>(ReadOnlyTensorSpan<T>, Int32)

计算指定张量中值的元素第 n 个根。

RotateLeft<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

按指定的旋转量计算指定张量中数字的元素旋转左侧。

RotateLeft<T>(ReadOnlyTensorSpan<T>, Int32)

按指定的旋转量计算指定张量中数字的元素旋转左侧。

RotateRight<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

按指定的旋转量计算指定张量中数字的元素旋转右。

RotateRight<T>(ReadOnlyTensorSpan<T>, Int32)

按指定的旋转量计算指定张量中数字的元素旋转右。

Round<T>(ReadOnlyTensorSpan<T>, Int32, MidpointRounding, TensorSpan<T>)

计算指定张量中数字的元素舍入

Round<T>(ReadOnlyTensorSpan<T>, Int32, MidpointRounding)

计算指定张量中数字的元素舍入

Round<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

计算指定张量中数字的元素舍入

Round<T>(ReadOnlyTensorSpan<T>, Int32)

计算指定张量中数字的元素舍入

Round<T>(ReadOnlyTensorSpan<T>, MidpointRounding, TensorSpan<T>)

计算指定张量中数字的元素舍入

Round<T>(ReadOnlyTensorSpan<T>, MidpointRounding)

计算指定张量中数字的元素舍入

Round<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中数字的元素舍入

Round<T>(ReadOnlyTensorSpan<T>)

计算指定张量中数字的元素舍入

SequenceEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

通过使用 IEquatable{T} 比较元素,确定两个序列是否相等。等于(T)。

SequenceEqual<T>(TensorSpan<T>, ReadOnlyTensorSpan<T>)

通过使用 IEquatable{T} 比较元素,确定两个序列是否相等。等于(T)。

SetSlice<T>(Tensor<T>, ReadOnlyTensorSpan<T>, ReadOnlySpan<NRange>)

使用为给定提供的tensor切片设置给定的values切片ranges

SetSlice<T>(TensorSpan<T>, ReadOnlyTensorSpan<T>, ReadOnlySpan<NRange>)

使用为给定提供的tensor切片设置给定的values切片ranges

ShiftLeft<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

对张量执行以元素方式左移。

ShiftLeft<T>(ReadOnlyTensorSpan<T>, Int32)

对张量执行以元素方式左移。

ShiftRightArithmetic<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

对张量执行按元素算术右移。

ShiftRightArithmetic<T>(ReadOnlyTensorSpan<T>, Int32)

对张量执行按元素算术右移。

ShiftRightLogical<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

对张量执行按元素的逻辑右移。

ShiftRightLogical<T>(ReadOnlyTensorSpan<T>, Int32)

对张量执行按元素的逻辑右移。

Sigmoid<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定非空数值张量上的元素级 sigmoid 函数。

Sigmoid<T>(ReadOnlyTensorSpan<T>)

计算指定非空数值张量上的元素级 sigmoid 函数。

Sin<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

获取每个元素的 ReadOnlyTensorSpan<T> 罪名,并返回一个新的 TensorSpan<T> 结果。

Sin<T>(ReadOnlyTensorSpan<T>)

获取每个元素的 ReadOnlyTensorSpan<T> 罪名,并返回一个新的 Tensor<T> 结果。

Sinh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中每个弧度角的元素双曲正弦值。

Sinh<T>(ReadOnlyTensorSpan<T>)

计算指定张量中每个弧度角的元素双曲正弦值。

SinPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中乘以 Pi 的值的元素顺正弦值。

SinPi<T>(ReadOnlyTensorSpan<T>)

计算指定张量中乘以 Pi 的值的元素顺正弦值。

SoftMax<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

通过指定的非空张量计算 softmax 函数。

SoftMax<T>(ReadOnlyTensorSpan<T>)

通过指定的非空张量计算 softmax 函数。

Split<T>(ReadOnlyTensorSpan<T>, Int32, IntPtr)

将一个 Tensor<T> 拆分为 splitCount 沿给定 dimension的 。 如果给定异常无法均匀 dimension 拆分张量,则会引发异常。

Sqrt<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

获取每个元素的 x 平方根,并返回具有结果的新 TensorSpan<T> 元素。

Sqrt<T>(ReadOnlyTensorSpan<T>)

获取每个元素的 ReadOnlyTensorSpan<T> 平方根,并返回具有结果的新 Tensor<T> 元素。

Squeeze<T>(ReadOnlyTensorSpan<T>)

从中移除一个 tensor长度的所有维度。

Squeeze<T>(Tensor<T>)

从中移除一个 tensor长度的所有维度。

Squeeze<T>(TensorSpan<T>)

从中移除一个 tensor长度的所有维度。

SqueezeDimension<T>(ReadOnlyTensorSpan<T>, Int32)

从给定tensor的轴中移除长度为 1 dimension 的轴。 如果维度不是长度,则会引发异常。

SqueezeDimension<T>(Tensor<T>, Int32)

从给定tensor的轴中移除长度为 1 dimension 的轴。 如果维度不是长度,则会引发异常。

SqueezeDimension<T>(TensorSpan<T>, Int32)

从给定tensor的轴中移除长度为 1 dimension 的轴。 如果维度不是长度,则会引发异常。

Stack<T>(ReadOnlySpan<Tensor<T>>, TensorSpan<T>)

沿位于位置 0 的新维度联接多个 Tensor<T> 。 所有张量都必须具有等效的形状。

Stack<T>(ReadOnlySpan<Tensor<T>>)

沿位于位置 0 的新维度联接多个 Tensor<T> 。 所有张量都必须具有等效的形状。

StackAlongDimension<T>(Int32, ReadOnlySpan<Tensor<T>>)

沿新维度联接多个 Tensor<T> 。 轴参数指定新维度的索引。 所有张量都必须具有等效的形状。

StackAlongDimension<T>(ReadOnlySpan<Tensor<T>>, TensorSpan<T>, Int32)

沿新维度联接多个 Tensor<T> 。 轴参数指定新维度的索引。 所有张量都必须具有等效的形状。

StdDev<T>(ReadOnlyTensorSpan<T>)

返回张量中 x 元素的标准偏差。

Subtract<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

在两个张量之间执行元素级减法。

Subtract<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

在两个张量之间执行元素级减法。

Subtract<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

在张量和标量之间执行元素级减法。

Subtract<T>(ReadOnlyTensorSpan<T>, T)

在张量和标量之间执行元素级减法。

Subtract<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

在张量和标量之间执行元素级减法。

Subtract<T>(T, ReadOnlyTensorSpan<T>)

在张量和标量之间执行元素级减法。

Sum<T>(ReadOnlyTensorSpan<T>)

对指定张量元素求和。

Tan<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中值的元素正切值。

Tan<T>(ReadOnlyTensorSpan<T>)

计算指定张量中值的元素正切值。

Tanh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中每个弧度角的元素双曲正切值。

Tanh<T>(ReadOnlyTensorSpan<T>)

计算指定张量中每个弧度角的元素双曲正切值。

TanPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中值(乘以 Pi)中的元素正切值。

TanPi<T>(ReadOnlyTensorSpan<T>)

计算指定张量中值(乘以 Pi)中的元素正切值。

TrailingZeroCount<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中的元素尾随零个数字计数。

TrailingZeroCount<T>(ReadOnlyTensorSpan<T>)

计算指定张量中的元素尾随零个数字计数。

Transpose<T>(Tensor<T>)

交换张量的最后两个维度 tensor 。

Truncate<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

计算指定张量中数字的元素截断。

Truncate<T>(ReadOnlyTensorSpan<T>)

计算指定张量中数字的元素截断。

TryBroadcastTo<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

将数据从 tensor 与最小的可广播形状兼容 destination ,并将其存储在 destination 形状不兼容时,返回 false。

TryBroadcastTo<T>(Tensor<T>, TensorSpan<T>)

将数据从 tensor 与最小的可广播形状兼容 destination ,并将其存储在 destination 形状不兼容时,返回 false。

TryBroadcastTo<T>(TensorSpan<T>, TensorSpan<T>)

将数据从 tensor 与最小的可广播形状兼容 destination ,并将其存储在 destination 形状不兼容时,返回 false。

Unsqueeze<T>(ReadOnlyTensorSpan<T>, Int32)

插入长度为 1 的新维度,该维度将显示在维度位置。

Unsqueeze<T>(Tensor<T>, Int32)

插入长度为 1 的新维度,该维度将显示在维度位置。

Unsqueeze<T>(TensorSpan<T>, Int32)

插入长度为 1 的新维度,该维度将显示在维度位置。

Xor<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

在两个张量之间执行独占或介于两个张量之间。

Xor<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

在两个张量之间执行独占或介于两个张量之间。

Xor<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

执行张量和标量之间的独占或。

Xor<T>(ReadOnlyTensorSpan<T>, T)

执行张量和标量之间的独占或。

运算符

名称 说明
Addition(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行元素相加。

Addition(ReadOnlyTensorSpan<TScalar>, TScalar)

在张量和标量之间执行元素相加。

Addition(Tensor<TScalar>, Tensor<TScalar>)

在两个张量之间执行元素相加。

Addition(Tensor<TScalar>, TScalar)

在张量和标量之间执行元素相加。

Addition(TensorSpan<TScalar>, TensorSpan<TScalar>)

在两个张量之间执行元素相加。

Addition(TensorSpan<TScalar>, TScalar)

在张量和标量之间执行元素相加。

Addition(TScalar, ReadOnlyTensorSpan<TScalar>)

在张量和标量之间执行元素相加。

Addition(TScalar, Tensor<TScalar>)

在张量和标量之间执行元素相加。

Addition(TScalar, TensorSpan<TScalar>)

在张量和标量之间执行元素相加。

Addition<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行元素相加。

Addition<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

在张量和标量之间执行元素相加。

Addition<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

在两个张量之间执行元素相加。

Addition<TScalar>(Tensor<TScalar>, TScalar)

在张量和标量之间执行元素相加。

Addition<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

在两个张量之间执行元素相加。

Addition<TScalar>(TensorSpan<TScalar>, TScalar)

在张量和标量之间执行元素相加。

Addition<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

在张量和标量之间执行元素相加。

Addition<TScalar>(TScalar, Tensor<TScalar>)

在张量和标量之间执行元素相加。

Addition<TScalar>(TScalar, TensorSpan<TScalar>)

在张量和标量之间执行元素相加。

AdditionAssignment(ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行就地元素相加。

AdditionAssignment(ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行就地元素相加。

AdditionAssignment(TScalar)

在张量和标量之间执行就地元素相加。

AdditionAssignment(TScalar)

在张量和标量之间执行就地元素相加。

AdditionAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行就地元素相加。

AdditionAssignment<TScalar>(Tensor<TScalar>, TScalar)

在张量和标量之间执行就地元素相加。

AdditionAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行就地元素相加。

AdditionAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

在张量和标量之间执行就地元素相加。

BitwiseAnd(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间按位执行。

BitwiseAnd(ReadOnlyTensorSpan<TScalar>, TScalar)

在张量和标量之间按位执行。

BitwiseAnd(Tensor<TScalar>, Tensor<TScalar>)

在两个张量之间按位执行。

BitwiseAnd(Tensor<TScalar>, TScalar)

在张量和标量之间按位执行。

BitwiseAnd(TensorSpan<TScalar>, TensorSpan<TScalar>)

在两个张量之间按位执行。

BitwiseAnd(TensorSpan<TScalar>, TScalar)

在张量和标量之间按位执行。

BitwiseAnd(TScalar, ReadOnlyTensorSpan<TScalar>)

在张量和标量之间按位执行。

BitwiseAnd(TScalar, Tensor<TScalar>)

在张量和标量之间按位执行。

BitwiseAnd(TScalar, TensorSpan<TScalar>)

在张量和标量之间按位执行。

BitwiseAnd<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间按位执行。

BitwiseAnd<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

在张量和标量之间按位执行。

BitwiseAnd<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

在两个张量之间按位执行。

BitwiseAnd<TScalar>(Tensor<TScalar>, TScalar)

在张量和标量之间按位执行。

BitwiseAnd<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

在两个张量之间按位执行。

BitwiseAnd<TScalar>(TensorSpan<TScalar>, TScalar)

在张量和标量之间按位执行。

BitwiseAnd<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

在张量和标量之间按位执行。

BitwiseAnd<TScalar>(TScalar, Tensor<TScalar>)

在张量和标量之间按位执行。

BitwiseAnd<TScalar>(TScalar, TensorSpan<TScalar>)

在张量和标量之间按位执行。

BitwiseAndAssignment(ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行就地位运算。

BitwiseAndAssignment(ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行就地位运算。

BitwiseAndAssignment(TScalar)

在张量和标量之间按位执行。

BitwiseAndAssignment(TScalar)

在张量和标量之间按位执行。

BitwiseAndAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行就地位运算。

BitwiseAndAssignment<TScalar>(Tensor<TScalar>, TScalar)

在张量和标量之间按位执行。

BitwiseAndAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行就地位运算。

BitwiseAndAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

在张量和标量之间按位执行。

BitwiseOr(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行按位或两个张量。

BitwiseOr(ReadOnlyTensorSpan<TScalar>, TScalar)

在张量和标量之间按位执行。

BitwiseOr(Tensor<TScalar>, Tensor<TScalar>)

在两个张量之间执行按位或两个张量。

BitwiseOr(Tensor<TScalar>, TScalar)

在张量和标量之间按位执行。

BitwiseOr(TensorSpan<TScalar>, TensorSpan<TScalar>)

在两个张量之间执行按位或两个张量。

BitwiseOr(TensorSpan<TScalar>, TScalar)

在张量和标量之间按位执行。

BitwiseOr(TScalar, ReadOnlyTensorSpan<TScalar>)

在张量和标量之间按位执行。

BitwiseOr(TScalar, Tensor<TScalar>)

在张量和标量之间按位执行。

BitwiseOr(TScalar, TensorSpan<TScalar>)

在张量和标量之间按位执行。

BitwiseOr<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行按位或两个张量。

BitwiseOr<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

在张量和标量之间按位执行。

BitwiseOr<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

在两个张量之间执行按位或两个张量。

BitwiseOr<TScalar>(Tensor<TScalar>, TScalar)

在张量和标量之间按位执行。

BitwiseOr<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

在两个张量之间执行按位或两个张量。

BitwiseOr<TScalar>(TensorSpan<TScalar>, TScalar)

在张量和标量之间按位执行。

BitwiseOr<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

在张量和标量之间按位执行。

BitwiseOr<TScalar>(TScalar, Tensor<TScalar>)

在张量和标量之间按位执行。

BitwiseOr<TScalar>(TScalar, TensorSpan<TScalar>)

在张量和标量之间按位执行。

BitwiseOrAssignment(ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行就地位或两个张量。

BitwiseOrAssignment(ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行就地位或两个张量。

BitwiseOrAssignment(TScalar)

在张量和标量之间按位执行。

BitwiseOrAssignment(TScalar)

在张量和标量之间按位执行。

BitwiseOrAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行就地位或两个张量。

BitwiseOrAssignment<TScalar>(Tensor<TScalar>, TScalar)

在张量和标量之间按位执行。

BitwiseOrAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行就地位或两个张量。

BitwiseOrAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

在张量和标量之间按位执行。

DecrementAssignment

对张量执行就地递减。

DecrementAssignment

对张量执行就地递减。

DecrementAssignment<TScalar>(Tensor<TScalar>)

对张量执行就地递减。

DecrementAssignment<TScalar>(TensorSpan<TScalar>)

对张量执行就地递减。

Division(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

执行两个张量之间的按元素划分。

Division(ReadOnlyTensorSpan<TScalar>, TScalar)

在张量和标量之间执行按元素划分。

Division(Tensor<TScalar>, Tensor<TScalar>)

执行两个张量之间的按元素划分。

Division(Tensor<TScalar>, TScalar)

在张量和标量之间执行按元素划分。

Division(TensorSpan<TScalar>, TensorSpan<TScalar>)

执行两个张量之间的按元素划分。

Division(TensorSpan<TScalar>, TScalar)

在张量和标量之间执行按元素划分。

Division(TScalar, ReadOnlyTensorSpan<TScalar>)

在张量和标量之间执行按元素划分。

Division(TScalar, Tensor<TScalar>)

在张量和标量之间执行按元素划分。

Division(TScalar, TensorSpan<TScalar>)

在张量和标量之间执行按元素划分。

Division<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

执行两个张量之间的按元素划分。

Division<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

在张量和标量之间执行按元素划分。

Division<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

执行两个张量之间的按元素划分。

Division<TScalar>(Tensor<TScalar>, TScalar)

在张量和标量之间执行按元素划分。

Division<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

执行两个张量之间的按元素划分。

Division<TScalar>(TensorSpan<TScalar>, TScalar)

在张量和标量之间执行按元素划分。

Division<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

在张量和标量之间执行按元素划分。

Division<TScalar>(TScalar, Tensor<TScalar>)

在张量和标量之间执行按元素划分。

Division<TScalar>(TScalar, TensorSpan<TScalar>)

在张量和标量之间执行按元素划分。

DivisionAssignment(ReadOnlyTensorSpan<TScalar>)

执行两个张量之间的就地元素相除。

DivisionAssignment(ReadOnlyTensorSpan<TScalar>)

执行两个张量之间的就地元素相除。

DivisionAssignment(TScalar)

执行张量和标量之间的就地元素划分。

DivisionAssignment(TScalar)

执行张量和标量之间的就地元素划分。

DivisionAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

执行两个张量之间的就地元素相除。

DivisionAssignment<TScalar>(Tensor<TScalar>, TScalar)

执行张量和标量之间的就地元素划分。

DivisionAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

执行两个张量之间的就地元素相除。

DivisionAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

执行张量和标量之间的就地元素划分。

ExclusiveOr(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行独占或介于两个张量之间。

ExclusiveOr(ReadOnlyTensorSpan<TScalar>, TScalar)

执行张量和标量之间的独占或。

ExclusiveOr(Tensor<TScalar>, Tensor<TScalar>)

在两个张量之间执行独占或介于两个张量之间。

ExclusiveOr(Tensor<TScalar>, TScalar)

执行张量和标量之间的独占或。

ExclusiveOr(TensorSpan<TScalar>, TensorSpan<TScalar>)

在两个张量之间执行独占或介于两个张量之间。

ExclusiveOr(TensorSpan<TScalar>, TScalar)

执行张量和标量之间的独占或。

ExclusiveOr(TScalar, ReadOnlyTensorSpan<TScalar>)

执行张量和标量之间的独占或。

ExclusiveOr(TScalar, Tensor<TScalar>)

执行张量和标量之间的独占或。

ExclusiveOr(TScalar, TensorSpan<TScalar>)

执行张量和标量之间的独占或。

ExclusiveOr<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行独占或介于两个张量之间。

ExclusiveOr<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

执行张量和标量之间的独占或。

ExclusiveOr<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

在两个张量之间执行独占或介于两个张量之间。

ExclusiveOr<TScalar>(Tensor<TScalar>, TScalar)

执行张量和标量之间的独占或。

ExclusiveOr<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

在两个张量之间执行独占或介于两个张量之间。

ExclusiveOr<TScalar>(TensorSpan<TScalar>, TScalar)

执行张量和标量之间的独占或。

ExclusiveOr<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

执行张量和标量之间的独占或。

ExclusiveOr<TScalar>(TScalar, Tensor<TScalar>)

执行张量和标量之间的独占或。

ExclusiveOr<TScalar>(TScalar, TensorSpan<TScalar>)

执行张量和标量之间的独占或。

ExclusiveOrAssignment(ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行就地独占或两个张量。

ExclusiveOrAssignment(ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行就地独占或两个张量。

ExclusiveOrAssignment(TScalar)

在张量和标量之间进行就地独占或就地执行。

ExclusiveOrAssignment(TScalar)

在张量和标量之间进行就地独占或就地执行。

ExclusiveOrAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行就地独占或两个张量。

ExclusiveOrAssignment<TScalar>(Tensor<TScalar>, TScalar)

在张量和标量之间进行就地独占或就地执行。

ExclusiveOrAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行就地独占或两个张量。

ExclusiveOrAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

在张量和标量之间进行就地独占或就地执行。

IncrementAssignment

对张量执行就地增量。

IncrementAssignment

对张量执行就地增量。

IncrementAssignment<TScalar>(Tensor<TScalar>)

对张量执行就地增量。

IncrementAssignment<TScalar>(TensorSpan<TScalar>)

对张量执行就地增量。

LeftShift(ReadOnlyTensorSpan<TScalar>, Int32)

对张量执行以元素方式左移。

LeftShift(Tensor<TScalar>, Int32)

对张量执行以元素方式左移。

LeftShift(TensorSpan<TScalar>, Int32)

对张量执行以元素方式左移。

LeftShift<TScalar>(ReadOnlyTensorSpan<TScalar>, Int32)

对张量执行以元素方式左移。

LeftShift<TScalar>(Tensor<TScalar>, Int32)

对张量执行以元素方式左移。

LeftShift<TScalar>(TensorSpan<TScalar>, Int32)

对张量执行以元素方式左移。

LeftShiftAssignment(Int32)

在张量上执行就地元素左移。

LeftShiftAssignment(Int32)

在张量上执行就地元素左移。

LeftShiftAssignment<TScalar>(Tensor<TScalar>, Int32)

在张量上执行就地元素左移。

LeftShiftAssignment<TScalar>(TensorSpan<TScalar>, Int32)

在张量上执行就地元素左移。

MultiplicationAssignment(ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行就地元素乘法。

MultiplicationAssignment(ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行就地元素乘法。

MultiplicationAssignment(TScalar)

在张量和标量之间执行就地元素乘法。

MultiplicationAssignment(TScalar)

在张量和标量之间执行就地元素乘法。

MultiplicationAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行就地元素乘法。

MultiplicationAssignment<TScalar>(Tensor<TScalar>, TScalar)

在张量和标量之间执行就地元素乘法。

MultiplicationAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行就地元素乘法。

MultiplicationAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

在张量和标量之间执行就地元素乘法。

Multiply(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行元素乘法。

Multiply(ReadOnlyTensorSpan<TScalar>, TScalar)

在张量和标量之间执行元素乘法。

Multiply(Tensor<TScalar>, Tensor<TScalar>)

在两个张量之间执行元素乘法。

Multiply(Tensor<TScalar>, TScalar)

在张量和标量之间执行元素乘法。

Multiply(TensorSpan<TScalar>, TensorSpan<TScalar>)

在两个张量之间执行元素乘法。

Multiply(TensorSpan<TScalar>, TScalar)

在张量和标量之间执行元素乘法。

Multiply(TScalar, ReadOnlyTensorSpan<TScalar>)

在张量和标量之间执行元素乘法。

Multiply(TScalar, Tensor<TScalar>)

在张量和标量之间执行元素乘法。

Multiply(TScalar, TensorSpan<TScalar>)

在张量和标量之间执行元素乘法。

Multiply<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行元素乘法。

Multiply<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

在张量和标量之间执行元素乘法。

Multiply<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

在两个张量之间执行元素乘法。

Multiply<TScalar>(Tensor<TScalar>, TScalar)

在张量和标量之间执行元素乘法。

Multiply<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

在两个张量之间执行元素乘法。

Multiply<TScalar>(TensorSpan<TScalar>, TScalar)

在张量和标量之间执行元素乘法。

Multiply<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

在张量和标量之间执行元素乘法。

Multiply<TScalar>(TScalar, Tensor<TScalar>)

在张量和标量之间执行元素乘法。

Multiply<TScalar>(TScalar, TensorSpan<TScalar>)

在张量和标量之间执行元素乘法。

OnesComplement(ReadOnlyTensorSpan<TScalar>)

对张量执行一个补充。

OnesComplement(Tensor<TScalar>)

对张量执行一个补充。

OnesComplement(TensorSpan<TScalar>)

对张量执行一个补充。

OnesComplement<TScalar>(ReadOnlyTensorSpan<TScalar>)

对张量执行一个补充。

OnesComplement<TScalar>(Tensor<TScalar>)

对张量执行一个补充。

OnesComplement<TScalar>(TensorSpan<TScalar>)

对张量执行一个补充。

RightShift(ReadOnlyTensorSpan<TScalar>, Int32)

对张量执行按元素算术右移。

RightShift(Tensor<TScalar>, Int32)

对张量执行按元素算术右移。

RightShift(TensorSpan<TScalar>, Int32)

对张量执行按元素算术右移。

RightShift<TScalar>(ReadOnlyTensorSpan<TScalar>, Int32)

对张量执行按元素算术右移。

RightShift<TScalar>(Tensor<TScalar>, Int32)

对张量执行按元素算术右移。

RightShift<TScalar>(TensorSpan<TScalar>, Int32)

对张量执行按元素算术右移。

RightShiftAssignment(Int32)

对张量执行就地元素算术右移。

RightShiftAssignment(Int32)

对张量执行就地元素算术右移。

RightShiftAssignment<TScalar>(Tensor<TScalar>, Int32)

对张量执行就地元素算术右移。

RightShiftAssignment<TScalar>(TensorSpan<TScalar>, Int32)

对张量执行就地元素算术右移。

Subtraction(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行元素级减法。

Subtraction(ReadOnlyTensorSpan<TScalar>, TScalar)

在张量和标量之间执行元素级减法。

Subtraction(Tensor<TScalar>, Tensor<TScalar>)

在两个张量之间执行元素级减法。

Subtraction(Tensor<TScalar>, TScalar)

在张量和标量之间执行元素级减法。

Subtraction(TensorSpan<TScalar>, TensorSpan<TScalar>)

在两个张量之间执行元素级减法。

Subtraction(TensorSpan<TScalar>, TScalar)

在张量和标量之间执行元素级减法。

Subtraction(TScalar, ReadOnlyTensorSpan<TScalar>)

在张量和标量之间执行元素级减法。

Subtraction(TScalar, Tensor<TScalar>)

在张量和标量之间执行元素级减法。

Subtraction(TScalar, TensorSpan<TScalar>)

在张量和标量之间执行元素级减法。

Subtraction<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

在两个张量之间执行元素级减法。

Subtraction<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

在张量和标量之间执行元素级减法。

Subtraction<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

在两个张量之间执行元素级减法。

Subtraction<TScalar>(Tensor<TScalar>, TScalar)

在张量和标量之间执行元素级减法。

Subtraction<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

在两个张量之间执行元素级减法。

Subtraction<TScalar>(TensorSpan<TScalar>, TScalar)

在张量和标量之间执行元素级减法。

Subtraction<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

在张量和标量之间执行元素级减法。

Subtraction<TScalar>(TScalar, Tensor<TScalar>)

在张量和标量之间执行元素级减法。

Subtraction<TScalar>(TScalar, TensorSpan<TScalar>)

在张量和标量之间执行元素级减法。

SubtractionAssignment(ReadOnlyTensorSpan<TScalar>)

执行两个张量之间的就地元素减法。

SubtractionAssignment(ReadOnlyTensorSpan<TScalar>)

执行两个张量之间的就地元素减法。

SubtractionAssignment(TScalar)

在张量和标量之间执行就地元素减法。

SubtractionAssignment(TScalar)

在张量和标量之间执行就地元素减法。

SubtractionAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

执行两个张量之间的就地元素减法。

SubtractionAssignment<TScalar>(Tensor<TScalar>, TScalar)

在张量和标量之间执行就地元素减法。

SubtractionAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

执行两个张量之间的就地元素减法。

SubtractionAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

在张量和标量之间执行就地元素减法。

UnaryNegation(ReadOnlyTensorSpan<TScalar>)

对张量执行元素一元求反。

UnaryNegation(Tensor<TScalar>)

对张量执行元素一元求反。

UnaryNegation(TensorSpan<TScalar>)

对张量执行元素一元求反。

UnaryNegation<TScalar>(ReadOnlyTensorSpan<TScalar>)

对张量执行元素一元求反。

UnaryNegation<TScalar>(Tensor<TScalar>)

对张量执行元素一元求反。

UnaryNegation<TScalar>(TensorSpan<TScalar>)

对张量执行元素一元求反。

UnaryPlus(ReadOnlyTensorSpan<TScalar>)

对张量执行元素一元加。

UnaryPlus(Tensor<TScalar>)

对张量执行元素一元加。

UnaryPlus(TensorSpan<TScalar>)

对张量执行元素一元加。

UnaryPlus<TScalar>(ReadOnlyTensorSpan<TScalar>)

对张量执行元素一元加。

UnaryPlus<TScalar>(Tensor<TScalar>)

对张量执行元素一元加。

UnaryPlus<TScalar>(TensorSpan<TScalar>)

对张量执行元素一元加。

UnsignedRightShift(ReadOnlyTensorSpan<TScalar>, Int32)

对张量执行按元素的逻辑右移。

UnsignedRightShift(Tensor<TScalar>, Int32)

对张量执行按元素的逻辑右移。

UnsignedRightShift(TensorSpan<TScalar>, Int32)

对张量执行按元素的逻辑右移。

UnsignedRightShift<TScalar>(ReadOnlyTensorSpan<TScalar>, Int32)

对张量执行按元素的逻辑右移。

UnsignedRightShift<TScalar>(Tensor<TScalar>, Int32)

对张量执行按元素的逻辑右移。

UnsignedRightShift<TScalar>(TensorSpan<TScalar>, Int32)

对张量执行按元素的逻辑右移。

UnsignedRightShiftAssignment(Int32)

对张量执行就地按元素的逻辑右移。

UnsignedRightShiftAssignment(Int32)

对张量执行就地按元素的逻辑右移。

UnsignedRightShiftAssignment<TScalar>(Tensor<TScalar>, Int32)

对张量执行就地按元素的逻辑右移。

UnsignedRightShiftAssignment<TScalar>(TensorSpan<TScalar>, Int32)

对张量执行就地按元素的逻辑右移。

适用于