Vector64 类

定义

命名空间:
System.Runtime.Intrinsics
程序集:
System.Runtime.Intrinsics.dll
Source:
Vector64.cs
Source:
Vector64.cs
Source:
Vector64.cs
Source:
Vector64.cs
Source:
Vector64.cs

提供用于创建、操作和其他在 64 位向量上运行的静态方法的集合。

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

属性

名称 说明
E

提供用于创建、操作和其他在 64 位向量上运行的静态方法的集合。
Epsilon

提供用于创建、操作和其他在 64 位向量上运行的静态方法的集合。
IsHardwareAccelerated

获取一个值，该值指示 64 位向量操作是否通过 JIT 内部支持受硬件加速的约束。
NaN

提供用于创建、操作和其他在 64 位向量上运行的静态方法的集合。
NegativeInfinity

提供用于创建、操作和其他在 64 位向量上运行的静态方法的集合。
NegativeOne

提供用于创建、操作和其他在 64 位向量上运行的静态方法的集合。
NegativeZero

提供用于创建、操作和其他在 64 位向量上运行的静态方法的集合。
Pi

提供用于创建、操作和其他在 64 位向量上运行的静态方法的集合。
PositiveInfinity

提供用于创建、操作和其他在 64 位向量上运行的静态方法的集合。
Tau

提供用于创建、操作和其他在 64 位向量上运行的静态方法的集合。

方法

名称 说明
Abs<T>(Vector64<T>)

计算向量中每个元素的绝对值。
Add<T>(Vector64<T>, Vector64<T>)

添加两个向量来计算其总和。
AddSaturate<T>(Vector64<T>, Vector64<T>)

添加两个向量来计算其元素饱和总和。
All<T>(Vector64<T>, T)

确定向量的所有元素是否都等于给定值。
AllWhereAllBitsSet<T>(Vector64<T>)

确定向量的所有元素是否都设置了其所有位。
AndNot<T>(Vector64<T>, Vector64<T>)

计算给定向量和给定向量与另一向量相补的按位计算。
Any<T>(Vector64<T>, T)

确定向量的任何元素是否等于给定值。
AnyWhereAllBitsSet<T>(Vector64<T>)

确定向量的任何元素是否都设置了其所有位。
As<T,U>(Vector64<T>)

将类型的 Vector64<T> 类型 TFrom 重新解释为新 Vector64<T> 类型 TTo。
AsByte<T>(Vector64<T>)

重新解释 Vector64<T> 为新 Vector64 类型 Byte。
AsDouble<T>(Vector64<T>)

重新解释 Vector64<T> 为新 Vector64 类型 Double。
Asin(Vector64<Double>)

提供用于创建、操作和其他在 64 位向量上运行的静态方法的集合。
Asin(Vector64<Single>)

提供用于创建、操作和其他在 64 位向量上运行的静态方法的集合。
AsInt16<T>(Vector64<T>)

重新解释 Vector64<T> 为新 Vector64 类型 Int16。
AsInt32<T>(Vector64<T>)

重新解释 Vector64<T> 为新 Vector64 类型 Int32。
AsInt64<T>(Vector64<T>)

重新解释 Vector64<T> 为新 Vector64 类型 Int64。
AsNInt<T>(Vector64<T>)

重新解释 Vector64<T> 为新的 Vector64<T>。
AsNUInt<T>(Vector64<T>)

重新解释 Vector64<T> 为新的 Vector64<T>。
AsSByte<T>(Vector64<T>)

重新解释 Vector64<T> 为新 Vector64 类型 SByte。
AsSingle<T>(Vector64<T>)

重新解释 Vector64<T> 为新 Vector64 类型 Single。
AsUInt16<T>(Vector64<T>)

重新解释 Vector64<T> 为新 Vector64 类型 UInt16。
AsUInt32<T>(Vector64<T>)

重新解释 Vector64<T> 为新 Vector64 类型 UInt32。
AsUInt64<T>(Vector64<T>)

重新解释 Vector64<T> 为新 Vector64 类型 UInt64。
BitwiseAnd<T>(Vector64<T>, Vector64<T>)

