Vector 类

定义

命名空间:

System.Numerics

程序集:

System.Numerics.Vectors.dll

Source:

Vector.cs

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

public ref class Vector abstract sealed

public static class Vector

type Vector = class

Public Module Vector

继承

Object

Vector

属性

IsHardwareAccelerated

获取一个值，该值指示向量运算是否会通过 JIT 内在支持进行硬件加速。

方法

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>。
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>)	返回一个新向量，其元素是大于或等于给定向量的元素的最小整型值。
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>。
ConvertToInt64(Vector<Double>)	将 Vector<Double> 转换为 Vector<Int64>。
ConvertToSingle(Vector<Int32>)	将 Vector<Int32> 转换为 Vector<Single>。
ConvertToSingle(Vector<UInt32>)	将 Vector<UInt32> 转换为 Vector<Single>。
ConvertToUInt32(Vector<Single>)	将 Vector<Single> 转换为 Vector<UInt32>。
ConvertToUInt64(Vector<Double>)	将 Vector<Double> 转换为 Vector<UInt64>。
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>)	返回一个值，该值指示两个给定向量中的任意元素对是否相等。
Floor(Vector<Double>)	返回一个新向量，其元素是小于或等于给定向量元素的最大整型值。
Floor(Vector<Single>)	返回一个新向量，其元素是小于或等于给定向量元素的最大整型值。
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>)	返回一个值，该值指示第一个向量中的任意元素是否大于或等于第二个向量中的相应元素。
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)	从给定的源和元素偏移量加载向量。
Max<T>(Vector<T>, Vector<T>)	返回一个新向量，其元素是两个给定向量中每对元素的最大值。
Min<T>(Vector<T>, Vector<T>)	返回一个新向量，其元素是两个给定向量中每对元素的最小值。
Multiply<T>(T, Vector<T>)	返回一个新向量，其值为乘以指定向量中的每个值所得的标量值。
Multiply<T>(Vector<T>, T)	返回一个新向量，其值是乘以标量值的指定向量的每个值。
Multiply<T>(Vector<T>, Vector<T>)	返回一个新向量，其值是两个指定向量中的每对元素的乘积。
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>)	返回一个新向量，其元素是通过取用指定向量的元素的二进制反码来获取的。
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)	(向量向量右侧的每个元素) 有符号的移位指定量。
ShiftRightArithmetic(Vector<Int32>, Int32)	(向量向量右侧的每个元素) 有符号的移位指定量。
ShiftRightArithmetic(Vector<Int64>, Int32)	(向量向量右侧的每个元素) 有符号的移位指定量。
ShiftRightArithmetic(Vector<IntPtr>, Int32)	(向量向量右侧的每个元素) 有符号的移位指定量。
ShiftRightArithmetic(Vector<SByte>, Int32)	(向量向量右侧的每个元素) 有符号的移位指定量。
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)	将 (无符号) 向量向量右侧的每个元素按指定量移位。
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>)	将给定向量转换为包含第一个元素的值的标量。
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) 运算，返回一个新向量。