Vector 類別

定義

命名空間:

System.Numerics

組件:

netstandard.dll, System.Numerics.Vectors.dll

來源:

Vector.cs

提供一系列靜態方法，用於建立、操作及以其他方式操作通用向量。

public ref class Vector abstract sealed

public static class Vector

type Vector = class

Public Module Vector

繼承

Object

Vector

屬性

名稱	Description
IsHardwareAccelerated	會得到一個值，表示向量操作是否會透過 JIT 內建支援進行硬體加速。

方法

名稱	Description
Abs<T>(Vector<T>)	回傳一個新的向量，其元素為該向量元素的絕對值。
Add<T>(Vector<T>, Vector<T>)	回傳一個新向量，其值為兩個給定向量中每對元素的總和。
AddSaturate<T>(Vector<T>, Vector<T>)	相加兩個向量以計算其元素間的飽和和。
All<T>(Vector<T>, T)	判斷向量的所有元素是否等於某一給定值。
AllWhereAllBitsSet<T>(Vector<T>)	判斷向量中所有元素是否都已設定所有位元。
AndNot<T>(Vector<T>, Vector<T>)	透過對兩個向量中對應元素的每對進行位元的 And Not 運算，回傳一個新的向量。
Any<T>(Vector<T>, T)	判斷向量中任何元素是否等於某個給定值。
AnyWhereAllBitsSet<T>(Vector<T>)	判斷向量中任何元素是否已設定所有位元。
As<TFrom,TTo>(Vector<TFrom>)	將 a Vector<T> 重新詮釋為新的 Vector<T>。
AsPlane(Vector4)	將 a Vector4 重新詮釋為新的 Plane。
AsQuaternion(Vector4)	將 a Vector4 重新詮釋為新的 Quaternion。
AsVector2(Vector3)	將 a Vector3 重新詮釋為新的 Vector2。
AsVector2(Vector4)	將 a Vector4 重新詮釋為新的 Vector2。
AsVector3(Vector2)	將 a Vector2 重新詮釋為新 Vector3 元素，並將新元素歸零。
AsVector3(Vector4)	將 a Vector4 重新詮釋為新的 Vector3。
AsVector3Unsafe(Vector2)	將 a Vector2 重新詮釋為 Vector3 新元素未定義的新元素。
AsVector4(Plane)	將 a Plane 重新詮釋為新的 Vector4。
AsVector4(Quaternion)	將 a Quaternion 重新詮釋為新的 Vector4。
AsVector4(Vector2)	將 a Vector2 重新詮釋為新 Vector4 元素，並將新元素歸零。
AsVector4(Vector3)	將 a Vector3 轉換成新 Vector4 元素，並將新元素歸零。
AsVector4Unsafe(Vector2)	將 a Vector2 重新詮釋為 Vector4 新元素未定義的新元素。
AsVector4Unsafe(Vector3)	將 a 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>)	利用平台特定行為NaNNegativeZero限制最小值與最大值之間的向量，且 ..
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>)	在 Overflow 上將 a Vector<T> 轉換成 Vector<T> 使用特定平台的行為。
ConvertToInt64(Vector<Double>)	將 Vector<Double> 轉換成 Vector<Int64>。
ConvertToInt64Native(Vector<Double>)	在 Overflow 上將 a 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>)	在 Overflow 上將 a System.Numerics.Vector<System.Single> 轉換成 System.Numerics.Vector<System.UInt32> 使用特定平台的行為。
ConvertToUInt64(Vector<Double>)	將 Vector<Double> 轉換成 Vector<UInt64>。
ConvertToUInt64Native(Vector<Double>)	在 Overflow 上將 a System.Numerics.Vector<System.Double> 轉換成 System.Numerics.Vector<System.UInt64> 使用特定平台的行為。
CopySign<T>(Vector<T>, Vector<T>)	將一個向量的每個元素符號複製到另一個向量的每個元素符號。
Cos(Vector<Double>)	計算向量中每個元素的餘弦值。
Cos(Vector<Single>)	計算向量中每個元素的餘弦值。
Count<T>(Vector<T>, T)	決定向量中等於某一給定值的元素數量。
CountWhereAllBitsSet<T>(Vector<T>)	決定向量中所有位元都設定為的元素數量。
Create<T>(ReadOnlySpan<T>)	從給定的唯讀區間建立新 Vector<T> 資料。
Create<T>(T)	建立一個 Vector<T> 新實例，所有元素初始化為指定值。
CreateScalar<T>(T)	建立一個新 Vector<T> 實例，第一個元素初始化為指定值，其餘元素初始化為零。
CreateScalarUnsafe<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>)	計算向量中每個元素的指數。
ExtractMostSignificantBits(Vector2)	從向量中每個元素中提取最高有效位元。
ExtractMostSignificantBits(Vector3)	從向量中每個元素中提取最高有效位元。
ExtractMostSignificantBits(Vector4)	從向量中每個元素中提取最高有效位元。
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(Vector2, Int32)	取得位於指定索引處的專案。
GetElement(Vector3, Int32)	取得位於指定索引處的專案。
GetElement(Vector4, Int32)	取得位於指定索引處的專案。
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>)	計算斜邊，給定兩個代表直角三角形中較短邊長度的向量。
IndexOf<T>(Vector<T>, T)	決定向量中第一個元素的索引，該元素等於給定值。
IndexOfWhereAllBitsSet<T>(Vector<T>)	決定向量中第一個元素的索引，該向量所有位元都已設定。
IsEvenInteger<T>(Vector<T>)	決定向量中哪些元素為整數值。
IsFinite<T>(Vector<T>)	決定向量中哪些元素是有限的。
IsInfinity<T>(Vector<T>)	決定向量中哪些元素是無限大。
IsInteger<T>(Vector<T>)	決定向量中哪些元素為整數值。
IsNaN<T>(Vector<T>)	決定向量中哪些元素是NaN。
IsNegative<T>(Vector<T>)	決定向量中哪些元素代表負實數。
IsNegativeInfinity<T>(Vector<T>)	決定向量中哪些元素為負無限大。
IsNormal<T>(Vector<T>)	決定向量中哪些元素是正規的。
IsOddInteger<T>(Vector<T>)	決定向量中哪些元素為奇積分值。
IsPositive<T>(Vector<T>)	決定向量中哪些元素代表正實數。
IsPositiveInfinity<T>(Vector<T>)	決定向量中哪些元素為正無限大。
IsSubnormal<T>(Vector<T>)	判斷向量中哪些元素是次正規的。
IsZero<T>(Vector<T>)	決定向量中哪些元素為零。
LastIndexOf<T>(Vector<T>, T)	決定向量中最後一個元素的指標，該元素等於給定值。
LastIndexOfWhereAllBitsSet<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, UIntPtr)	從給定來源和元素偏移量載入向量。
LoadUnsafe<T>(T)	從給定來源載入向量。
Log(Vector<Double>)	計算向量中每個元素的對數。
Log(Vector<Single>)	計算向量中每個元素的對數。
Log2(Vector<Double>)	計算向量中每個元素的 log²。
Log2(Vector<Single>)	計算向量中每個元素的 log²。
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>)	比較兩個向量，利用平台特定行為NaNNegativeZero在每個元素上判斷哪個更強。
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>)	比較兩個向量，利用平台特定行為在NaNNegativeZero每個元素上判斷哪個較小。
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>)	計算估計值為（left * right） + 。 addend
MultiplyAddEstimate(Vector<Single>, Vector<Single>, Vector<Single>)	計算估計值為（left * right） + 。 addend
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>。
NarrowWithSaturation(Vector<Double>, Vector<Double>)	利用飽和轉換將兩個實例向量 Double 縮小為一個向量 Single 。
NarrowWithSaturation(Vector<Int16>, Vector<Int16>)	利用飽和轉換將兩個實例向量 Int16 縮小為一個向量 SByte 。
NarrowWithSaturation(Vector<Int32>, Vector<Int32>)	利用飽和轉換將兩個實例向量 Int32 縮小為一個向量 Int16 。
NarrowWithSaturation(Vector<Int64>, Vector<Int64>)	利用飽和轉換將兩個實例向量 Int64 縮小為一個向量 Int32 。
NarrowWithSaturation(Vector<UInt16>, Vector<UInt16>)	利用飽和轉換將兩個實例向量 UInt16 縮小為一個向量 Byte 。
NarrowWithSaturation(Vector<UInt32>, Vector<UInt32>)	利用飽和轉換將兩個實例向量 UInt32 縮小為一個向量 UInt16 。
NarrowWithSaturation(Vector<UInt64>, Vector<UInt64>)	利用飽和轉換將兩個實例向量 UInt64 縮小為一個向量 UInt32 。
Negate<T>(Vector<T>)	回傳一個新向量，其元素是指定向量中對應元素的否定。
None<T>(Vector<T>, T)	判斷向量中是否沒有元素等於某一給定值。
NoneWhereAllBitsSet<T>(Vector<T>)	判斷向量中沒有元素的位元全部被設定。
OnesComplement<T>(Vector<T>)	回傳一個新向量，其元素是透過取指定向量元素的補數得到。
RadiansToDegrees(Vector<Double>)	將給定向量從弧度轉換為度數。
RadiansToDegrees(Vector<Single>)	將給定向量從弧度轉換為度數。
Round(Vector<Double>, MidpointRounding)	利用指定的四捨五入模式將向量中的每個元素捨入至最接近的整數。
Round(Vector<Double>)	利用預設的四捨五入模式（ToEven）將向量中的每個元素捨入到最接近的整數。
Round(Vector<Single>, MidpointRounding)	利用指定的四捨五入模式將向量中的每個元素捨入至最接近的整數。
Round(Vector<Single>)	利用預設的四捨五入模式（ToEven）將向量中的每個元素捨入到最接近的整數。
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)	將向量中的每個元素（無符號）向右偏移指定幅度。
Sin(Vector<Double>)	計算向量中每個元素的正弦值。
Sin(Vector<Single>)	計算向量中每個元素的正弦值。
SinCos(Vector<Double>)	計算向量中每個元素的正弦與餘弦值。
SinCos(Vector<Single>)	計算向量中每個元素的正弦與餘弦值。
SquareRoot<T>(Vector<T>)	回傳一個新向量，其元素為指定向量元素的平方根。
Store(Vector2, Single*)	在指定目的地儲存一個向量。
Store(Vector3, Single*)	在指定目的地儲存一個向量。
Store(Vector4, Single*)	在指定目的地儲存一個向量。
Store<T>(Vector<T>, T*)	在指定目的地儲存一個向量。
StoreAligned(Vector2, Single*)	在指定的 8 位元組對齊目的地儲存向量。
StoreAligned(Vector3, Single*)	在指定的 8 位元組對齊目的地儲存向量。
StoreAligned(Vector4, Single*)	在指定的 16 位元組對齊目的地儲存向量。
StoreAligned<T>(Vector<T>, T*)	在指定對齊的目的地儲存一個向量。
StoreAlignedNonTemporal(Vector2, Single*)	在指定的 8 位元組對齊目的地儲存向量。
StoreAlignedNonTemporal(Vector3, Single*)	在指定的 8 位元組對齊目的地儲存向量。
StoreAlignedNonTemporal(Vector4, Single*)	在指定的 16 位元組對齊目的地儲存向量。
StoreAlignedNonTemporal<T>(Vector<T>, T*)	在指定對齊的目的地儲存一個向量。
StoreUnsafe(Vector2, Single, UIntPtr)	在指定目的地儲存一個向量。
StoreUnsafe(Vector2, Single)	在指定目的地儲存一個向量。
StoreUnsafe(Vector3, Single, UIntPtr)	在指定目的地儲存一個向量。
StoreUnsafe(Vector3, Single)	在指定目的地儲存一個向量。
StoreUnsafe(Vector4, Single, UIntPtr)	在指定目的地儲存一個向量。
StoreUnsafe(Vector4, Single)	在指定目的地儲存一個向量。
StoreUnsafe<T>(Vector<T>, T, UIntPtr)	在指定目的地儲存一個向量。
StoreUnsafe<T>(Vector<T>, T)	在指定目的地儲存一個向量。
Subtract<T>(Vector<T>, Vector<T>)	回傳一個新向量，其值為第二個向量中元素與其對應元素之間的差。
SubtractSaturate<T>(Vector<T>, Vector<T>)	減去兩個向量以計算它們在元素間的飽和差。
Sum<T>(Vector<T>)	回傳指定向量內所有元素的總和。
ToScalar(Vector2)	將給定向量轉換為包含第一個元素值的標量。
ToScalar(Vector3)	將給定向量轉換為包含第一個元素值的標量。
ToScalar(Vector4)	將給定向量轉換為包含第一個元素值的標量。
ToScalar<T>(Vector<T>)	將給定向量轉換為包含第一個元素值的標量。
Truncate(Vector<Double>)	截斷向量中的每個元素。
Truncate(Vector<Single>)	截斷向量中的每個元素。
Widen(Vector<Byte>, Vector<UInt16>, Vector<UInt16>)	將 a Vector<Byte> 擴大成兩個 Vector<UInt16> 例子。
Widen(Vector<Int16>, Vector<Int32>, Vector<Int32>)	將 a Vector<Int16> 擴大成兩個 Vector<Int32> 例子。
Widen(Vector<Int32>, Vector<Int64>, Vector<Int64>)	將 a Vector<Int32> 擴大成兩個 Vector<Int64> 例子。
Widen(Vector<SByte>, Vector<Int16>, Vector<Int16>)	將 a Vector<SByte> 擴大成兩個 Vector<Int16> 例子。
Widen(Vector<Single>, Vector<Double>, Vector<Double>)	將 a Vector<Single> 擴大成兩個 Vector<Double> 例子。
Widen(Vector<UInt16>, Vector<UInt32>, Vector<UInt32>)	將 a Vector<UInt16> 擴大成兩個 Vector<UInt32> 例子。
Widen(Vector<UInt32>, Vector<UInt64>, Vector<UInt64>)	將 a Vector<UInt32> 擴大成兩個 Vector<UInt64> 例子。
WidenLower(Vector<Byte>)	將 a Vector<T> 的下半部擴大成 Vector<T>。
WidenLower(Vector<Int16>)	將 a Vector<T> 的下半部擴大成 Vector<T>。
WidenLower(Vector<Int32>)	將 a Vector<T> 的下半部擴大成 Vector<T>。
WidenLower(Vector<SByte>)	將 a Vector<T> 的下半部擴大成 Vector<T>。
WidenLower(Vector<Single>)	將 a Vector<T> 的下半部擴大成 Vector<T>。
WidenLower(Vector<UInt16>)	將 a Vector<T> 的下半部擴大成 Vector<T>。
WidenLower(Vector<UInt32>)	將 a Vector<T> 的下半部擴大成 Vector<T>。
WidenUpper(Vector<Byte>)	將 a Vector<T> 的上半部擴大為 Vector<T>。
WidenUpper(Vector<Int16>)	將 a Vector<T> 的上半部擴大為 Vector<T>。
WidenUpper(Vector<Int32>)	將 a Vector<T> 的上半部擴大為 Vector<T>。
WidenUpper(Vector<SByte>)	將 a Vector<T> 的上半部擴大為 Vector<T>。
WidenUpper(Vector<Single>)	將 a Vector<T> 的上半部擴大為 Vector<T>。
WidenUpper(Vector<UInt16>)	將 a Vector<T> 的上半部擴大為 Vector<T>。
WidenUpper(Vector<UInt32>)	將 a Vector<T> 的上半部擴大為 Vector<T>。
WithElement(Vector2, Int32, Single)	建立一個新 Vector128<T> Entry，將指定索引的元素設定為指定值，其餘元素則設定為與給定向量中的相同值。
WithElement(Vector3, Int32, Single)	建立一個新 Vector128<T> Entry，將指定索引的元素設定為指定值，其餘元素則設定為與給定向量中的相同值。
WithElement(Vector4, Int32, Single)	建立一個新 Vector128<T> Entry，將指定索引的元素設定為指定值，其餘元素則設定為與給定向量中的相同值。
WithElement<T>(Vector<T>, Int32, T)	建立一個新 Vector<T> Entry，將指定索引的元素設定為指定值，其餘元素則設定為與給定向量中的相同值。
Xor<T>(Vector<T>, Vector<T>)	透過對兩個向量中的每對元素執行位元排斥 Or （XOr） 操作，回傳一個新向量。