计算两个向量的按位和两个向量。
BitwiseOr<T>(Vector64<T>, Vector64<T>)

计算两个向量的按位或两个向量。
Ceiling(Vector64<Double>)

计算向量中每个元素的上限。
Ceiling(Vector64<Single>)

计算向量中每个元素的上限。
Clamp<T>(Vector64<T>, Vector64<T>, Vector64<T>)

限制最小值和最大值之间的向量。
ClampNative<T>(Vector64<T>, Vector64<T>, Vector64<T>)

使用平台特定的行为NaNNegativeZero来限制最小值和最大值之间的向量。
ConditionalSelect<T>(Vector64<T>, Vector64<T>, Vector64<T>)

按条件从两个向量中按位选择一个值。
ConvertToDouble(Vector64<Int64>)

将 Vector64<T> 转换为 Vector64<T>。
ConvertToDouble(Vector64<UInt64>)

将 Vector64<T> 转换为 Vector64<T>。
ConvertToInt32(Vector64<Single>)

将 Vector64<T> 转换为 Vector64<T>。
ConvertToInt32Native(Vector64<Single>)

在溢出时将 a Vector64<Single> 转换为 Vector64<Int32> 使用平台特定的行为。
ConvertToInt64(Vector64<Double>)

将 Vector64<T> 转换为 Vector64<T>。
ConvertToInt64Native(Vector64<Double>)

在溢出时将 a Vector64<Double> 转换为 Vector64<Int64> 使用平台特定的行为。
ConvertToSingle(Vector64<Int32>)

将 Vector64<T> 转换为 Vector64<T>。
ConvertToSingle(Vector64<UInt32>)

将 Vector64<T> 转换为 Vector64<T>。
ConvertToUInt32(Vector64<Single>)

将 Vector64<T> 转换为 Vector64<T>。
ConvertToUInt32Native(Vector64<Single>)

在溢出时将 a Vector64<Single> 转换为 Vector64<UInt32> 使用平台特定的行为。
ConvertToUInt64(Vector64<Double>)

将 Vector64<T> 转换为 Vector64<T>。
ConvertToUInt64Native(Vector64<Double>)

在溢出时将 a Vector64<Double> 转换为 Vector64<UInt64> 使用平台特定的行为。
CopySign<T>(Vector64<T>, Vector64<T>)

将向量的 per-element 符号复制到另一个向量的 per-element 符号。
CopyTo<T>(Vector64<T>, Span<T>)

将 a Vector64<T> 复制到给定范围。
CopyTo<T>(Vector64<T>, T[], Int32)

从指定索引处开始，将 a Vector64<T> 复制到给定数组。
CopyTo<T>(Vector64<T>, T[])

将 a Vector64<T> 复制到给定数组。
Cos(Vector64<Double>)

计算向量中每个元素的余弦值。
Cos(Vector64<Single>)

计算向量中每个元素的余弦值。
Count<T>(Vector64<T>, T)

确定向量中等于给定值的元素数。
CountWhereAllBitsSet<T>(Vector64<T>)

确定已设置所有位的向量中的元素数。
Create(Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte)

创建一个新 Vector64<T> 实例，其中每个元素初始化为相应的指定值。
Create(Byte)

创建初始化为指定值的所有元素的新 Vector64<T> 实例。
Create(Double)

创建初始化为指定值的所有元素的新 Vector64<T> 实例。
Create(Int16, Int16, Int16, Int16)

创建一个新 Vector64<T> 实例，其中每个元素初始化为相应的指定值。
Create(Int16)

创建初始化为指定值的所有元素的新 Vector64<T> 实例。
Create(Int32, Int32)

创建一个新 Vector64<T> 实例，其中每个元素初始化为相应的指定值。
Create(Int32)

创建初始化为指定值的所有元素的新 Vector64<T> 实例。
Create(Int64)

创建初始化为指定值的所有元素的新 Vector64<T> 实例。
Create(IntPtr)

创建初始化为指定值的所有元素的新 Vector64<T> 实例。
Create(SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte)

创建一个新 Vector64<T> 实例，其中每个元素初始化为相应的指定值。
Create(SByte)

创建初始化为指定值的所有元素的新 Vector64<T> 实例。
Create(Single, Single)

