通过

Vector128 类

  • 参考

定义

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

提供静态方法的集合，用于创建、操作和其他操作 128 位向量。

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

属性

IsHardwareAccelerated

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

方法

Abs<T>(Vector128<T>)

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

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

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

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

将 Vector128<T> 重新解释为 Byte类型的新 Vector128。
AsDouble<T>(Vector128<T>)

将 Vector128<T> 重新解释为 Double类型的新 Vector128。
AsInt16<T>(Vector128<T>)

将 Vector128<T> 重新解释为 Int16类型的新 Vector128。
AsInt32<T>(Vector128<T>)

将 Vector128<T> 重新解释为 Int32类型的新 Vector128。
AsInt64<T>(Vector128<T>)

将 Vector128<T> 重新解释为 Int64类型的新 Vector128。
AsNInt<T>(Vector128<T>)

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

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

将 Vector128<T> 重新解释为 SByte类型的新 Vector128。
AsSingle<T>(Vector128<T>)

将 Vector128<T> 重新解释为 Single类型的新 Vector128。
AsUInt16<T>(Vector128<T>)

将 Vector128<T> 重新解释为 UInt16类型的新 Vector128。
AsUInt32<T>(Vector128<T>)

将 Vector128<T> 重新解释为 UInt32类型的新 Vector128。
AsUInt64<T>(Vector128<T>)

将 Vector128<T> 重新解释为 UInt64类型的新 Vector128。
AsVector<T>(Vector128<T>)

将 Vector128<T> 重新解释为新的 Vector<T>。
AsVector128(Vector2)

将 Vector2 重新解释为新的 Vector128<T>。
AsVector128(Vector3)

将 Vector3 重新解释为新的 Vector128<T>。
AsVector128(Vector4)

将 Vector4 重新解释为新的 Vector128<T>。
AsVector128<T>(Vector<T>)

将 Vector<T> 重新解释为新的 Vector128<T>。
AsVector128Unsafe(Vector2)

将 Vector2 重新解释为新的 Vector128<T>，使新元素未定义。
AsVector128Unsafe(Vector3)

将 Vector3 重新解释为新的 Vector128<T>，使新元素未定义。
AsVector2(Vector128<Single>)

将 Vector128<T> 重新解释为新的 Vector2。
AsVector3(Vector128<Single>)

将 Vector128<T> 重新解释为新的 Vector3。
AsVector4(Vector128<Single>)

将 Vector128<T> 重新解释为新的 Vector4。
BitwiseAnd<T>(Vector128<T>, Vector128<T>)

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

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

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

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

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

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

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

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

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

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

将 Vector128<Single> 转换为溢出时 Vector128<Int32> 平台特定行为。
ConvertToInt64(Vector128<Double>)

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

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

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

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

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

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

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

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

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

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

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

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

计算向量中每个元素的 cos。
Cos(Vector128<Single>)

计算向量中每个元素的 cos。
Create(Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte)

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

创建一个新的 Vector128<T> 实例，其中包含初始化为指定值的所有元素。
Create(Double, Double)

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

创建一个新的 Vector128<T> 实例，其中包含初始化为指定值的所有元素。
Create(Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16)

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

创建一个新的 Vector128<T> 实例，其中包含初始化为指定值的所有元素。
Create(Int32, Int32, Int32, Int32)

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

创建一个新的 Vector128<T> 实例，其中包含初始化为指定值的所有元素。
Create(Int64, Int64)

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

创建一个新的 Vector128<T> 实例，其中包含初始化为指定值的所有元素。
Create(IntPtr)

创建一个新的 Vector128<T> 实例，其中包含初始化为指定值的所有元素。
Create(SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte)

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

创建一个新的 Vector128<T> 实例，其中包含初始化为指定值的所有元素。
Create(Single, Single, Single, Single)

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

创建一个新的 Vector128<T> 实例，其中包含初始化为指定值的所有元素。
Create(UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16)

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

创建一个新的 Vector128<T> 实例，其中包含初始化为指定值的所有元素。
Create(UInt32, UInt32, UInt32, UInt32)

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

创建一个新的 Vector128<T> 实例，其中包含初始化为指定值的所有元素。
Create(UInt64, UInt64)

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

创建一个新的 Vector128<T> 实例，其中包含初始化为指定值的所有元素。
Create(UIntPtr)

创建一个新的 Vector128<T> 实例，其中包含初始化为指定值的所有元素。
Create(Vector64<Byte>, Vector64<Byte>)

从两个 Vector64<T> 实例创建新的 Vector128<T> 实例。
Create(Vector64<Double>, Vector64<Double>)

从两个 Vector64<T> 实例创建新的 Vector128<T> 实例。
Create(Vector64<Int16>, Vector64<Int16>)

从两个 Vector64<T> 实例创建新的 Vector128<T> 实例。
Create(Vector64<Int32>, Vector64<Int32>)

从两个 Vector64<T> 实例创建新的 Vector128<T> 实例。
Create(Vector64<Int64>, Vector64<Int64>)

从两个 Vector64<T> 实例创建新的 Vector128<T> 实例。
Create(Vector64<IntPtr>, Vector64<IntPtr>)

从两个 Vector64<T> 实例创建新的 Vector128<T> 实例。
Create(Vector64<SByte>, Vector64<SByte>)

从两个 Vector64<T> 实例创建新的 Vector128<T> 实例。
Create(Vector64<Single>, Vector64<Single>)

从两个 Vector64<T> 实例创建新的 Vector128<T> 实例。
Create(Vector64<UInt16>, Vector64<UInt16>)

