|
Abs<T>(Vector<T>)
|
返回一个新向量，其元素是给定向量元素的绝对值。
|
|
Add<T>(Vector<T>, Vector<T>)
|
返回一个新向量，其值是两个给定向量中每对元素的总和。
|
|
AndNot<T>(Vector<T>, Vector<T>)
|
通过对两个向量中的每个对应元素对执行按位且不运算来返回一个新向量。
|
|
As<TFrom,TTo>(Vector<TFrom>)
|
将 Vector<T> 重新解释为新的 Vector<T>。
|
|
AsPlane(Vector4)
|
将 Vector4 重新解释为新的 Plane。
|
|
AsQuaternion(Vector4)
|
将 Vector4 重新解释为新的 Quaternion。
|
|
AsVector2(Vector4)
|
将 Vector4 重新解释为新的 Vector2。
|
|
AsVector3(Vector4)
|
将 Vector4 重新解释为新的 Vector3。
|
|
AsVector4(Plane)
|
将 Plane 重新解释为新的 Vector4。
|
|
AsVector4(Quaternion)
|
将 Quaternion 重新解释为新的 Vector4。
|
|
AsVector4(Vector2)
|
使用零零的新元素重新解释对新 Vector4 的 Vector2。
|
|
AsVector4(Vector3)
|
将 Vector3 转换为具有零新元素的新 Vector4。
|
|
AsVector4Unsafe(Vector2)
|
使用未定义的新元素重新解释对新 Vector4 的 Vector2。
|
|
AsVector4Unsafe(Vector3)
|
使用未定义的新元素将 Vector3 转换为新的 Vector4。
|
|
AsVectorByte<T>(Vector<T>)
|
将指定向量的位重新解释为无符号字节矢量的位。
|
|
AsVectorDouble<T>(Vector<T>)
|
将指定向量的位重新解释为双精度浮点向量。
|
|
AsVectorInt16<T>(Vector<T>)
|
将指定向量的位重新解释为 16 位整数的向量。
|
|
AsVectorInt32<T>(Vector<T>)
|
将指定向量的位重新解释为整数向量。
|
|
AsVectorInt64<T>(Vector<T>)
|
将指定向量的位重新解释为长整数向量中的位。
|
|
AsVectorNInt<T>(Vector<T>)
|
将指定向量的位重新解释为本机大小的整数矢量的位。
|
|
AsVectorNUInt<T>(Vector<T>)
|
将指定向量的位重新解释为本机大小的无符号整数矢量的位。
|
|
AsVectorSByte<T>(Vector<T>)
|
将指定向量的位重新解释为带符号字节矢量的位。
|
|
AsVectorSingle<T>(Vector<T>)
|
将指定向量的位重新解释为单精度浮点向量。
|
|
AsVectorUInt16<T>(Vector<T>)
|
将指定向量的位重新解释为无符号 16 位整数的向量。
|
|
AsVectorUInt32<T>(Vector<T>)
|
将指定向量的位重新解释为无符号整数矢量的位。
|
|
AsVectorUInt64<T>(Vector<T>)
|
将指定向量的位重新解释为无符号长整数矢量的位。
|
|
BitwiseAnd<T>(Vector<T>, Vector<T>)
|
通过对两个向量中的每个元素对执行按位 And 运算来返回新向量。
|
|
BitwiseOr<T>(Vector<T>, Vector<T>)
|
通过对两个向量中的每个元素对执行按位 Or 运算来返回新向量。
|
|
Ceiling(Vector<Double>)
|
返回一个新向量，其元素是大于或等于给定向量元素的最小整型值。
|
|
Ceiling(Vector<Single>)
|
返回一个新向量，其元素是大于或等于给定向量元素的最小整型值。
|
|
Clamp<T>(Vector<T>, Vector<T>, Vector<T>)
|
限制最小值和最大值之间的向量。
|
|
ClampNative<T>(Vector<T>, Vector<T>, Vector<T>)
|
使用 NaN 和 NegativeZero.的平台特定行为限制最小值和最大值之间的向量。
|
|
ConditionalSelect(Vector<Int32>, Vector<Single>, Vector<Single>)
|
创建一个新的单精度向量，其中包含基于整型掩码向量在两个指定单精度源向量之间进行选择的元素。
|
|
ConditionalSelect(Vector<Int64>, Vector<Double>, Vector<Double>)
|
创建一个新的双精度向量，其中包含基于整型掩码向量在两个指定的双精度源向量之间选择的元素。
|
|
ConditionalSelect<T>(Vector<T>, Vector<T>, Vector<T>)
|
创建指定类型的新向量，其中基于整型掩码向量在相同类型的两个指定源向量之间选择的元素。
|
|
ConvertToDouble(Vector<Int64>)
|
将 Vector<Int64> 转换为 Vector<Double>。
|
|
ConvertToDouble(Vector<UInt64>)
|
将 Vector<UInt64> 转换为 Vector<Double>。
|
|
ConvertToInt32(Vector<Single>)
|
将 Vector<Single> 转换为 Vector<Int32>。
|
|
ConvertToInt32Native(Vector<Single>)
|
使用特定于平台的行为在溢出时将 Vector<T> 转换为 Vector<T>。
|
|
ConvertToInt64(Vector<Double>)
|
将 Vector<Double> 转换为 Vector<Int64>。
|
|
ConvertToInt64Native(Vector<Double>)
|
使用特定于平台的行为在溢出时将 System.Numerics.Vector<System.Double> 转换为 System.Numerics.Vector<System.Int64>。
|
|
ConvertToSingle(Vector<Int32>)
|
将 Vector<Int32> 转换为 Vector<Single>。
|
|
ConvertToSingle(Vector<UInt32>)
|
将 Vector<UInt32> 转换为 Vector<Single>。
|
|
ConvertToUInt32(Vector<Single>)
|
将 Vector<Single> 转换为 Vector<UInt32>。
|
|
ConvertToUInt32Native(Vector<Single>)
|
使用特定于平台的行为在溢出时将 System.Numerics.Vector<System.Single> 转换为 System.Numerics.Vector<System.UInt32>。
|
|
ConvertToUInt64(Vector<Double>)
|
将 Vector<Double> 转换为 Vector<UInt64>。
|
|
ConvertToUInt64Native(Vector<Double>)
|
使用特定于平台的行为在溢出时将 System.Numerics.Vector<System.Double> 转换为 System.Numerics.Vector<System.UInt64>。
|
|
CopySign<T>(Vector<T>, Vector<T>)
|
将向量的 per-element 符号复制到另一个向量的 per-element 符号。
|
|
Cos(Vector<Double>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
Cos(Vector<Single>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
Create<T>(ReadOnlySpan<T>)
|
从给定的只读范围创建新的 Vector<T>。
|
|
Create<T>(T)
|
创建一个新的 Vector<T> 实例，其中包含初始化为指定值的所有元素。
|
|
CreateSequence<T>(T, T)
|
创建一个新的 Vector<T> 实例，其中元素从指定值开始，并按另一个指定值分隔。
|
|
DegreesToRadians(Vector<Double>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
DegreesToRadians(Vector<Single>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
Divide<T>(Vector<T>, T)
|
将矢量除以标量以计算每个元素商。
|
|
Divide<T>(Vector<T>, Vector<T>)
|
返回一个新向量，其值是将第一个向量元素除以第二个向量中的相应元素的结果。
|
|
Dot<T>(Vector<T>, Vector<T>)
|
返回两个向量的点积。
|
|
Equals(Vector<Double>, Vector<Double>)
|
返回一个新的整型向量，其元素指示两个指定双精度向量中的元素是否相等。
|
|
Equals(Vector<Int32>, Vector<Int32>)
|
返回一个新的整型向量，其元素指示两个指定整型向量中的元素是否相等。
|
|
Equals(Vector<Int64>, Vector<Int64>)
|
返回一个新向量，其元素指示两个指定长整数向量中的元素是否相等。
|
|
Equals(Vector<Single>, Vector<Single>)
|
返回一个新的整型向量，其元素指示两个指定单精度向量中的元素是否相等。
|
|
Equals<T>(Vector<T>, Vector<T>)
|
返回指定类型的新向量，其元素指示同一类型的两个指定向量中的元素是否相等。
|
|
EqualsAll<T>(Vector<T>, Vector<T>)
|
返回一个值，该值指示给定向量中的每个元素对是否相等。
|
|
EqualsAny<T>(Vector<T>, Vector<T>)
|
返回一个值，该值指示给定向量中的任何一对元素是否相等。
|
|
Exp(Vector<Double>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
Exp(Vector<Single>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
Floor(Vector<Double>)
|
返回一个新向量，其元素是小于或等于给定向量元素的最大整型值。
|
|
Floor(Vector<Single>)
|
返回一个新向量，其元素是小于或等于给定向量元素的最大整型值。
|
|
FusedMultiplyAdd(Vector<Double>, Vector<Double>, Vector<Double>)
|
计算 （left * right） + addend，舍入为一个三元运算。
|
|
FusedMultiplyAdd(Vector<Single>, Vector<Single>, Vector<Single>)
|
计算 （left * right） + addend，舍入为一个三元运算。
|
|
GetElement<T>(Vector<T>, Int32)
|
获取指定索引处的元素。
|
|
GreaterThan(Vector<Double>, Vector<Double>)
|
返回一个新的整型向量，其元素指示一个双精度浮点向量中的元素是否大于第二个双精度浮点向量中的相应元素。
|
|
GreaterThan(Vector<Int32>, Vector<Int32>)
|
返回一个新的整型向量，其元素指示一个整型向量中的元素是否大于第二个整型向量中的相应元素。
|
|
GreaterThan(Vector<Int64>, Vector<Int64>)
|
返回一个新的长整数向量，其元素指示一个长整数向量中的元素是否大于第二个长整数向量中的相应元素。
|
|
GreaterThan(Vector<Single>, Vector<Single>)
|
返回一个新的整型向量，其元素指示一个单精度浮点向量中的元素是否大于第二个单精度浮点向量中的相应元素。
|
|
GreaterThan<T>(Vector<T>, Vector<T>)
|
返回一个新向量，其元素指示指定类型的一个向量中的元素是否大于同一时间第二个向量中的相应元素。
|
|
GreaterThanAll<T>(Vector<T>, Vector<T>)
|
返回一个值，该值指示第一个向量中的所有元素是否大于第二个向量中的相应元素。
|
|
GreaterThanAny<T>(Vector<T>, Vector<T>)
|
返回一个值，该值指示第一个向量中的任何元素是否大于第二个向量中的相应元素。
|
|
GreaterThanOrEqual(Vector<Double>, Vector<Double>)
|
返回一个新的整型向量，其元素指示一个向量中的元素是否大于或等于第二个双精度浮点向量中的相应元素。
|
|
GreaterThanOrEqual(Vector<Int32>, Vector<Int32>)
|
返回一个新的整型向量，其元素指示一个整型向量的元素是否大于或等于第二个整型向量中的相应元素。
|
|
GreaterThanOrEqual(Vector<Int64>, Vector<Int64>)
|
返回一个新的长整数向量，其元素指示一个长整数向量中的元素是否大于或等于其第二个长整数向量中的相应元素。
|
|
GreaterThanOrEqual(Vector<Single>, Vector<Single>)
|
返回一个新的整型向量，其元素指示一个向量中的元素是否大于或等于其单精度浮点第二向量中的相应元素。
|
|
GreaterThanOrEqual<T>(Vector<T>, Vector<T>)
|
返回一个新向量，其元素指示指定类型的一个向量中的元素是否大于或等于同一类型的第二个向量中的相应元素。
|
|
GreaterThanOrEqualAll<T>(Vector<T>, Vector<T>)
|
返回一个值，该值指示第一个向量中的所有元素是否大于或等于第二个向量中的所有相应元素。
|
|
GreaterThanOrEqualAny<T>(Vector<T>, Vector<T>)
|
返回一个值，该值指示第一个向量中的任何元素是否大于或等于第二个向量中的相应元素。
|
|
Hypot(Vector<Double>, Vector<Double>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
Hypot(Vector<Single>, Vector<Single>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
IsNaN<T>(Vector<T>)
|
确定向量中的哪些元素为 NaN。
|
|
IsNegative<T>(Vector<T>)
|
确定向量中的哪些元素表示负实数。
|
|
IsPositive<T>(Vector<T>)
|
确定向量中的哪些元素表示正实数。
|
|
IsPositiveInfinity<T>(Vector<T>)
|
确定向量中的哪些元素是正无穷大。
|
|
IsZero<T>(Vector<T>)
|
确定向量中的哪些元素为零。
|
|
Lerp(Vector<Double>, Vector<Double>, Vector<Double>)
|
根据给定权重在两个向量之间执行线性内插。
|
|
Lerp(Vector<Single>, Vector<Single>, Vector<Single>)
|
根据给定权重在两个向量之间执行线性内插。
|
|
LessThan(Vector<Double>, Vector<Double>)
|
返回一个新的整型向量，其元素指示一个双精度浮点向量中的元素是否小于第二个双精度浮点向量中的相应元素。
|
|
LessThan(Vector<Int32>, Vector<Int32>)
|
返回一个新的整型向量，其元素指示一个整型向量中的元素是否小于第二整型向量中的相应元素。
|
|
LessThan(Vector<Int64>, Vector<Int64>)
|
返回一个新的长整数向量，其元素指示一个长整数向量中的元素是否小于第二个长整数向量中的相应元素。
|
|
LessThan(Vector<Single>, Vector<Single>)
|
返回一个新的整型向量，其元素指示一个单精度向量中的元素是否小于第二个单精度向量中的相应元素。
|
|
LessThan<T>(Vector<T>, Vector<T>)
|
返回指定类型的新向量向量，其元素指示一个向量中的元素是否小于第二个向量中的相应元素。
|
|
LessThanAll<T>(Vector<T>, Vector<T>)
|
返回一个值，该值指示第一个向量中的所有元素是否小于第二个向量中的相应元素。
|
|
LessThanAny<T>(Vector<T>, Vector<T>)
|
返回一个值，该值指示第一个向量中的任何元素是否小于第二个向量中的相应元素。
|
|
LessThanOrEqual(Vector<Double>, Vector<Double>)
|
返回一个新的整型向量，其元素指示一个双精度浮点向量中的元素是否小于或等于第二个双精度浮点向量中的相应元素。
|
|
LessThanOrEqual(Vector<Int32>, Vector<Int32>)
|
返回一个新的整型向量，其元素指示一个整型向量的元素是否小于或等于第二个整型向量中的相应元素。
|
|
LessThanOrEqual(Vector<Int64>, Vector<Int64>)
|
返回一个新的长整数向量，其元素指示一个长整数向量中的元素是小于还是等于第二个长整数向量中的相应元素。
|
|
LessThanOrEqual(Vector<Single>, Vector<Single>)
|
返回一个新的整型向量，其元素指示一个单精度浮点向量中的元素是否小于或等于第二个单精度浮点向量中的相应元素。
|
|
LessThanOrEqual<T>(Vector<T>, Vector<T>)
|
返回一个新向量，其元素指示一个向量中的元素是否小于或等于第二个向量中的相应元素。
|
|
LessThanOrEqualAll<T>(Vector<T>, Vector<T>)
|
返回一个值，该值指示第一个向量中的所有元素是否小于或等于第二个向量中的相应元素。
|
|
LessThanOrEqualAny<T>(Vector<T>, Vector<T>)
|
返回一个值，该值指示第一个向量中的任何元素是否小于或等于第二个向量中的相应元素。
|
|
Load<T>(T*)
|
从给定源加载向量。
|
|
LoadAligned<T>(T*)
|
从给定的对齐源加载向量。
|
|
LoadAlignedNonTemporal<T>(T*)
|
从给定的对齐源加载向量。
|
|
LoadUnsafe<T>(T)
|
从给定源加载向量。
|
|
LoadUnsafe<T>(T, UIntPtr)
|
从给定的源和元素偏移量加载向量。
|
|
Log(Vector<Double>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
Log(Vector<Single>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
Log2(Vector<Double>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
Log2(Vector<Single>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
Max<T>(Vector<T>, Vector<T>)
|
返回一个新向量，其元素是两个给定向量中每个元素对的最大值。
|
|
MaxMagnitude<T>(Vector<T>, Vector<T>)
|
将两个向量与计算进行比较，每个元素具有更大的数量级。
|
|
MaxMagnitudeNumber<T>(Vector<T>, Vector<T>)
|
将两个向量（基于每个元素）与计算进行比较，如果输入 NaN，则计算其数量级更大并返回另一个值。
|
|
MaxNative<T>(Vector<T>, Vector<T>)
|
比较两个向量，以确定每个元素使用特定于平台的行为 NaN 和 NegativeZero。
|
|
MaxNumber<T>(Vector<T>, Vector<T>)
|
将两个向量（基于每个元素）与计算结果进行比较，如果元素 NaN，则计算该值更大，并返回另一个值。
|
|
Min<T>(Vector<T>, Vector<T>)
|
返回一个新向量，其元素是两个给定向量中每个元素对的最小值。
|
|
MinMagnitude<T>(Vector<T>, Vector<T>)
|
将两个向量与计算进行比较，每个元素的量级较小。
|
|
MinMagnitudeNumber<T>(Vector<T>, Vector<T>)
|
将两个向量（基于每个元素）与计算进行比较，如果输入 NaN，则计算其数量级较小并返回另一个值。
|
|
MinNative<T>(Vector<T>, Vector<T>)
|
比较两个向量，以确定每个元素使用特定于平台的行为 NaN 和 NegativeZero。
|
|
MinNumber<T>(Vector<T>, Vector<T>)
|
比较两个向量（基于每个元素）计算，如果元素 NaN，则计算该向量更小，并返回另一个值。
|
|
Multiply<T>(T, Vector<T>)
|
返回一个新向量，其值是标量值乘以指定向量的每个值。
|
|
Multiply<T>(Vector<T>, T)
|
返回一个新向量，其值是指定向量的值，每个向量乘以标量值。
|
|
Multiply<T>(Vector<T>, Vector<T>)
|
返回一个新向量，其值是两个指定向量中每个元素对的乘积。
|
|
MultiplyAddEstimate(Vector<Double>, Vector<Double>, Vector<Double>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
MultiplyAddEstimate(Vector<Single>, Vector<Single>, Vector<Single>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
Narrow(Vector<Double>, Vector<Double>)
|
将两个 Vector<Double> 实例缩小为一个 Vector<Single>。
|
|
Narrow(Vector<Int16>, Vector<Int16>)
|
将两个 Vector<Int16> 实例缩小为一个 Vector<SByte>。
|
|
Narrow(Vector<Int32>, Vector<Int32>)
|
将两个 Vector<Int32> 实例缩小为一个 Vector<Int16>。
|
|
Narrow(Vector<Int64>, Vector<Int64>)
|
将两个 Vector<Int64> 实例缩小为一个 Vector<Int32>。
|
|
Narrow(Vector<UInt16>, Vector<UInt16>)
|
将两个 Vector<UInt16> 实例缩小为一个 Vector<Byte>。
|
|
Narrow(Vector<UInt32>, Vector<UInt32>)
|
将两个 Vector<UInt32> 实例缩小为一个 Vector<UInt16>。
|
|
Narrow(Vector<UInt64>, Vector<UInt64>)
|
将两个 Vector<UInt64> 实例缩小为一个 Vector<UInt32>。
|
|
Negate<T>(Vector<T>)
|
返回一个新向量，其元素是指定向量中相应元素的求反。
|
|
OnesComplement<T>(Vector<T>)
|
返回一个新向量，其元素是通过获取指定向量元素的补数获得的。
|
|
RadiansToDegrees(Vector<Double>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
RadiansToDegrees(Vector<Single>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
Round(Vector<Double>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
Round(Vector<Double>, MidpointRounding)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
Round(Vector<Single>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
Round(Vector<Single>, MidpointRounding)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
ShiftLeft(Vector<Byte>, Int32)
|
将向量的每个元素左移指定量。
|
|
ShiftLeft(Vector<Int16>, Int32)
|
将向量的每个元素左移指定量。
|
|
ShiftLeft(Vector<Int32>, Int32)
|
将向量的每个元素左移指定量。
|
|
ShiftLeft(Vector<Int64>, Int32)
|
将向量的每个元素左移指定量。
|
|
ShiftLeft(Vector<IntPtr>, Int32)
|
将向量的每个元素左移指定量。
|
|
ShiftLeft(Vector<SByte>, Int32)
|
将向量的每个元素左移指定量。
|
|
ShiftLeft(Vector<UInt16>, Int32)
|
将向量的每个元素左移指定量。
|
|
ShiftLeft(Vector<UInt32>, Int32)
|
将向量的每个元素左移指定量。
|
|
ShiftLeft(Vector<UInt64>, Int32)
|
将向量的每个元素左移指定量。
|
|
ShiftLeft(Vector<UIntPtr>, Int32)
|
将向量的每个元素左移指定量。
|
|
ShiftRightArithmetic(Vector<Int16>, Int32)
|
按指定量向量向右移动 （signed） 的每个元素。
|
|
ShiftRightArithmetic(Vector<Int32>, Int32)
|
按指定量向量向右移动 （signed） 的每个元素。
|
|
ShiftRightArithmetic(Vector<Int64>, Int32)
|
按指定量向量向右移动 （signed） 的每个元素。
|
|
ShiftRightArithmetic(Vector<IntPtr>, Int32)
|
按指定量向量向右移动 （signed） 的每个元素。
|
|
ShiftRightArithmetic(Vector<SByte>, Int32)
|
按指定量向量向右移动 （signed） 的每个元素。
|
|
ShiftRightLogical(Vector<Byte>, Int32)
|
按指定量向量向右移动（无符号）的每个元素。
|
|
ShiftRightLogical(Vector<Int16>, Int32)
|
按指定量向量向右移动（无符号）的每个元素。
|
|
ShiftRightLogical(Vector<Int32>, Int32)
|
按指定量向量向右移动（无符号）的每个元素。
|
|
ShiftRightLogical(Vector<Int64>, Int32)
|
按指定量向量向右移动（无符号）的每个元素。
|
|
ShiftRightLogical(Vector<IntPtr>, Int32)
|
按指定量向量向右移动（无符号）的每个元素。
|
|
ShiftRightLogical(Vector<SByte>, Int32)
|
按指定量向量向右移动（无符号）的每个元素。
|
|
ShiftRightLogical(Vector<UInt16>, Int32)
|
按指定量向量向右移动（无符号）的每个元素。
|
|
ShiftRightLogical(Vector<UInt32>, Int32)
|
按指定量向量向右移动（无符号）的每个元素。
|
|
ShiftRightLogical(Vector<UInt64>, Int32)
|
按指定量向量向右移动（无符号）的每个元素。
|
|
ShiftRightLogical(Vector<UIntPtr>, Int32)
|
按指定量向量向右移动（无符号）的每个元素。
|
|
Sin(Vector<Double>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
Sin(Vector<Single>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
SinCos(Vector<Double>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
SinCos(Vector<Single>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
SquareRoot<T>(Vector<T>)
|
返回一个新向量，其元素是指定向量元素的平方根。
|
|
Store<T>(Vector<T>, T*)
|
将向量存储在给定的目标处。
|
|
StoreAligned<T>(Vector<T>, T*)
|
将矢量存储在给定的对齐目标处。
|
|
StoreAlignedNonTemporal<T>(Vector<T>, T*)
|
将矢量存储在给定的对齐目标处。
|
|
StoreUnsafe<T>(Vector<T>, T)
|
将向量存储在给定的目标处。
|
|
StoreUnsafe<T>(Vector<T>, T, UIntPtr)
|
将向量存储在给定的目标处。
|
|
Subtract<T>(Vector<T>, Vector<T>)
|
返回一个新向量，其值是第二个向量中的元素与第一个向量中的相应元素之间的差异。
|
|
Sum<T>(Vector<T>)
|
返回指定向量内所有元素的总和。
|
|
ToScalar<T>(Vector<T>)
|
将给定向量转换为包含第一个元素值的标量。
|
|
Truncate(Vector<Double>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
Truncate(Vector<Single>)
|
提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
|
|
Widen(Vector<Byte>, Vector<UInt16>, Vector<UInt16>)
|
将 Vector<Byte> 扩大为两个 Vector<UInt16> 实例。
|
|
Widen(Vector<Int16>, Vector<Int32>, Vector<Int32>)
|
将 Vector<Int16> 扩大为两个 Vector<Int32> 实例。
|
|
Widen(Vector<Int32>, Vector<Int64>, Vector<Int64>)
|
将 Vector<Int32> 扩大为两个 Vector<Int64> 实例。
|
|
Widen(Vector<SByte>, Vector<Int16>, Vector<Int16>)
|
将 Vector<SByte> 扩大为两个 Vector<Int16> 实例。
|
|
Widen(Vector<Single>, Vector<Double>, Vector<Double>)
|
将 Vector<Single> 扩大为两个 Vector<Double> 实例。
|
|
Widen(Vector<UInt16>, Vector<UInt32>, Vector<UInt32>)
|
将 Vector<UInt16> 扩大为两个 Vector<UInt32> 实例。
|
|
Widen(Vector<UInt32>, Vector<UInt64>, Vector<UInt64>)
|
将 Vector<UInt32> 扩大为两个 Vector<UInt64> 实例。
|
|
WidenLower(Vector<Byte>)
|
将 Vector<T> 的下半部分扩大为 Vector<T>。
|
|
WidenLower(Vector<Int16>)
|
将 Vector<T> 的下半部分扩大为 Vector<T>。
|
|
WidenLower(Vector<Int32>)
|
将 Vector<T> 的下半部分扩大为 Vector<T>。
|
|
WidenLower(Vector<SByte>)
|
将 Vector<T> 的下半部分扩大为 Vector<T>。
|
|
WidenLower(Vector<Single>)
|
将 Vector<T> 的下半部分扩大为 Vector<T>。
|
|
WidenLower(Vector<UInt16>)
|
将 Vector<T> 的下半部分扩大为 Vector<T>。
|
|
WidenLower(Vector<UInt32>)
|
将 Vector<T> 的下半部分扩大为 Vector<T>。
|
|
WidenUpper(Vector<Byte>)
|
将 Vector<T> 的上半部分扩大为 Vector<T>。
|
|
WidenUpper(Vector<Int16>)
|
将 Vector<T> 的上半部分扩大为 Vector<T>。
|
|
WidenUpper(Vector<Int32>)
|
将 Vector<T> 的上半部分扩大为 Vector<T>。
|
|
WidenUpper(Vector<SByte>)
|
将 Vector<T> 的上半部分扩大为 Vector<T>。
|
|
WidenUpper(Vector<Single>)
|
将 Vector<T> 的上半部分扩大为 Vector<T>。
|
|
WidenUpper(Vector<UInt16>)
|
将 Vector<T> 的上半部分扩大为 Vector<T>。
|
|
WidenUpper(Vector<UInt32>)
|
将 Vector<T> 的上半部分扩大为 Vector<T>。
|
|
WithElement<T>(Vector<T>, Int32, T)
|
创建一个新的 Vector<T>，该元素位于指定索引处设置为指定值，其余元素设置为与给定向量中的相同值。
|
|
Xor<T>(Vector<T>, Vector<T>)
|
通过对两个向量中的每个元素对执行按位排他或（XOr）运算来返回一个新向量。
|