创建一个新 Vector64<T> 实例，其中每个元素初始化为相应的指定值。
Create(Single)

创建初始化为指定值的所有元素的新 Vector64<T> 实例。
Create(UInt16, UInt16, UInt16, UInt16)

创建一个新 Vector64<T> 实例，其中每个元素初始化为相应的指定值。
Create(UInt16)

创建初始化为指定值的所有元素的新 Vector64<T> 实例。
Create(UInt32, UInt32)

创建一个新 Vector64<T> 实例，其中每个元素初始化为相应的指定值。
Create(UInt32)

创建初始化为指定值的所有元素的新 Vector64<T> 实例。
Create(UInt64)

创建初始化为指定值的所有元素的新 Vector64<T> 实例。
Create(UIntPtr)

创建初始化为指定值的所有元素的新 Vector64<T> 实例。
Create<T>(ReadOnlySpan<T>)

从给定的只读跨度创建一个新 Vector64<T> 项。
Create<T>(T)

创建初始化为指定值的所有元素的新 Vector64<T> 实例。
Create<T>(T[], Int32)

Vector64<T>从给定数组创建新项。
Create<T>(T[])

Vector64<T>从给定数组创建新项。
CreateScalar(Byte)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素初始化为零。
CreateScalar(Double)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素初始化为零。
CreateScalar(Int16)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素初始化为零。
CreateScalar(Int32)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素初始化为零。
CreateScalar(Int64)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素初始化为零。
CreateScalar(IntPtr)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素初始化为零。
CreateScalar(SByte)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素初始化为零。
CreateScalar(Single)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素初始化为零。
CreateScalar(UInt16)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素初始化为零。
CreateScalar(UInt32)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素初始化为零。
CreateScalar(UInt64)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素初始化为零。
CreateScalar(UIntPtr)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素初始化为零。
CreateScalar<T>(T)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素初始化为零。
CreateScalarUnsafe(Byte)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素未初始化。
CreateScalarUnsafe(Double)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素未初始化。
CreateScalarUnsafe(Int16)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素未初始化。
CreateScalarUnsafe(Int32)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素未初始化。
CreateScalarUnsafe(Int64)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素未初始化。
CreateScalarUnsafe(IntPtr)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素未初始化。
CreateScalarUnsafe(SByte)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素未初始化。
CreateScalarUnsafe(Single)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素未初始化。
CreateScalarUnsafe(UInt16)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素未初始化。
CreateScalarUnsafe(UInt32)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素未初始化。
CreateScalarUnsafe(UInt64)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素未初始化。
CreateScalarUnsafe(UIntPtr)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素未初始化。
CreateScalarUnsafe<T>(T)

创建一个新 Vector64<T> 实例，其中第一个元素初始化为指定值，其余元素未初始化。
CreateSequence<T>(T, T)

创建一个新 Vector64<T> 实例，其中元素从指定值开始，并按另一个指定值分隔。
DegreesToRadians(Vector64<Double>)

将给定向量从度转换为弧度。
DegreesToRadians(Vector64<Single>)

将给定向量从度转换为弧度。
Divide<T>(Vector64<T>, T)

将矢量除以标量以计算每个元素商。
Divide<T>(Vector64<T>, Vector64<T>)

将两个向量除以计算其商。
Dot<T>(Vector64<T>, Vector64<T>)

计算两个向量的点积。
Equals<T>(Vector64<T>, Vector64<T>)

比较两个向量，以确定它们是否基于每个元素相等。
EqualsAll<T>(Vector64<T>, Vector64<T>)

比较两个向量以确定所有元素是否相等。
EqualsAny<T>(Vector64<T>, Vector64<T>)

比较两个向量，以确定任何元素是否相等。
Exp(Vector64<Double>)

计算向量中每个元素的指数。
Exp(Vector64<Single>)

计算向量中每个元素的指数。
ExtractMostSignificantBits<T>(Vector64<T>)

从向量中的每个元素中提取最重要的位。
Floor(Vector64<Double>)

计算向量中每个元素的下限。
Floor(Vector64<Single>)