从两个 Vector64<T> 实例创建新的 Vector128<T> 实例。
Create(Vector64<UInt32>, Vector64<UInt32>)

从两个 Vector64<T> 实例创建新的 Vector128<T> 实例。
Create(Vector64<UInt64>, Vector64<UInt64>)

从两个 Vector64<T> 实例创建新的 Vector128<T> 实例。
Create(Vector64<UIntPtr>, Vector64<UIntPtr>)

从两个 Vector64<T> 实例创建新的 Vector128<T> 实例。
Create<T>(ReadOnlySpan<T>)

从给定的只读范围创建新的 Vector128<T>。
Create<T>(T)

创建一个新的 Vector128<T> 实例，其中包含初始化为指定值的所有元素。
Create<T>(T[], Int32)

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

从给定数组创建新的 Vector128<T>。
Create<T>(Vector64<T>, Vector64<T>)

从两个 Vector64<T> 实例创建新的 Vector128<T> 实例。
Create<T>(Vector64<T>)

创建一个新的 Vector128<T> 实例，该实例的下限和高 64 位初始化为指定值。
CreateScalar(Byte)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

计算向量中每个元素的 exp。
Exp(Vector128<Single>)

计算向量中每个元素的 exp。
ExtractMostSignificantBits<T>(Vector128<T>)

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

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

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

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

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

获取指定索引处的元素。
GetLower<T>(Vector128<T>)

获取低 64 位作为新 Vector64<T>的值。
GetUpper<T>(Vector128<T>)

获取高 64 位作为新 Vector64<T>的值。
GreaterThan<T>(Vector128<T>, Vector128<T>)

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

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

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

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

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

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

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

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

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

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

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

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

确定向量中的哪些元素为零。
Lerp(Vector128<Double>, Vector128<Double>, Vector128<Double>)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

将两个向量（基于每个元素）与计算进行比较，如果输入 NaN，则计算其数量级更大并返回另一个值。
MaxNative<T>(Vector128<T>, Vector128<T>)

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

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

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

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

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

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

比较两个向量（基于每个元素）计算，如果元素 NaN，则计算该向量更小，并返回另一个值。
Multiply<T>(T, Vector128<T>)

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

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

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

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

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

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

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

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

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

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

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

将两个 Vector128<T> 实例缩小为一个 Vector128<T>。
Negate<T>(Vector128<T>)

否定向量。
OnesComplement<T>(Vector128<T>)

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

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

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

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

提供静态方法的集合，用于创建、操作和其他操作 128 位向量。
Round(Vector128<Single>, MidpointRounding)

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

提供静态方法的集合，用于创建、操作和其他操作 128 位向量。
ShiftLeft(Vector128<Byte>, Int32)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

计算向量中每个元素的罪恶。
Sin(Vector128<Single>)

计算向量中每个元素的罪恶。
SinCos(Vector128<Double>)

计算向量中每个元素的 cos。
SinCos(Vector128<Single>)

计算向量中每个元素的 cos。
Sqrt<T>(Vector128<T>)

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

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

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

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

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

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

减去两个矢量以计算其差异。
Sum<T>(Vector128<T>)

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

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

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

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

提供静态方法的集合，用于创建、操作和其他操作 128 位向量。
Truncate(Vector128<Single>)

提供静态方法的集合，用于创建、操作和其他操作 128 位向量。
TryCopyTo<T>(Vector128<T>, Span<T>)

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

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

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

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

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

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

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

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

将 Vector128<T> 的下半部分扩大为 Vector128<T>。
WidenLower(Vector128<Int16>)

将 Vector128<T> 的下半部分扩大为 Vector128<T>。
WidenLower(Vector128<Int32>)

将 Vector128<T> 的下半部分扩大为 Vector128<T>。
WidenLower(Vector128<SByte>)

将 Vector128<T> 的下半部分扩大为 Vector128<T>。
WidenLower(Vector128<Single>)

将 Vector128<T> 的下半部分扩大为 Vector128<T>。
WidenLower(Vector128<UInt16>)

将 Vector128<T> 的下半部分扩大为 Vector128<T>。
WidenLower(Vector128<UInt32>)

将 Vector128<T> 的下半部分扩大为 Vector128<T>。
WidenUpper(Vector128<Byte>)

将 Vector128<T> 的上半部分扩大为 Vector128<T>。
WidenUpper(Vector128<Int16>)

将 Vector128<T> 的上半部分扩大为 Vector128<T>。
WidenUpper(Vector128<Int32>)

将 Vector128<T> 的上半部分扩大为 Vector128<T>。
WidenUpper(Vector128<SByte>)

将 Vector128<T> 的上半部分扩大为 Vector128<T>。
WidenUpper(Vector128<Single>)

将 Vector128<T> 的上半部分扩大为 Vector128<T>。
WidenUpper(Vector128<UInt16>)

将 Vector128<T> 的上半部分扩大为 Vector128<T>。
WidenUpper(Vector128<UInt32>)

将 Vector128<T> 的上半部分扩大为 Vector128<T>。
WithElement<T>(Vector128<T>, Int32, T)

创建一个新的 Vector128<T>，该元素位于指定索引处设置为指定值，其余元素设置为与给定向量中的相同值。
WithLower<T>(Vector128<T>, Vector64<T>)

创建一个新的 Vector128<T>，将较低的 64 位设置为指定值，并将高 64 位设置为与给定向量中的值相同的值。
WithUpper<T>(Vector128<T>, Vector64<T>)

创建一个新的 Vector128<T>，将高 64 位设置为指定值，将较低的 64 位设置为与给定向量中的值相同的值。
Xor<T>(Vector128<T>, Vector128<T>)

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

适用于