计算向量中每个元素的下限。
FusedMultiplyAdd(Vector64<Double>, Vector64<Double>, Vector64<Double>)

计算 （left * right） + addend，舍入为一个三元运算。
FusedMultiplyAdd(Vector64<Single>, Vector64<Single>, Vector64<Single>)

计算 （left * right） + addend，舍入为一个三元运算。
get_E<T>()

提供用于创建、操作和其他在 64 位向量上运行的静态方法的集合。
get_Epsilon<T>()

提供用于创建、操作和其他在 64 位向量上运行的静态方法的集合。
get_NaN<T>()

提供用于创建、操作和其他在 64 位向量上运行的静态方法的集合。
get_NegativeInfinity<T>()

提供用于创建、操作和其他在 64 位向量上运行的静态方法的集合。
get_NegativeOne<T>()

提供用于创建、操作和其他在 64 位向量上运行的静态方法的集合。
get_NegativeZero<T>()

提供用于创建、操作和其他在 64 位向量上运行的静态方法的集合。
get_Pi<T>()

提供用于创建、操作和其他在 64 位向量上运行的静态方法的集合。
get_PositiveInfinity<T>()

提供用于创建、操作和其他在 64 位向量上运行的静态方法的集合。
get_Tau<T>()

提供用于创建、操作和其他在 64 位向量上运行的静态方法的集合。
GetElement<T>(Vector64<T>, Int32)

获取指定索引处的元素。
GreaterThan<T>(Vector64<T>, Vector64<T>)

比较两个向量，以确定每个元素的哪一个矢量更大。
GreaterThanAll<T>(Vector64<T>, Vector64<T>)

比较两个向量，以确定所有元素是否都更大。
GreaterThanAny<T>(Vector64<T>, Vector64<T>)

比较两个向量，以确定任何元素是否更大。
GreaterThanOrEqual<T>(Vector64<T>, Vector64<T>)

比较两个向量，以确定每个元素的更大或相等。
GreaterThanOrEqualAll<T>(Vector64<T>, Vector64<T>)

比较两个向量，以确定所有元素是否都更大或相等。
GreaterThanOrEqualAny<T>(Vector64<T>, Vector64<T>)

比较两个向量，以确定任何元素是否更大或相等。
Hypot(Vector64<Double>, Vector64<Double>)

计算给定的两个向量（表示右角三角形中较短边的长度）的虚构。
Hypot(Vector64<Single>, Vector64<Single>)

计算给定的两个向量（表示右角三角形中较短边的长度）的虚构。
IndexOf<T>(Vector64<T>, T)

确定向量中与给定值相等的第一个元素的索引。
IndexOfWhereAllBitsSet<T>(Vector64<T>)

确定已设置所有位的向量中第一个元素的索引。
IsEvenInteger<T>(Vector64<T>)

确定向量中的哪些元素甚至是整型值。
IsFinite<T>(Vector64<T>)

确定向量中的哪些元素是有限的。
IsInfinity<T>(Vector64<T>)

确定向量中的哪些元素是无穷大。
IsInteger<T>(Vector64<T>)

确定向量中的哪些元素是整型值。
IsNaN<T>(Vector64<T>)

确定向量中的哪些元素为 NaN。
IsNegative<T>(Vector64<T>)

确定向量中的哪些元素表示负实数。
IsNegativeInfinity<T>(Vector64<T>)

确定向量中的哪些元素是负无穷大。
IsNormal<T>(Vector64<T>)

确定向量中的哪些元素是正常的。
IsOddInteger<T>(Vector64<T>)

确定向量中的哪些元素是奇数整数值。
IsPositive<T>(Vector64<T>)

确定向量中的哪些元素表示正实数。
IsPositiveInfinity<T>(Vector64<T>)

确定向量中的哪些元素是正无穷大。
IsSubnormal<T>(Vector64<T>)

确定向量中的哪些元素是非正常元素。
IsZero<T>(Vector64<T>)

确定向量中的哪些元素为零。
LastIndexOf<T>(Vector64<T>, T)

确定向量中最后一个与给定值相等的元素的索引。
LastIndexOfWhereAllBitsSet<T>(Vector64<T>)

确定已设置所有位的向量中最后一个元素的索引。
Lerp(Vector64<Double>, Vector64<Double>, Vector64<Double>)

根据给定权重在两个向量之间执行线性内插。
Lerp(Vector64<Single>, Vector64<Single>, Vector64<Single>)

根据给定权重在两个向量之间执行线性内插。
LessThan<T>(Vector64<T>, Vector64<T>)

比较两个向量，以确定每个元素的相对较少。
LessThanAll<T>(Vector64<T>, Vector64<T>)

比较两个向量，以确定所有元素是否更少。
LessThanAny<T>(Vector64<T>, Vector64<T>)

比较两个向量，以确定任何元素是否更少。
LessThanOrEqual<T>(Vector64<T>, Vector64<T>)

比较两个向量，以确定每个元素上的哪一个矢量小于或等于。
LessThanOrEqualAll<T>(Vector64<T>, Vector64<T>)

比较两个向量，以确定所有元素是否小于或相等。
LessThanOrEqualAny<T>(Vector64<T>, Vector64<T>)

比较两个向量，以确定任何元素是否小于或相等。
Load<T>(T*)

从给定源加载向量。
LoadAligned<T>(T*)

从给定的对齐源加载向量。
LoadAlignedNonTemporal<T>(T*)

从给定的对齐源加载向量。
LoadUnsafe<T>(T, UIntPtr)

从给定的源和元素偏移量加载向量。
LoadUnsafe<T>(T)

从给定源加载向量。
Log(Vector64<Double>)

计算向量中每个元素的日志。
Log(Vector64<Single>)

计算向量中每个元素的日志。
Log2(Vector64<Double>)

计算向量中每个元素的 log2。
Log2(Vector64<Single>)

计算向量中每个元素的 log2。
Max<T>(Vector64<T>, Vector64<T>)

计算每个元素的最大两个向量。
MaxMagnitude<T>(Vector64<T>, Vector64<T>)

将两个向量与计算进行比较，每个元素具有更大的数量级。
MaxMagnitudeNumber<T>(Vector64<T>, Vector64<T>)

将两个向量（基于每个元素）与具有更大数量级的计算进行比较，并在输入为 NaN时返回另一个值。
MaxNative<T>(Vector64<T>, Vector64<T>)

比较两个向量，以确定每个元素使用特定于平台的行为 NaN 和 NegativeZero。
MaxNumber<T>(Vector64<T>, Vector64<T>)

将两个向量（基于每个元素）与计算结果进行比较，如果元素 NaN是，则返回另一个值。
Min<T>(Vector64<T>, Vector64<T>)

基于每个元素计算两个向量中的最小值。
MinMagnitude<T>(Vector64<T>, Vector64<T>)

将两个向量与计算进行比较，每个元素的量级较小。
MinMagnitudeNumber<T>(Vector64<T>, Vector64<T>)

将两个向量（基于每个元素）与计算（如果输入 NaN为）相比较，其数量级较小，并返回另一个值。
MinNative<T>(Vector64<T>, Vector64<T>)

比较两个向量，以确定每个元素使用特定于平台的行为 NaN 和 NegativeZero。
MinNumber<T>(Vector64<T>, Vector64<T>)

将两个向量（基于每个元素）与计算结果进行比较，如果元素 NaN是，则返回另一个值。
Multiply<T>(T, Vector64<T>)

将矢量乘以标量来计算其产品。
Multiply<T>(Vector64<T>, T)

将矢量乘以标量来计算其产品。
Multiply<T>(Vector64<T>, Vector64<T>)

将两个向量相乘以计算其元素乘积。
MultiplyAddEstimate(Vector64<Double>, Vector64<Double>, Vector64<Double>)

计算估计值 （left * right） + 。 addend
MultiplyAddEstimate(Vector64<Single>, Vector64<Single>, Vector64<Single>)

计算估计值 （left * right） + 。 addend
Narrow(Vector64<Double>, Vector64<Double>)

将两 Vector64<T> 个实例缩小为一个 Vector64<T>实例。
Narrow(Vector64<Int16>, Vector64<Int16>)

将两 Vector64<T> 个实例缩小为一个 Vector64<T>实例。
Narrow(Vector64<Int32>, Vector64<Int32>)

将两 Vector64<T> 个实例缩小为一个 Vector64<T>实例。
Narrow(Vector64<Int64>, Vector64<Int64>)

将两 Vector64<T> 个实例缩小为一个 Vector64<T>实例。
Narrow(Vector64<UInt16>, Vector64<UInt16>)

将两 Vector64<T> 个实例缩小为一个 Vector64<T>实例。
Narrow(Vector64<UInt32>, Vector64<UInt32>)

将两 Vector64<T> 个实例缩小为一个 Vector64<T>实例。
Narrow(Vector64<UInt64>, Vector64<UInt64>)

将两 Vector64<T> 个实例缩小为一个 Vector64<T>实例。
NarrowWithSaturation(Vector64<Double>, Vector64<Double>)

将两个 Double 实例向量缩小为一个使用饱和转换的 Single 向量。
NarrowWithSaturation(Vector64<Int16>, Vector64<Int16>)

将两个 Int16 实例向量缩小为一个使用饱和转换的 SByte 向量。
NarrowWithSaturation(Vector64<Int32>, Vector64<Int32>)

将两个 Int32 实例向量缩小为一个使用饱和转换的 Int16 向量。
NarrowWithSaturation(Vector64<Int64>, Vector64<Int64>)

将两个 Int64 实例向量缩小为一个使用饱和转换的 Int32 向量。
NarrowWithSaturation(Vector64<UInt16>, Vector64<UInt16>)

将两个 UInt16 实例向量缩小为一个使用饱和转换的 Byte 向量。
NarrowWithSaturation(Vector64<UInt32>, Vector64<UInt32>)

将两个 UInt32 实例向量缩小为一个使用饱和转换的 UInt16 向量。
NarrowWithSaturation(Vector64<UInt64>, Vector64<UInt64>)

将两个 UInt64 实例向量缩小为一个使用饱和转换的 UInt32 向量。
Negate<T>(Vector64<T>)

否定向量。
None<T>(Vector64<T>, T)

确定向量中没有元素是否等于给定值。
NoneWhereAllBitsSet<T>(Vector64<T>)

确定矢量的元素是否设置了所有位。
OnesComplement<T>(Vector64<T>)

计算矢量的补数。
RadiansToDegrees(Vector64<Double>)

将给定向量从弧度转换为度。
RadiansToDegrees(Vector64<Single>)

将给定向量从弧度转换为度。
Round(Vector64<Double>, MidpointRounding)

使用指定的舍入模式将向量中的每个元素舍入到最接近的整数。
Round(Vector64<Double>)

使用默认舍入模式将向量中的每个元素舍入到最接近的整数（ToEven）。
Round(Vector64<Single>, MidpointRounding)

使用指定的舍入模式将向量中的每个元素舍入到最接近的整数。
Round(Vector64<Single>)

使用默认舍入模式将向量中的每个元素舍入到最接近的整数（ToEven）。
ShiftLeft(Vector64<Byte>, Int32)

将向量的每个元素左移指定量。
ShiftLeft(Vector64<Int16>, Int32)

将向量的每个元素左移指定量。
ShiftLeft(Vector64<Int32>, Int32)

将向量的每个元素左移指定量。
ShiftLeft(Vector64<Int64>, Int32)

将向量的每个元素左移指定量。
ShiftLeft(Vector64<IntPtr>, Int32)

将向量的每个元素左移指定量。
ShiftLeft(Vector64<SByte>, Int32)

将向量的每个元素左移指定量。
ShiftLeft(Vector64<UInt16>, Int32)

将向量的每个元素左移指定量。
ShiftLeft(Vector64<UInt32>, Int32)

将向量的每个元素左移指定量。
ShiftLeft(Vector64<UInt64>, Int32)

将向量的每个元素左移指定量。
ShiftLeft(Vector64<UIntPtr>, Int32)

将向量的每个元素左移指定量。
ShiftRightArithmetic(Vector64<Int16>, Int32)

按指定量向量向右移动 （signed） 的每个元素。
ShiftRightArithmetic(Vector64<Int32>, Int32)

按指定量向量向右移动 （signed） 的每个元素。
ShiftRightArithmetic(Vector64<Int64>, Int32)

按指定量向量向右移动 （signed） 的每个元素。
ShiftRightArithmetic(Vector64<IntPtr>, Int32)

按指定量向量向右移动 （signed） 的每个元素。
ShiftRightArithmetic(Vector64<SByte>, Int32)

按指定量向量向右移动 （signed） 的每个元素。
ShiftRightLogical(Vector64<Byte>, Int32)

按指定量向量向右移动（无符号）的每个元素。
ShiftRightLogical(Vector64<Int16>, Int32)

按指定量向量向右移动（无符号）的每个元素。
ShiftRightLogical(Vector64<Int32>, Int32)

按指定量向量向右移动（无符号）的每个元素。
ShiftRightLogical(Vector64<Int64>, Int32)

按指定量向量向右移动（无符号）的每个元素。
ShiftRightLogical(Vector64<IntPtr>, Int32)

按指定量向量向右移动（无符号）的每个元素。
ShiftRightLogical(Vector64<SByte>, Int32)

按指定量向量向右移动（无符号）的每个元素。
ShiftRightLogical(Vector64<UInt16>, Int32)

按指定量向量向右移动（无符号）的每个元素。
ShiftRightLogical(Vector64<UInt32>, Int32)

按指定量向量向右移动（无符号）的每个元素。
ShiftRightLogical(Vector64<UInt64>, Int32)

按指定量向量向右移动（无符号）的每个元素。
ShiftRightLogical(Vector64<UIntPtr>, Int32)

按指定量向量向右移动（无符号）的每个元素。
Shuffle(Vector64<Byte>, Vector64<Byte>)

通过使用一组索引从输入向量中选择值来创建一个新向量。
Shuffle(Vector64<Int16>, Vector64<Int16>)

通过使用一组索引从输入向量中选择值来创建一个新向量。
Shuffle(Vector64<Int32>, Vector64<Int32>)

通过使用一组索引从输入向量中选择值来创建一个新向量。
Shuffle(Vector64<SByte>, Vector64<SByte>)

通过使用一组索引从输入向量中选择值来创建一个新向量。
Shuffle(Vector64<Single>, Vector64<Int32>)

通过使用一组索引从输入向量中选择值来创建一个新向量。
Shuffle(Vector64<UInt16>, Vector64<UInt16>)

通过使用一组索引从输入向量中选择值来创建一个新向量。
Shuffle(Vector64<UInt32>, Vector64<UInt32>)

通过使用一组索引从输入向量中选择值来创建一个新向量。
ShuffleNative(Vector64<Byte>, Vector64<Byte>)

通过使用一组索引从输入向量中选择值来创建一个新向量。

对于范围外索引，行为依赖于平台。
ShuffleNative(Vector64<Int16>, Vector64<Int16>)

通过使用一组索引从输入向量中选择值来创建一个新向量。
ShuffleNative(Vector64<Int32>, Vector64<Int32>)

通过使用一组索引从输入向量中选择值来创建一个新向量。
ShuffleNative(Vector64<SByte>, Vector64<SByte>)

通过使用一组索引从输入向量中选择值来创建一个新向量。

对于范围外索引，行为依赖于平台。
ShuffleNative(Vector64<Single>, Vector64<Int32>)

通过使用一组索引从输入向量中选择值来创建一个新向量。
ShuffleNative(Vector64<UInt16>, Vector64<UInt16>)

通过使用一组索引从输入向量中选择值来创建一个新向量。
ShuffleNative(Vector64<UInt32>, Vector64<UInt32>)

通过使用一组索引从输入向量中选择值来创建一个新向量。
Sin(Vector64<Double>)

计算向量中每个元素的正弦值。
Sin(Vector64<Single>)

计算向量中每个元素的正弦值。
SinCos(Vector64<Double>)

计算向量中每个元素的正弦值和余弦值。
SinCos(Vector64<Single>)

计算向量中每个元素的正弦值和余弦值。
Sqrt<T>(Vector64<T>)

基于每个元素计算矢量的平方根。
Store<T>(Vector64<T>, T*)

将向量存储在给定的目标处。
StoreAligned<T>(Vector64<T>, T*)

将矢量存储在给定的对齐目标处。
StoreAlignedNonTemporal<T>(Vector64<T>, T*)

将矢量存储在给定的对齐目标处。
StoreUnsafe<T>(Vector64<T>, T, UIntPtr)

将向量存储在给定的目标处。
StoreUnsafe<T>(Vector64<T>, T)

将向量存储在给定的目标处。
Subtract<T>(Vector64<T>, Vector64<T>)

减去两个矢量以计算其差异。
SubtractSaturate<T>(Vector64<T>, Vector64<T>)

减去两个向量以计算其元素饱和差。
Sum<T>(Vector64<T>)

计算向量中所有元素的总和。
ToScalar<T>(Vector64<T>)

将给定向量转换为包含第一个元素值的标量。
ToVector128<T>(Vector64<T>)

将给定向量转换为 Vector128<T> 新向量，将较低的 64 位设置为给定向量的值，并将高 64 位初始化为零。
ToVector128Unsafe<T>(Vector64<T>)

将给定向量转换为 Vector128<T> 新向量，将较低的 64 位设置为给定向量的值，而高 64 位则未初始化。
Truncate(Vector64<Double>)

截断向量中的每个元素。
Truncate(Vector64<Single>)

截断向量中的每个元素。
TryCopyTo<T>(Vector64<T>, Span<T>)

尝试将 a Vector<T> 复制到给定范围。
Widen(Vector64<Byte>)

将一个 Vector64<T> 扩大为两 Vector64<T>个。
Widen(Vector64<Int16>)

将一个 Vector64<T> 扩大为两 Vector64<T>个。
Widen(Vector64<Int32>)

将一个 Vector64<T> 扩大为两 Vector64<T>个。
Widen(Vector64<SByte>)

将一个 Vector64<T> 扩大为两 Vector64<T>个。
Widen(Vector64<Single>)

将一个 Vector64<T> 扩大为两 Vector64<T>个。
Widen(Vector64<UInt16>)

将一个 Vector64<T> 扩大为两 Vector64<T>个。
Widen(Vector64<UInt32>)

将一个 Vector64<T> 扩大为两 Vector64<T>个。
WidenLower(Vector64<Byte>)

将下 Vector64<T> 半部分扩大为一个 Vector64<T>。
WidenLower(Vector64<Int16>)

将下 Vector64<T> 半部分扩大为一个 Vector64<T>。
WidenLower(Vector64<Int32>)

将下 Vector64<T> 半部分扩大为一个 Vector64<T>。
WidenLower(Vector64<SByte>)

将下 Vector64<T> 半部分扩大为一个 Vector64<T>。
WidenLower(Vector64<Single>)

将下 Vector64<T> 半部分扩大为一个 Vector64<T>。
WidenLower(Vector64<UInt16>)

将下 Vector64<T> 半部分扩大为一个 Vector64<T>。
WidenLower(Vector64<UInt32>)

将下 Vector64<T> 半部分扩大为一个 Vector64<T>。
WidenUpper(Vector64<Byte>)

将上 Vector64<T> 半部分扩大为一个 Vector64<T>。
WidenUpper(Vector64<Int16>)

将上 Vector64<T> 半部分扩大为一个 Vector64<T>。
WidenUpper(Vector64<Int32>)

将上 Vector64<T> 半部分扩大为一个 Vector64<T>。
WidenUpper(Vector64<SByte>)

将上 Vector64<T> 半部分扩大为一个 Vector64<T>。
WidenUpper(Vector64<Single>)

将上 Vector64<T> 半部分扩大为一个 Vector64<T>。
WidenUpper(Vector64<UInt16>)

将上 Vector64<T> 半部分扩大为一个 Vector64<T>。
WidenUpper(Vector64<UInt32>)

将上 Vector64<T> 半部分扩大为一个 Vector64<T>。
WithElement<T>(Vector64<T>, Int32, T)

Vector64<T>使用指定索引处的元素设置为指定值，其余元素设置为与给定向量中的元素相同的值。
Xor<T>(Vector64<T>, Vector64<T>)

计算两个向量的独占或两个向量。

适用于