Class Vectors

Namespace: Zyl.VectorTraits

Assembly: VectorTraits.dll

Methods of Vector<T>. It supports ExType, and the element type can also be (它支持扩展类型, 元素类型还可以为): ExInt128, ExUInt128, Int128, UInt128.

public static class Vectors

Inheritance: object

Vectors

Inherited Members: object.Equals(object)

object.Equals(object, object)

object.GetHashCode()

object.GetType()

object.MemberwiseClone()

object.ReferenceEquals(object, object)

object.ToString()

Properties

Add_AcceleratedTypes: Types with hardware acceleration when running Add (运行 Add 时具有硬件加速的类型).

BaseInstance: Base traits instance (基本特征实例).

BaseInstanceDynamic: Base traits instance dynamic value (基本特征实例动态值).

ByteCount: Get byte count (取得字节数量).

Ceiling_AcceleratedTypes: Types with hardware acceleration when running Ceiling (运行 Ceiling 时具有硬件加速的类型).

ConvertToDouble_AcceleratedTypes: Types with hardware acceleration when running ConvertToDouble (运行 ConvertToDouble 时具有硬件加速的类型).

ConvertToInt32_AcceleratedTypes: Types with hardware acceleration when running ConvertToInt32 (运行 ConvertToInt32 时具有硬件加速的类型).

ConvertToInt64_AcceleratedTypes: Types with hardware acceleration when running ConvertToInt64 (运行 ConvertToInt64 时具有硬件加速的类型).

ConvertToSingle_AcceleratedTypes: Types with hardware acceleration when running ConvertToSingle (运行 ConvertToSingle 时具有硬件加速的类型).

ConvertToUInt32_AcceleratedTypes: Types with hardware acceleration when running ConvertToUInt32 (运行 ConvertToUInt32 时具有硬件加速的类型).

ConvertToUInt64_AcceleratedTypes: Types with hardware acceleration when running ConvertToUInt64 (运行 ConvertToUInt64 时具有硬件加速的类型).

Dot_AcceleratedTypes: Types with hardware acceleration when running Dot (运行 Dot 时具有硬件加速的类型).

ExtractMostSignificantBits_AcceleratedTypes: Types with hardware acceleration when running ExtractMostSignificantBits (运行 ExtractMostSignificantBits 时具有硬件加速的类型).

Floor_AcceleratedTypes: Types with hardware acceleration when running Floor (运行 Floor 时具有硬件加速的类型).

Instance: Best traits instance (最佳特征实例).

InstanceDynamic: Best traits instance dynamic value (最佳特征实例动态值).

IsHardwareAccelerated: Whether to exist hardware accelerated (是否存在硬件加速).

IsSupported: Whether to support the run (是否支持运行).

Multiply_AcceleratedTypes: Types with hardware acceleration when running Multiply (运行 Multiply 时具有硬件加速的类型).

Multiply_FullAcceleratedTypes: Types with full hardware acceleration when running Multiply (运行 Multiply 时具有完全硬件加速的类型).

Narrow_AcceleratedTypes: Types with hardware acceleration when running Narrow (运行 Narrow 时具有硬件加速的类型).

ShiftLeft_AcceleratedTypes: Types with hardware acceleration when running ShiftLeft (运行 ShiftLeft 时具有硬件加速的类型).

ShiftRightArithmetic_AcceleratedTypes: Types with hardware acceleration when running ShiftRightArithmetic (运行 ShiftRightArithmetic 时具有硬件加速的类型).

ShiftRightLogical_AcceleratedTypes: Types with hardware acceleration when running ShiftRightLogical (运行 ShiftRightLogical 时具有硬件加速的类型).

Shuffle_AcceleratedTypes: Types with hardware acceleration when running Shuffle (运行 Shuffle 时具有硬件加速的类型).

Sqrt_AcceleratedTypes: Types with hardware acceleration when running Sqrt (运行 Sqrt 时具有硬件加速的类型).

StaticsTypes: Statics types (静态类型集).

Sum_AcceleratedTypes: Types with hardware acceleration when running Sum (运行 Sum 时具有硬件加速的类型).

TraitsInstances: Traits instance list (特征实例列表).

TraitsNames: Traits name list (特征名称列表).

WidenLower_AcceleratedTypes: Types with hardware acceleration when running WidenLower (运行 WidenLower 时具有硬件加速的类型).

WidenUpper_AcceleratedTypes: Types with hardware acceleration when running WidenUpper (运行 WidenUpper 时具有硬件加速的类型).

Widen_AcceleratedTypes: Types with hardware acceleration when running Widen (运行 Widen 时具有硬件加速的类型).

YBitToByte_IsAccelerated: Is it has hardware accelerated when running YBitToByte (运行 YBitToByte 时是否具有硬件加速).

YBitToInt16_IsAccelerated: Is it has hardware accelerated when running YBitToInt16 (运行 YBitToInt16 时是否具有硬件加速).

YBitToInt32_IsAccelerated: Is it has hardware accelerated when running YBitToInt32 (运行 YBitToInt32 时是否具有硬件加速).

YBitToInt64_IsAccelerated: Is it has hardware accelerated when running YBitToInt64 (运行 YBitToInt64 时是否具有硬件加速).

YClamp_AcceleratedTypes: Types with hardware acceleration when running YClamp (运行 YClamp 时具有硬件加速的类型).

YCopySign_AcceleratedTypes: Types with hardware acceleration when running YCopySign (运行 YCopySign 时具有硬件加速的类型).

YGroup1ToGroup3_AcceleratedTypes: Types with hardware acceleration when running YGroup1ToGroup3 (运行 YGroup1ToGroup3 时具有硬件加速的类型).

YGroup1ToGroup4WithW_AcceleratedTypes: Types with hardware acceleration when running YGroup1ToGroup4WithW (运行 YGroup1ToGroup4WithW 时具有硬件加速的类型).

YGroup1ToGroup4_AcceleratedTypes: Types with hardware acceleration when running YGroup1ToGroup4 (运行 YGroup1ToGroup4 时具有硬件加速的类型).

YGroup2TransposeEven_AcceleratedTypes: Types with hardware acceleration when running YGroup2TransposeEven (运行 YGroup2TransposeEven 时具有硬件加速的类型).

YGroup2TransposeOdd_AcceleratedTypes: Types with hardware acceleration when running YGroup2TransposeOdd (运行 YGroup2TransposeOdd 时具有硬件加速的类型).

YGroup2Transpose_AcceleratedTypes: Types with hardware acceleration when running YGroup2Transpose (运行 YGroup2Transpose 时具有硬件加速的类型).

YGroup2UnzipEven_AcceleratedTypes: Types with hardware acceleration when running YGroup2UnzipEven (运行 YGroup2UnzipEven 时具有硬件加速的类型).

YGroup2UnzipOdd_AcceleratedTypes: Types with hardware acceleration when running YGroup2UnzipOdd (运行 YGroup2UnzipOdd 时具有硬件加速的类型).

YGroup2Unzip_AcceleratedTypes: Types with hardware acceleration when running YGroup2Unzip (运行 YGroup2Unzip 时具有硬件加速的类型).

YGroup2ZipHigh_AcceleratedTypes: Types with hardware acceleration when running YGroup2ZipHigh (运行 YGroup2ZipHigh 时具有硬件加速的类型).

YGroup2ZipLow_AcceleratedTypes: Types with hardware acceleration when running YGroup2ZipLow (运行 YGroup2ZipLow 时具有硬件加速的类型).

YGroup2Zip_AcceleratedTypes: Types with hardware acceleration when running YGroup2Zip (运行 YGroup2Zip 时具有硬件加速的类型).

YGroup3ToGroup4_AcceleratedTypes: Types with hardware acceleration when running YGroup3ToGroup4 (运行 YGroup3ToGroup4 时具有硬件加速的类型).

YGroup3UnzipX2_AcceleratedTypes: Types with hardware acceleration when running YGroup3UnzipX2 (运行 YGroup3UnzipX2 时具有硬件加速的类型).

YGroup3Unzip_AcceleratedTypes: Types with hardware acceleration when running YGroup3Unzip (运行 YGroup3Unzip 时具有硬件加速的类型).

YGroup3ZipX2_AcceleratedTypes: Types with hardware acceleration when running YGroup3ZipX2 (运行 YGroup3ZipX2 时具有硬件加速的类型).

YGroup3Zip_AcceleratedTypes: Types with hardware acceleration when running YGroup3Zip (运行 YGroup3Zip 时具有硬件加速的类型).

YGroup4ToGroup3_AcceleratedTypes: Types with hardware acceleration when running YGroup4ToGroup3 (运行 YGroup4ToGroup3 时具有硬件加速的类型).

YGroup4Unzip_AcceleratedTypes: Types with hardware acceleration when running YGroup4Unzip (运行 YGroup4Unzip 时具有硬件加速的类型).

YGroup4Zip_AcceleratedTypes: Types with hardware acceleration when running YGroup4Zip (运行 YGroup4Zip 时具有硬件加速的类型).

YIsAllTrue_AcceleratedTypes: Types with hardware acceleration when running YIsAllTrue (运行 YIsAllTrue 时具有硬件加速的类型).

YIsAnyTrue_AcceleratedTypes: Types with hardware acceleration when running YIsAnyTrue (运行 YIsAnyTrue 时具有硬件加速的类型).

YIsEvenInteger_AcceleratedTypes: Types with hardware acceleration when running YIsEvenInteger (运行 YIsEvenInteger 时具有硬件加速的类型).

YIsFinite_AcceleratedTypes: Types with hardware acceleration when running YIsFinite (运行 YIsFinite 时具有硬件加速的类型).

YIsInfinityOrNaN_AcceleratedTypes: Types with hardware acceleration when running YIsInfinityOrNaN (运行 YIsInfinityOrNaN 时具有硬件加速的类型).

YIsInfinity_AcceleratedTypes: Types with hardware acceleration when running YIsInfinity (运行 YIsInfinity 时具有硬件加速的类型).

YIsInteger_AcceleratedTypes: Types with hardware acceleration when running YIsInteger (运行 YIsInteger 时具有硬件加速的类型).

YIsNaN_AcceleratedTypes: Types with hardware acceleration when running YIsNaN (运行 YIsNaN 时具有硬件加速的类型).

YIsNegativeInfinity_AcceleratedTypes: Types with hardware acceleration when running YIsNegativeInfinity (运行 YIsNegativeInfinity 时具有硬件加速的类型).

YIsNegativeZero_AcceleratedTypes: Types with hardware acceleration when running YIsNegativeZero (运行 YIsNegativeZero 时具有硬件加速的类型).

YIsNegative_AcceleratedTypes: Types with hardware acceleration when running YIsNegative (运行 YIsNegative 时具有硬件加速的类型).

YIsNormal_AcceleratedTypes: Types with hardware acceleration when running YIsNormal (运行 YIsNormal 时具有硬件加速的类型).

YIsNotEquals_AcceleratedTypes: Types with hardware acceleration when running YIsNotEquals (运行 YIsNotEquals 时具有硬件加速的类型).

YIsNotNaN_AcceleratedTypes: Types with hardware acceleration when running YIsNotNaN (运行 YIsNotNaN 时具有硬件加速的类型).

YIsOddInteger_AcceleratedTypes: Types with hardware acceleration when running YIsOddInteger (运行 YIsOddInteger 时具有硬件加速的类型).

YIsPositiveInfinity_AcceleratedTypes: Types with hardware acceleration when running YIsPositiveInfinity (运行 YIsPositiveInfinity 时具有硬件加速的类型).

YIsPositive_AcceleratedTypes: Types with hardware acceleration when running YIsPositive (运行 YIsPositive 时具有硬件加速的类型).

YIsSubnormal_AcceleratedTypes: Types with hardware acceleration when running YIsSubnormal (运行 YIsSubnormal 时具有硬件加速的类型).

YIsZeroOrSubnormal_AcceleratedTypes: Types with hardware acceleration when running YIsZeroOrSubnormal (运行 YIsZeroOrSubnormal 时具有硬件加速的类型).

YIsZero_AcceleratedTypes: Types with hardware acceleration when running YIsZero (运行 YIsZero 时具有硬件加速的类型).

YMaxNumber_AcceleratedTypes: Types with hardware acceleration when running YMaxNumber (运行 YMaxNumber 时具有硬件加速的类型).

YMinNumber_AcceleratedTypes: Types with hardware acceleration when running YMinNumber (运行 YMinNumber 时具有硬件加速的类型).

YNarrowSaturateUnsigned_AcceleratedTypes: Types with hardware acceleration when running YNarrowSaturateUnsigned (运行 YNarrowSaturateUnsigned 时具有硬件加速的类型).

YNarrowSaturateUnsigned_FullAcceleratedTypes: Types with full hardware acceleration when running YNarrowSaturateUnsigned (运行 YNarrowSaturateUnsigned 时具有完全硬件加速的类型).

YNarrowSaturate_AcceleratedTypes: Types with hardware acceleration when running YNarrowSaturate (运行 YNarrowSaturate 时具有硬件加速的类型).

YNarrowSaturate_FullAcceleratedTypes: Types with full hardware acceleration when running YNarrowSaturate (运行 YNarrowSaturate 时具有完全硬件加速的类型).

YOrNot_AcceleratedTypes: Types with hardware acceleration when running YOrNot (运行 YOrNot 时具有硬件加速的类型).

YRoundToEven_AcceleratedTypes: Types with hardware acceleration when running YRoundToEven (运行 YRoundToEven 时具有硬件加速的类型).

YRoundToZero_AcceleratedTypes: Types with hardware acceleration when running YRoundToZero (运行 YRoundToZero 时具有硬件加速的类型).

YShuffleG2_AcceleratedTypes: Types with hardware acceleration when running YShuffleG2 (运行 YShuffleG2 时具有硬件加速的类型).

YShuffleG4X2_AcceleratedTypes: Types with hardware acceleration when running YShuffleG4X2 (运行 YShuffleG4X2 时具有硬件加速的类型).

YShuffleG4_AcceleratedTypes: Types with hardware acceleration when running YShuffleG4 (运行 YShuffleG4 时具有硬件加速的类型).

YShuffleInsert_AcceleratedTypes: Types with hardware acceleration when running YShuffleInsert (运行 YShuffleInsert 时具有硬件加速的类型).

YShuffleKernel_AcceleratedTypes: Types with hardware acceleration when running YShuffleKernel (运行 Shuffle 时具有硬件加速的类型).

YShuffleX2Insert_AcceleratedTypes: Types with hardware acceleration when running YShuffleX2Insert (运行 YShuffleX2Insert 时具有硬件加速的类型).

YShuffleX2Kernel_AcceleratedTypes: Types with hardware acceleration when running YShuffleX2Kernel (运行 YShuffleX2Kernel 时具有硬件加速的类型).

YShuffleX2_AcceleratedTypes: Types with hardware acceleration when running YShuffleX2 (运行 YShuffleX2 时具有硬件加速的类型).

YShuffleX3Insert_AcceleratedTypes: Types with hardware acceleration when running YShuffleX3Insert (运行 YShuffleX3Insert 时具有硬件加速的类型).

YShuffleX3Kernel_AcceleratedTypes: Types with hardware acceleration when running YShuffleX3Kernel (运行 YShuffleX3Kernel 时具有硬件加速的类型).

YShuffleX3_AcceleratedTypes: Types with hardware acceleration when running YShuffleX3 (运行 YShuffleX3 时具有硬件加速的类型).

YShuffleX4Insert_AcceleratedTypes: Types with hardware acceleration when running YShuffleX4Insert (运行 YShuffleX4Insert 时具有硬件加速的类型).

YShuffleX4Kernel_AcceleratedTypes: Types with hardware acceleration when running YShuffleX4Kernel (运行 YShuffleX4Kernel 时具有硬件加速的类型).

YShuffleX4_AcceleratedTypes: Types with hardware acceleration when running YShuffleX4 (运行 YShuffleX4 时具有硬件加速的类型).

YSignFloat_AcceleratedTypes: Types with hardware acceleration when running YSignFloat (运行 YSignFloat 时具有硬件加速的类型).

YSign_AcceleratedTypes: Types with hardware acceleration when running YSign (运行 YSign 时具有硬件加速的类型).

Methods

Add(Vector<byte>, Vector<byte>): Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic: rt[i] := left[i] + right[i].

Add(Vector<double>, Vector<double>): Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic: rt[i] := left[i] + right[i].

Add(Vector<short>, Vector<short>): Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic: rt[i] := left[i] + right[i].

Add(Vector<int>, Vector<int>): Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic: rt[i] := left[i] + right[i].

Add(Vector<long>, Vector<long>): Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic: rt[i] := left[i] + right[i].

Add(Vector<sbyte>, Vector<sbyte>): Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic: rt[i] := left[i] + right[i].

Add(Vector<float>, Vector<float>): Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic: rt[i] := left[i] + right[i].

Add(Vector<ushort>, Vector<ushort>): Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic: rt[i] := left[i] + right[i].

Add(Vector<uint>, Vector<uint>): Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic: rt[i] := left[i] + right[i].

Add(Vector<ulong>, Vector<ulong>): Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic: rt[i] := left[i] + right[i].

AsVector128<T>(Vector<T>): Reinterprets a Vector<T> as a new Vector128<T> (将 Vector<T> 重新解释为新的 Vector128<T>). It supports ExType, so there is no element type check (它支持 ExType, 故没有元素类型检查).

AsVector256A<T>(Vector<T>): Reinterprets a Vector<T> as a new Vector256<T> (将 Vector<T> 重新解释为新的 Vector256<T>). It supports ExType, so there is no element type check (它支持 ExType, 故没有元素类型检查).

AsVector256<T>(Vector<T>): Reinterprets a Vector<T> as a new Vector256<T> (将 Vector<T> 重新解释为新的 Vector256<T>). It supports ExType, so there is no element type check (它支持 ExType, 故没有元素类型检查).

AsVector512<T>(Vector<T>): Reinterprets a Vector<T> as a new Vector512<T> (将 Vector<T> 重新解释为新的 Vector512<T>). It supports ExType, so there is no element type check (它支持 ExType, 故没有元素类型检查).

AsVector<T>(Vector128<T>): Reinterprets a Vector128<T> as a new Vector<T> (将 Vector128<T> 重新解释为新的 Vector<T>). It supports ExType, so there is no element type check (它支持 ExType, 故没有元素类型检查).

AsVector<T>(Vector256<T>): Reinterprets a Vector256<T> as a new Vector<T> (将 Vector256<T> 重新解释为新的 Vector<T>). It supports ExType, so there is no element type check (它支持 ExType, 故没有元素类型检查).

AsVector<T>(Vector512<T>): Reinterprets a Vector512<T> as a new Vector<T> (将 Vector512<T> 重新解释为新的 Vector<T>). It supports ExType, so there is no element type check (它支持 ExType, 故没有元素类型检查).

BitEquals<T>(Vector<T>, Vector<T>): Returns a value that indicates whether this instance is binary equal to a specified vector (返回一个值，该值指示此实例是否与指定的向量二进制相等).

Ceiling(Vector<double>): Computes the ceiling of each element in a vector (计算向量中每个元素的向上取整). It is also known as round to positive infinity (它也被称作向正无穷舍入). See more: ToPositiveInfinity. Mnemonic: rt[i] := ceiling(value[i]).

Ceiling(Vector<float>): Computes the ceiling of each element in a vector (计算向量中每个元素的向上取整). It is also known as round to positive infinity (它也被称作向正无穷舍入). See more: ToPositiveInfinity. Mnemonic: rt[i] := ceiling(value[i]).

ConvertToDouble(Vector<long>): Convert to a vector whose elements are of type Double (转换为元素类型是Double的向量).. Mnemonic: rt[i] := (Double)(value[i]).

ConvertToDouble(Vector<ulong>): Convert to a vector whose elements are of type Double (转换为元素类型是Double的向量).. Mnemonic: rt[i] := (Double)(value[i]).

ConvertToDouble_Range52(Vector<long>): Convert to a vector whose elements are of type Double (转换为元素类型是Double的向量). Works for inputs in the range: [-2^51, 2^51). Mnemonic: rt[i] := (Double)(value[i]).

ConvertToDouble_Range52(Vector<ulong>): Convert to a vector whose elements are of type Double (转换为元素类型是Double的向量). Works for inputs in the range: [0, 2^52). Mnemonic: rt[i] := (Double)(value[i]).

ConvertToInt32(Vector<float>): Convert to a vector whose elements are of type Int32 (转换为元素类型是Int32的向量).. Mnemonic: rt[i] := (Int32)(value[i]).

ConvertToInt64(Vector<double>): Convert to a vector whose elements are of type Int64, rounding mode is truncate(round to zero) (转换为元素类型是Int64的向量, 舍入模式为截断(舍入到零)). Mnemonic: rt[i] := (Int64)(value[i]).

ConvertToInt64_Range52(Vector<double>): Convert to a vector whose elements are of type Int64, rounding mode is truncate(round to zero) (转换为元素类型是Int64的向量, 舍入模式为截断(舍入到零)). Works for inputs in the range: [-2^51, 2^51). Mnemonic: rt[i] := (Int64)(value[i]).

ConvertToInt64_Range52RoundToEven(Vector<double>): Convert to a vector whose elements are of type Int64, rounding mode is round to even(round to nearest integer) (转换为元素类型是Int64的向量, 舍入模式为舍入到偶数(舍入到最近整数)). Works for inputs in the range: [-2^51, 2^51). Mnemonic: rt[i] := (Int64)(round_to_even(value[i])).

ConvertToSingle(Vector<int>): Convert to a vector whose elements are of type Single (转换为元素类型是Single的向量).. Mnemonic: rt[i] := (Single)(value[i]).

ConvertToSingle(Vector<uint>): Convert to a vector whose elements are of type Single (转换为元素类型是Single的向量).. Mnemonic: rt[i] := (Single)(value[i]).

ConvertToUInt32(Vector<float>): Convert to a vector whose elements are of type UInt32 (转换为元素类型是UInt32的向量).. Mnemonic: rt[i] := (UInt32)(value[i]).

ConvertToUInt64(Vector<double>): Convert to a vector whose elements are of type UInt64, rounding mode is truncate(round to zero) (转换为元素类型是UInt64的向量, 舍入模式为截断(舍入到零)). Mnemonic: rt[i] := (UInt64)(value[i]).

ConvertToUInt64_Range52(Vector<double>): Convert to a vector whose elements are of type UInt64, rounding mode is truncate(round to zero) (转换为元素类型是UInt64的向量, 舍入模式为截断(舍入到零)). Works for inputs in the range: [0, 2^52). Mnemonic: rt[i] := (UInt64)(value[i]).

ConvertToUInt64_Range52RoundToEven(Vector<double>): Convert to a vector whose elements are of type UInt64, rounding mode is round to even(round to nearest integer) (转换为元素类型是UInt64的向量, 舍入模式为舍入到偶数(舍入到最近整数)). Works for inputs in the range: [0, 2^52). Mnemonic: rt[i] := (UInt64)(round_to_even(value[i])).

Count<T>(): Returns the number of elements stored in the vector (返回存储在向量中的元素数量).

Create(Int128): Creates a new vector instance of element type Int128 with all elements initialized to the specified value (创建新的元素类型为Int128的向量实例，其中所有元素已初始化为指定值).

Create(UInt128): Creates a new vector instance of element type UInt128 with all elements initialized to the specified value (创建新的元素类型为UInt128的向量实例，其中所有元素已初始化为指定值).

Create(ExInt128): Creates a new vector instance of element type ExInt128 with all elements initialized to the specified value (创建新的元素类型为ExInt128的向量实例，其中所有元素已初始化为指定值).

Create(ExUInt128): Creates a new vector instance of element type ExUInt128 with all elements initialized to the specified value (创建新的元素类型为ExUInt128的向量实例，其中所有元素已初始化为指定值).

CreateBy128Bits<T>(ExInt128): Creates a Vector<T> whose components are of a specified 128-bits integer (创建一个 Vector<T>，其元素为指定的128位整数).

CreateByBits<T>(long): Creates a Vector<T> whose components are of a specified integer bits (创建一个 Vector<T>，其元素为指定的整数位).

CreateByDoubleLoop<T>(double, double): Creates a Vector<T> from double value for loop (创建一个 Vector<T>，其元素来自双精度浮点值的for循环).

CreateByDouble<T>(double): Creates a Vector<T> whose components are of a specified double value (创建一个 Vector<T>，其元素为指定的双精度浮点值).

CreateByFunc<T>(Func<int, T>): Creates a new Vector<T> from a from the given Func<T, TResult> (从给定 Func<T, TResult> 创建一个新的 Vector<T> ) .

CreateByFunc<T, TUserdata>(Func<int, TUserdata, T>, TUserdata): Creates a new Vector<T> from a from the given Func<T1, T2, TResult> (从给定 Func<T1, T2, TResult> 创建一个新的 Vector<T> ) .

CreatePadding<T>(ReadOnlySpan<T>): Padding creates a new Vector<T> from a given span (从指定跨度补齐创建一个 Vector<T>). The element after values is initialized to 0(values 之后的元素会初始化为0).

CreatePadding<T>(ReadOnlySpan<T>, int, int): Padding creates a new Vector<T> from a given span starting at a specified index position (于指定索引位置开始，从指定跨度补齐创建一个 Vector<T>). The element after values is initialized to 0(values 之后的元素会初始化为0).

CreatePadding<T>(params T[]): Padding creates a new Vector<T> from a given array (从给定数组补齐创建一个新的 Vector<T> ). The element after values is initialized to 0(values 之后的元素会初始化为0).

CreatePadding<T>(T[], int, int): Padding creates a new Vector<T> from a given span starting at a specified index position (于指定索引位置开始，从指定跨度补齐创建一个 Vector<T>). The element after values is initialized to 0(values 之后的元素会初始化为0).

CreateRotate<T>(ReadOnlySpan<T>): Rotate creates a new Vector<T> from a given span (从指定跨度旋转创建一个 Vector<T>).

CreateRotate<T>(ReadOnlySpan<T>, int, int): Rotate creates a new Vector<T> from a given span starting at a specified index position (于指定索引位置开始，从指定跨度旋转创建一个 Vector<T>).

CreateRotate<T>(params T[]): Rotate creates a new Vector<T> from a given array (从给定数组旋转创建一个新的 Vector<T> ).

CreateRotate<T>(T[], int, int): Rotate creates a new Vector<T> from a given span starting at a specified index position (于指定索引位置开始，从指定跨度旋转创建一个 Vector<T>).

CreateScalar(Int128): Creates a new vector instance of element type Int128 with the first element initialized to the specified value and the remaining elements initialized to zero {创建新的元素类型为Int128的向量实例，其中首个元素已初始化为指定值并且其余元素已初始化为零}.

CreateScalar(UInt128): Creates a new vector instance of element type UInt128 with the first element initialized to the specified value and the remaining elements initialized to zero {创建新的元素类型为UInt128的向量实例，其中首个元素已初始化为指定值并且其余元素已初始化为零}.

CreateScalar(ExInt128): Creates a new vector instance of element type ExInt128 with the first element initialized to the specified value and the remaining elements initialized to zero {创建新的元素类型为ExInt128的向量实例，其中首个元素已初始化为指定值并且其余元素已初始化为零}.

CreateScalar(ExUInt128): Creates a new vector instance of element type ExUInt128 with the first element initialized to the specified value and the remaining elements initialized to zero {创建新的元素类型为ExUInt128的向量实例，其中首个元素已初始化为指定值并且其余元素已初始化为零}.

CreateScalarUnsafe(Int128): Creates a new vector instance of element type Int128 with the first element initialized to the specified value and the remaining elements left uninitialized (创建新的元素类型为Int128的向量实例，其中首个元素已初始化为指定值，而其余元素未初始化).

CreateScalarUnsafe(UInt128): Creates a new vector instance of element type UInt128 with the first element initialized to the specified value and the remaining elements left uninitialized (创建新的元素类型为UInt128的向量实例，其中首个元素已初始化为指定值，而其余元素未初始化).

CreateScalarUnsafe(ExInt128): Creates a new vector instance of element type ExInt128 with the first element initialized to the specified value and the remaining elements left uninitialized (创建新的元素类型为ExInt128的向量实例，其中首个元素已初始化为指定值，而其余元素未初始化).

CreateScalarUnsafe(ExUInt128): Creates a new vector instance of element type ExUInt128 with the first element initialized to the specified value and the remaining elements left uninitialized (创建新的元素类型为ExUInt128的向量实例，其中首个元素已初始化为指定值，而其余元素未初始化).

Create<T>(ReadOnlySpan<byte>): Creates a new Vector<T> from a given read-only span of bytes (根据给定的只读字节跨度构造一个 Vector<T>).

Create<T>(ReadOnlySpan<T>): Creates a new Vector<T> from a from the given ReadOnlySpan<T> (根据给定的 ReadOnlySpan<T> 构造一个 Vector<T>).

Create<T>(Span<T>): Creates a new Vector<T> from a from the given Span<T> (根据给定的 Span<T> 构造一个 Vector<T>).

Create<T>(T): Creates a new Vector<T> instance with all elements initialized to the specified value (创建新的 Vector<T> 实例，其中所有元素已初始化为指定值).

Create<T>(T[]): Creates a new Vector<T> from a given array (从给定数组创建一个新的 Vector<T> ).

Create<T>(T[], int): Creates a new Vector<T> from a given array starting at a specified index position (于指定索引位置开始，从指定数组创建一个 Vector<T>).

Dot(Vector<byte>, Vector<byte>): Computes the dot product of two vectors (计算两个向量的点积). Mnemonic: rt := left[0]*right[0] + left[1]*right[1] + left[2]*right[2] + ... + left[Count-1]*right[Count-1].

Dot(Vector<double>, Vector<double>): Computes the dot product of two vectors (计算两个向量的点积). Mnemonic: rt := left[0]*right[0] + left[1]*right[1] + left[2]*right[2] + ... + left[Count-1]*right[Count-1].

Dot(Vector<short>, Vector<short>): Computes the dot product of two vectors (计算两个向量的点积). Mnemonic: rt := left[0]*right[0] + left[1]*right[1] + left[2]*right[2] + ... + left[Count-1]*right[Count-1].

Dot(Vector<int>, Vector<int>): Computes the dot product of two vectors (计算两个向量的点积). Mnemonic: rt := left[0]*right[0] + left[1]*right[1] + left[2]*right[2] + ... + left[Count-1]*right[Count-1].

Dot(Vector<long>, Vector<long>): Computes the dot product of two vectors (计算两个向量的点积). Mnemonic: rt := left[0]*right[0] + left[1]*right[1] + left[2]*right[2] + ... + left[Count-1]*right[Count-1].

Dot(Vector<sbyte>, Vector<sbyte>): Computes the dot product of two vectors (计算两个向量的点积). Mnemonic: rt := left[0]*right[0] + left[1]*right[1] + left[2]*right[2] + ... + left[Count-1]*right[Count-1].

Dot(Vector<float>, Vector<float>): Computes the dot product of two vectors (计算两个向量的点积). Mnemonic: rt := left[0]*right[0] + left[1]*right[1] + left[2]*right[2] + ... + left[Count-1]*right[Count-1].

Dot(Vector<ushort>, Vector<ushort>): Computes the dot product of two vectors (计算两个向量的点积). Mnemonic: rt := left[0]*right[0] + left[1]*right[1] + left[2]*right[2] + ... + left[Count-1]*right[Count-1].

Dot(Vector<uint>, Vector<uint>): Computes the dot product of two vectors (计算两个向量的点积). Mnemonic: rt := left[0]*right[0] + left[1]*right[1] + left[2]*right[2] + ... + left[Count-1]*right[Count-1].

Dot(Vector<ulong>, Vector<ulong>): Computes the dot product of two vectors (计算两个向量的点积). Mnemonic: rt := left[0]*right[0] + left[1]*right[1] + left[2]*right[2] + ... + left[Count-1]*right[Count-1].

ExAsByte<T>(Vector<T>): (ExType) Reinterprets a Vector<T> as a new Vector<T> of type byte (将 Vector<T> 重新解释为 byte 类型的新 Vector<T>).

ExAsDouble<T>(Vector<T>): (ExType) Reinterprets a Vector<T> as a new Vector<T> of type double (将 Vector<T> 重新解释为 double 类型的新 Vector<T>).

ExAsExInt128<T>(Vector<T>): (ExType) Reinterprets a Vector<T> as a new Vector<T> of type ExInt128 (将 Vector<T> 重新解释为 ExInt128 类型的新 Vector<T>).

ExAsExUInt128<T>(Vector<T>): (ExType) Reinterprets a Vector<T> as a new Vector<T> of type ExUInt128 (将 Vector<T> 重新解释为 ExUInt128 类型的新 Vector<T>).

ExAsInt128<T>(Vector<T>): (ExType) Reinterprets a Vector<T> as a new Vector<T> of type Int128 (将 Vector<T> 重新解释为 Int128 类型的新 Vector<T>).

ExAsInt16<T>(Vector<T>): (ExType) Reinterprets a Vector<T> as a new Vector<T> of type short (将 Vector<T> 重新解释为 short 类型的新 Vector<T>).

ExAsInt32<T>(Vector<T>): (ExType) Reinterprets a Vector<T> as a new Vector<T> of type int (将 Vector<T> 重新解释为 int 类型的新 Vector<T>).

ExAsInt64<T>(Vector<T>): (ExType) Reinterprets a Vector<T> as a new Vector<T> of type long (将 Vector<T> 重新解释为 long 类型的新 Vector<T>).

ExAsSByte<T>(Vector<T>): (ExType) Reinterprets a Vector<T> as a new Vector<T> of type sbyte (将 Vector<T> 重新解释为 sbyte 类型的新 Vector<T>).

ExAsSingle<T>(Vector<T>): (ExType) Reinterprets a Vector<T> as a new Vector<T> of type float (将 Vector<T> 重新解释为 float 类型的新 Vector<T>).

ExAsUInt128<T>(Vector<T>): (ExType) Reinterprets a Vector<T> as a new Vector<T> of type UInt128 (将 Vector<T> 重新解释为 UInt128 类型的新 Vector<T>).

ExAsUInt16<T>(Vector<T>): (ExType) Reinterprets a Vector<T> as a new Vector<T> of type ushort (将 Vector<T> 重新解释为 ushort 类型的新 Vector<T>).

ExAsUInt32<T>(Vector<T>): (ExType) Reinterprets a Vector<T> as a new Vector<T> of type uint (将 Vector<T> 重新解释为 uint 类型的新 Vector<T>).

ExAsUInt64<T>(Vector<T>): (ExType) Reinterprets a Vector<T> as a new Vector<T> of type ulong (将 Vector<T> 重新解释为 ulong 类型的新 Vector<T>).

ExAs<TFrom, TTo>(Vector<TFrom>): (ExType) Reinterprets a Vector<T> of type TFrom as a new Vector<T> of type TTo. It supports ExType, so there is no element type check (将 TFrom 类型的 Vector<T> 重新解释为 TTo 类型的新 Vector<T>. 它支持扩展类型, 故没有元素类型检查).

ExGetElement<T>(in Vector<T>, int): (ExType) Gets the element at the specified index. It is unsafe method, it ignores the index range check (获取指定索引处的元素. 它是非安全的, 它忽略了索引的范围检查).

ExToScalar<T>(Vector<T>): Converts the given vector to a scalar containing the value of the first element (将给定向量转换为首个元素的值的标量).

ExtractMostSignificantBits(Vector<byte>): Extracts the most significant bit from each element in a vector (从向量的每个元素中提取最高有效位). Mnemonic: rt |= getMostSignificantBit(vector[i]) <>> (sizeof(T)*8-1) ) << i.

ExtractMostSignificantBits(Vector<double>): Extracts the most significant bit from each element in a vector (从向量的每个元素中提取最高有效位). Mnemonic: rt |= getMostSignificantBit(vector[i]) <>> (sizeof(T)*8-1) ) << i.

ExtractMostSignificantBits(Vector<short>): Extracts the most significant bit from each element in a vector (从向量的每个元素中提取最高有效位). Mnemonic: rt |= getMostSignificantBit(vector[i]) <>> (sizeof(T)*8-1) ) << i.

ExtractMostSignificantBits(Vector<int>): Extracts the most significant bit from each element in a vector (从向量的每个元素中提取最高有效位). Mnemonic: rt |= getMostSignificantBit(vector[i]) <>> (sizeof(T)*8-1) ) << i.

ExtractMostSignificantBits(Vector<long>): Extracts the most significant bit from each element in a vector (从向量的每个元素中提取最高有效位). Mnemonic: rt |= getMostSignificantBit(vector[i]) <>> (sizeof(T)*8-1) ) << i.

ExtractMostSignificantBits(Vector<sbyte>): Extracts the most significant bit from each element in a vector (从向量的每个元素中提取最高有效位). Mnemonic: rt |= getMostSignificantBit(vector[i]) <>> (sizeof(T)*8-1) ) << i.

ExtractMostSignificantBits(Vector<float>): Extracts the most significant bit from each element in a vector (从向量的每个元素中提取最高有效位). Mnemonic: rt |= getMostSignificantBit(vector[i]) <>> (sizeof(T)*8-1) ) << i.

ExtractMostSignificantBits(Vector<ushort>): Extracts the most significant bit from each element in a vector (从向量的每个元素中提取最高有效位). Mnemonic: rt |= getMostSignificantBit(vector[i]) <>> (sizeof(T)*8-1) ) << i.

ExtractMostSignificantBits(Vector<uint>): Extracts the most significant bit from each element in a vector (从向量的每个元素中提取最高有效位). Mnemonic: rt |= getMostSignificantBit(vector[i]) <>> (sizeof(T)*8-1) ) << i.

ExtractMostSignificantBits(Vector<ulong>): Extracts the most significant bit from each element in a vector (从向量的每个元素中提取最高有效位). Mnemonic: rt |= getMostSignificantBit(vector[i]) <>> (sizeof(T)*8-1) ) << i.

Floor(Vector<double>): Computes the floor of each element in a vector (计算向量中每个元素的向下取整). It is also known as round to negative infinity (它也被称作向负无穷舍入). See more: ToNegativeInfinity. Mnemonic: rt[i] := floor(value[i]).

Floor(Vector<float>): Computes the floor of each element in a vector (计算向量中每个元素的向下取整). It is also known as round to negative infinity (它也被称作向负无穷舍入). See more: ToNegativeInfinity. Mnemonic: rt[i] := floor(value[i]).

GenerateDemoElement<T>(int): Generate the elements of the Demo value (生成演示值的各元素).

GetIsSupported(bool): Gets it is support the run (取得它是否支持运行).

GetSupportedMethodListCallback<T>(Action<T>, params string[]): Get supported method list and output callback (取得支持的方法列表并输出到 callback ).

GetSupportedMethodListFill<T>(ICollection<T>, params string[]): Get supported method list and fill (取得支持的方法列表并填充).

GetSupportedMethodList<T>(params string[]): Get supported method list (取得支持的方法列表).

GetUnsupportedMessage(bool): Get unsupported messages (取得不支持时的消息).

GreaterThan_Unsigned(Vector<byte>, Vector<byte>): Compares two vectors to determine which is unsigned greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个是无符号更大). Mnemonic: rt[i] := (T)to_mask(asUnsigned(left[i]) > asUnsigned(right[i])).

GreaterThan_Unsigned(Vector<short>, Vector<short>): Compares two vectors to determine which is unsigned greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个是无符号更大). Mnemonic: rt[i] := (T)to_mask(asUnsigned(left[i]) > asUnsigned(right[i])).

GreaterThan_Unsigned(Vector<int>, Vector<int>): Compares two vectors to determine which is unsigned greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个是无符号更大). Mnemonic: rt[i] := (T)to_mask(asUnsigned(left[i]) > asUnsigned(right[i])).

GreaterThan_Unsigned(Vector<long>, Vector<long>): Compares two vectors to determine which is unsigned greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个是无符号更大). Mnemonic: rt[i] := (T)to_mask(asUnsigned(left[i]) > asUnsigned(right[i])).

GreaterThan_Unsigned(Vector<sbyte>, Vector<sbyte>): Compares two vectors to determine which is unsigned greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个是无符号更大). Mnemonic: rt[i] := (T)to_mask(asUnsigned(left[i]) > asUnsigned(right[i])).

GreaterThan_Unsigned(Vector<ushort>, Vector<ushort>): Compares two vectors to determine which is unsigned greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个是无符号更大). Mnemonic: rt[i] := (T)to_mask(asUnsigned(left[i]) > asUnsigned(right[i])).

GreaterThan_Unsigned(Vector<uint>, Vector<uint>): Compares two vectors to determine which is unsigned greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个是无符号更大). Mnemonic: rt[i] := (T)to_mask(asUnsigned(left[i]) > asUnsigned(right[i])).

GreaterThan_Unsigned(Vector<ulong>, Vector<ulong>): Compares two vectors to determine which is unsigned greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个是无符号更大). Mnemonic: rt[i] := (T)to_mask(asUnsigned(left[i]) > asUnsigned(right[i])).

IsNativeSupported<T>(): Determines if this element type is native supported (判断是否原生支持这种元素类型).

Multiply(Vector<byte>, Vector<byte>): Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic: rt[i] := left[i] * right[i].

Multiply(Vector<double>, Vector<double>): Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic: rt[i] := left[i] * right[i].

Multiply(Vector<short>, Vector<short>): Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic: rt[i] := left[i] * right[i].

Multiply(Vector<int>, Vector<int>): Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic: rt[i] := left[i] * right[i].

Multiply(Vector<long>, Vector<long>): Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic: rt[i] := left[i] * right[i].

Multiply(Vector<sbyte>, Vector<sbyte>): Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic: rt[i] := left[i] * right[i].

Multiply(Vector<float>, Vector<float>): Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic: rt[i] := left[i] * right[i].

Multiply(Vector<ushort>, Vector<ushort>): Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic: rt[i] := left[i] * right[i].

Multiply(Vector<uint>, Vector<uint>): Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic: rt[i] := left[i] * right[i].

Multiply(Vector<ulong>, Vector<ulong>): Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic: rt[i] := left[i] * right[i].

Narrow(Vector<double>, Vector<double>): Narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例缩窄为一个 Vector<T> ). />. Mnemonic: rt[i] := narrow(element_ref(i, lower, upper)).

Narrow(Vector<short>, Vector<short>): Narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例缩窄为一个 Vector<T> ). />. Mnemonic: rt[i] := narrow(element_ref(i, lower, upper)).

Narrow(Vector<int>, Vector<int>): Narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例缩窄为一个 Vector<T> ). />. Mnemonic: rt[i] := narrow(element_ref(i, lower, upper)).

Narrow(Vector<long>, Vector<long>): Narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例缩窄为一个 Vector<T> ). />. Mnemonic: rt[i] := narrow(element_ref(i, lower, upper)).

Narrow(Vector<ushort>, Vector<ushort>): Narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例缩窄为一个 Vector<T> ). />. Mnemonic: rt[i] := narrow(element_ref(i, lower, upper)).

Narrow(Vector<uint>, Vector<uint>): Narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例缩窄为一个 Vector<T> ). />. Mnemonic: rt[i] := narrow(element_ref(i, lower, upper)).

Narrow(Vector<ulong>, Vector<ulong>): Narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例缩窄为一个 Vector<T> ). />. Mnemonic: rt[i] := narrow(element_ref(i, lower, upper)).

ShiftLeft(Vector<byte>, int): Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft(Vector<short>, int): Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft(Vector<int>, int): Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft(Vector<long>, int): Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft(Vector<sbyte>, int): Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft(Vector<ushort>, int): Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft(Vector<uint>, int): Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft(Vector<ulong>, int): Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Args(Vector<byte>, int): Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Args(Vector<byte>, int, out Vector<byte>): Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Args(Vector<short>, int): Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Args(Vector<short>, int, out Vector<short>): Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Args(Vector<int>, int): Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Args(Vector<int>, int, out Vector<int>): Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Args(Vector<long>, int): Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Args(Vector<long>, int, out Vector<long>): Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Args(Vector<sbyte>, int): Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Args(Vector<sbyte>, int, out Vector<sbyte>): Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Args(Vector<ushort>, int): Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Args(Vector<ushort>, int, out Vector<ushort>): Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Args(Vector<uint>, int): Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Args(Vector<uint>, int, out Vector<uint>): Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Args(Vector<ulong>, int): Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Args(Vector<ulong>, int, out Vector<ulong>): Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Args<T>(Vector<T>, int): Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Const(Vector<byte>, int): Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_Const(Vector<short>, int): Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_Const(Vector<int>, int): Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_Const(Vector<long>, int): Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_Const(Vector<sbyte>, int): Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_Const(Vector<ushort>, int): Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_Const(Vector<uint>, int): Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_Const(Vector<ulong>, int): Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_ConstCore(Vector<byte>, int, Vector<byte>, Vector<byte>): Core calculation for shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量的核心计算 - 常量). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_ConstCore(Vector<short>, int, Vector<short>, Vector<short>): Core calculation for shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量的核心计算 - 常量). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_ConstCore(Vector<int>, int, Vector<int>, Vector<int>): Core calculation for shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量的核心计算 - 常量). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_ConstCore(Vector<long>, int, Vector<long>, Vector<long>): Core calculation for shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量的核心计算 - 常量). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_ConstCore(Vector<sbyte>, int, Vector<sbyte>, Vector<sbyte>): Core calculation for shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量的核心计算 - 常量). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_ConstCore(Vector<ushort>, int, Vector<ushort>, Vector<ushort>): Core calculation for shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量的核心计算 - 常量). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_ConstCore(Vector<uint>, int, Vector<uint>, Vector<uint>): Core calculation for shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量的核心计算 - 常量). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_ConstCore(Vector<ulong>, int, Vector<ulong>, Vector<ulong>): Core calculation for shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量的核心计算 - 常量). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_Core(Vector<byte>, int, Vector<byte>, Vector<byte>): Core calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的核心计算). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Core(Vector<short>, int, Vector<short>, Vector<short>): Core calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的核心计算). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Core(Vector<short>, Vector<short>, Vector<short>): Core calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的核心计算). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Core(Vector<int>, int, Vector<int>, Vector<int>): Core calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的核心计算). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Core(Vector<long>, int, Vector<long>, Vector<long>): Core calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的核心计算). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Core(Vector<sbyte>, int, Vector<sbyte>, Vector<sbyte>): Core calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的核心计算). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Core(Vector<ushort>, int, Vector<ushort>, Vector<ushort>): Core calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的核心计算). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Core(Vector<uint>, int, Vector<uint>, Vector<uint>): Core calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的核心计算). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Core(Vector<ulong>, int, Vector<ulong>, Vector<ulong>): Core calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的核心计算). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic: rt[i] := value[i] << shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftLeft_Fast(Vector<byte>, int): Shifts each element of a vector left by the specified amount - Fast (将向量的每个元素左移指定量 - 快速). No check shiftAmount, please use LimitShiftAmount<T>(int) first. Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_Fast(Vector<short>, int): Shifts each element of a vector left by the specified amount - Fast (将向量的每个元素左移指定量 - 快速). No check shiftAmount, please use LimitShiftAmount<T>(int) first. Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_Fast(Vector<int>, int): Shifts each element of a vector left by the specified amount - Fast (将向量的每个元素左移指定量 - 快速). No check shiftAmount, please use LimitShiftAmount<T>(int) first. Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_Fast(Vector<long>, int): Shifts each element of a vector left by the specified amount - Fast (将向量的每个元素左移指定量 - 快速). No check shiftAmount, please use LimitShiftAmount<T>(int) first. Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_Fast(Vector<sbyte>, int): Shifts each element of a vector left by the specified amount - Fast (将向量的每个元素左移指定量 - 快速). No check shiftAmount, please use LimitShiftAmount<T>(int) first. Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_Fast(Vector<ushort>, int): Shifts each element of a vector left by the specified amount - Fast (将向量的每个元素左移指定量 - 快速). No check shiftAmount, please use LimitShiftAmount<T>(int) first. Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_Fast(Vector<uint>, int): Shifts each element of a vector left by the specified amount - Fast (将向量的每个元素左移指定量 - 快速). No check shiftAmount, please use LimitShiftAmount<T>(int) first. Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftLeft_Fast(Vector<ulong>, int): Shifts each element of a vector left by the specified amount - Fast (将向量的每个元素左移指定量 - 快速). No check shiftAmount, please use LimitShiftAmount<T>(int) first. Mnemonic: rt[i] := value[i] << shiftAmount.

ShiftRightArithmetic(Vector<short>, int): Shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量). Mnemonic: rt[i] := value[i] >> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightArithmetic(Vector<int>, int): Shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量). Mnemonic: rt[i] := value[i] >> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightArithmetic(Vector<long>, int): Shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量). Mnemonic: rt[i] := value[i] >> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightArithmetic(Vector<sbyte>, int): Shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量). Mnemonic: rt[i] := value[i] >> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightArithmetic_Args(Vector<short>, int): Arguments calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的参数计算). Provide arguments for ShiftRightArithmetic_Core (为 ShiftRightArithmetic_Core 提供参数). Mnemonic: rt[i] := value[i] >> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightArithmetic_Args(Vector<short>, int, out Vector<short>): Arguments calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的参数计算). Provide arguments for ShiftRightArithmetic_Core (为 ShiftRightArithmetic_Core 提供参数). Mnemonic: rt[i] := value[i] >> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightArithmetic_Args(Vector<int>, int): Arguments calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的参数计算). Provide arguments for ShiftRightArithmetic_Core (为 ShiftRightArithmetic_Core 提供参数). Mnemonic: rt[i] := value[i] >> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightArithmetic_Args(Vector<int>, int, out Vector<int>): Arguments calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的参数计算). Provide arguments for ShiftRightArithmetic_Core (为 ShiftRightArithmetic_Core 提供参数). Mnemonic: rt[i] := value[i] >> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightArithmetic_Args(Vector<long>, int): Arguments calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的参数计算). Provide arguments for ShiftRightArithmetic_Core (为 ShiftRightArithmetic_Core 提供参数). Mnemonic: rt[i] := value[i] >> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightArithmetic_Args(Vector<long>, int, out Vector<long>): Arguments calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的参数计算). Provide arguments for ShiftRightArithmetic_Core (为 ShiftRightArithmetic_Core 提供参数). Mnemonic: rt[i] := value[i] >> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightArithmetic_Args(Vector<sbyte>, int): Arguments calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的参数计算). Provide arguments for ShiftRightArithmetic_Core (为 ShiftRightArithmetic_Core 提供参数). Mnemonic: rt[i] := value[i] >> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightArithmetic_Args(Vector<sbyte>, int, out Vector<sbyte>): Arguments calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的参数计算). Provide arguments for ShiftRightArithmetic_Core (为 ShiftRightArithmetic_Core 提供参数). Mnemonic: rt[i] := value[i] >> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightArithmetic_Args<T>(Vector<T>, int): Arguments calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的参数计算). Provide arguments for ShiftRightArithmetic_Core (为 ShiftRightArithmetic_Core 提供参数). Mnemonic: rt[i] := value[i] >> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightArithmetic_Const(Vector<short>, int): Shifts (signed) each element of a vector right by the specified amount - Const(将向量的每个有符号元素算术右移指定量 - 常量). Mnemonic: rt[i] := value[i] >> shiftAmount.

ShiftRightArithmetic_Const(Vector<int>, int): Shifts (signed) each element of a vector right by the specified amount - Const(将向量的每个有符号元素算术右移指定量 - 常量). Mnemonic: rt[i] := value[i] >> shiftAmount.

ShiftRightArithmetic_Const(Vector<long>, int): Shifts (signed) each element of a vector right by the specified amount - Const(将向量的每个有符号元素算术右移指定量 - 常量). Mnemonic: rt[i] := value[i] >> shiftAmount.

ShiftRightArithmetic_Const(Vector<sbyte>, int): Shifts (signed) each element of a vector right by the specified amount - Const(将向量的每个有符号元素算术右移指定量 - 常量). Mnemonic: rt[i] := value[i] >> shiftAmount.

ShiftRightArithmetic_ConstCore(Vector<short>, int, Vector<short>, Vector<short>): Core calculation for shifts (signed) each element of a vector right by the specified amount - Const (将向量的每个有符号元素算术右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightArithmetic_Args (其参数来源于 ShiftRightArithmetic_Args). Mnemonic: rt[i] := value[i] >> shiftAmount.

ShiftRightArithmetic_ConstCore(Vector<int>, int, Vector<int>, Vector<int>): Core calculation for shifts (signed) each element of a vector right by the specified amount - Const (将向量的每个有符号元素算术右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightArithmetic_Args (其参数来源于 ShiftRightArithmetic_Args). Mnemonic: rt[i] := value[i] >> shiftAmount.

ShiftRightArithmetic_ConstCore(Vector<long>, int, Vector<long>, Vector<long>): Core calculation for shifts (signed) each element of a vector right by the specified amount - Const (将向量的每个有符号元素算术右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightArithmetic_Args (其参数来源于 ShiftRightArithmetic_Args). Mnemonic: rt[i] := value[i] >> shiftAmount.

ShiftRightArithmetic_ConstCore(Vector<sbyte>, int, Vector<sbyte>, Vector<sbyte>): Core calculation for shifts (signed) each element of a vector right by the specified amount - Const (将向量的每个有符号元素算术右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightArithmetic_Args (其参数来源于 ShiftRightArithmetic_Args). Mnemonic: rt[i] := value[i] >> shiftAmount.

ShiftRightArithmetic_Core(Vector<short>, int, Vector<short>, Vector<short>): Core calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的核心计算). Its arguments are derived from ShiftRightArithmetic_Args (其参数来源于 ShiftRightArithmetic_Args). Mnemonic: rt[i] := value[i] >> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightArithmetic_Core(Vector<int>, int, Vector<int>, Vector<int>): Core calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的核心计算). Its arguments are derived from ShiftRightArithmetic_Args (其参数来源于 ShiftRightArithmetic_Args). Mnemonic: rt[i] := value[i] >> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightArithmetic_Core(Vector<long>, int, Vector<long>, Vector<long>): Core calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的核心计算). Its arguments are derived from ShiftRightArithmetic_Args (其参数来源于 ShiftRightArithmetic_Args). Mnemonic: rt[i] := value[i] >> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightArithmetic_Core(Vector<sbyte>, int, Vector<sbyte>, Vector<sbyte>): Core calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的核心计算). Its arguments are derived from ShiftRightArithmetic_Args (其参数来源于 ShiftRightArithmetic_Args). Mnemonic: rt[i] := value[i] >> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightArithmetic_Fast(Vector<short>, int): Shifts (signed) each element of a vector right by the specified amount - Fast(将向量的每个有符号元素算术右移指定量 - 快速). No check shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic: rt[i] := value[i] >> shiftAmount.

ShiftRightArithmetic_Fast(Vector<int>, int): Shifts (signed) each element of a vector right by the specified amount - Fast(将向量的每个有符号元素算术右移指定量 - 快速). No check shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic: rt[i] := value[i] >> shiftAmount.

ShiftRightArithmetic_Fast(Vector<long>, int): Shifts (signed) each element of a vector right by the specified amount - Fast(将向量的每个有符号元素算术右移指定量 - 快速). No check shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic: rt[i] := value[i] >> shiftAmount.

ShiftRightArithmetic_Fast(Vector<sbyte>, int): Shifts (signed) each element of a vector right by the specified amount - Fast(将向量的每个有符号元素算术右移指定量 - 快速). No check shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic: rt[i] := value[i] >> shiftAmount.

ShiftRightLogical(Vector<byte>, int): Shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical(Vector<short>, int): Shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical(Vector<int>, int): Shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical(Vector<long>, int): Shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical(Vector<sbyte>, int): Shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical(Vector<ushort>, int): Shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical(Vector<uint>, int): Shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical(Vector<ulong>, int): Shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Args(Vector<byte>, int): Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Args(Vector<byte>, int, out Vector<byte>): Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Args(Vector<short>, int): Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Args(Vector<short>, int, out Vector<short>): Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Args(Vector<int>, int): Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Args(Vector<int>, int, out Vector<int>): Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Args(Vector<long>, int): Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Args(Vector<long>, int, out Vector<long>): Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Args(Vector<sbyte>, int): Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Args(Vector<sbyte>, int, out Vector<sbyte>): Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Args(Vector<ushort>, int): Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Args(Vector<ushort>, int, out Vector<ushort>): Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Args(Vector<uint>, int): Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Args(Vector<uint>, int, out Vector<uint>): Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Args(Vector<ulong>, int): Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Args(Vector<ulong>, int, out Vector<ulong>): Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Args<T>(Vector<T>, int): Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Const(Vector<byte>, int): Shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量 - 常量). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Const(Vector<short>, int): Shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量 - 常量). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Const(Vector<int>, int): Shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量 - 常量). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Const(Vector<long>, int): Shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量 - 常量). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Const(Vector<sbyte>, int): Shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量 - 常量). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Const(Vector<ushort>, int): Shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量 - 常量). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Const(Vector<uint>, int): Shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量 - 常量). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Const(Vector<ulong>, int): Shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量 - 常量). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_ConstCore(Vector<byte>, int, Vector<byte>, Vector<byte>): Core calculation for shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic: rt[i] := value[i] >>> shiftAmount.

ShiftRightLogical_ConstCore(Vector<short>, int, Vector<short>, Vector<short>): Core calculation for shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic: rt[i] := value[i] >>> shiftAmount.

ShiftRightLogical_ConstCore(Vector<int>, int, Vector<int>, Vector<int>): Core calculation for shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic: rt[i] := value[i] >>> shiftAmount.

ShiftRightLogical_ConstCore(Vector<long>, int, Vector<long>, Vector<long>): Core calculation for shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic: rt[i] := value[i] >>> shiftAmount.

ShiftRightLogical_ConstCore(Vector<sbyte>, int, Vector<sbyte>, Vector<sbyte>): Core calculation for shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic: rt[i] := value[i] >>> shiftAmount.

ShiftRightLogical_ConstCore(Vector<ushort>, int, Vector<ushort>, Vector<ushort>): Core calculation for shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic: rt[i] := value[i] >>> shiftAmount.

ShiftRightLogical_ConstCore(Vector<uint>, int, Vector<uint>, Vector<uint>): Core calculation for shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic: rt[i] := value[i] >>> shiftAmount.

ShiftRightLogical_ConstCore(Vector<ulong>, int, Vector<ulong>, Vector<ulong>): Core calculation for shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic: rt[i] := value[i] >>> shiftAmount.

ShiftRightLogical_Core(Vector<byte>, int, Vector<byte>, Vector<byte>): Core calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的核心计算). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Core(Vector<short>, int, Vector<short>, Vector<short>): Core calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的核心计算). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Core(Vector<int>, int, Vector<int>, Vector<int>): Core calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的核心计算). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Core(Vector<long>, int, Vector<long>, Vector<long>): Core calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的核心计算). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Core(Vector<sbyte>, int, Vector<sbyte>, Vector<sbyte>): Core calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的核心计算). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Core(Vector<ushort>, int, Vector<ushort>, Vector<ushort>): Core calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的核心计算). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Core(Vector<uint>, int, Vector<uint>, Vector<uint>): Core calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的核心计算). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Core(Vector<ulong>, int, Vector<ulong>, Vector<ulong>): Core calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的核心计算). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic: rt[i] := value[i] >>> shiftAmount, shiftAmount &= (T.BitSize-1).

ShiftRightLogical_Fast(Vector<byte>, int): Shifts (unsigned) each element of a vector right by the specified amount. - Fast(将向量的每个无符号元素逻辑右移指定量 - 快速). No check shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic: rt[i] := value[i] >>> shiftAmount.

ShiftRightLogical_Fast(Vector<short>, int): Shifts (unsigned) each element of a vector right by the specified amount. - Fast(将向量的每个无符号元素逻辑右移指定量 - 快速). No check shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic: rt[i] := value[i] >>> shiftAmount.

ShiftRightLogical_Fast(Vector<int>, int): Shifts (unsigned) each element of a vector right by the specified amount. - Fast(将向量的每个无符号元素逻辑右移指定量 - 快速). No check shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic: rt[i] := value[i] >>> shiftAmount.

ShiftRightLogical_Fast(Vector<long>, int): Shifts (unsigned) each element of a vector right by the specified amount. - Fast(将向量的每个无符号元素逻辑右移指定量 - 快速). No check shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic: rt[i] := value[i] >>> shiftAmount.

ShiftRightLogical_Fast(Vector<sbyte>, int): Shifts (unsigned) each element of a vector right by the specified amount. - Fast(将向量的每个无符号元素逻辑右移指定量 - 快速). No check shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic: rt[i] := value[i] >>> shiftAmount.

ShiftRightLogical_Fast(Vector<ushort>, int): Shifts (unsigned) each element of a vector right by the specified amount. - Fast(将向量的每个无符号元素逻辑右移指定量 - 快速). No check shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic: rt[i] := value[i] >>> shiftAmount.

ShiftRightLogical_Fast(Vector<uint>, int): Shifts (unsigned) each element of a vector right by the specified amount. - Fast(将向量的每个无符号元素逻辑右移指定量 - 快速). No check shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic: rt[i] := value[i] >>> shiftAmount.

ShiftRightLogical_Fast(Vector<ulong>, int): Shifts (unsigned) each element of a vector right by the specified amount. - Fast(将向量的每个无符号元素逻辑右移指定量 - 快速). No check shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic: rt[i] := value[i] >>> shiftAmount.

Shuffle(Vector<byte>, Vector<byte>): Shuffle and clear (换位并清零). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle(Vector<double>, Vector<long>): Shuffle and clear (换位并清零). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle(Vector<short>, Vector<short>): Shuffle and clear (换位并清零). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle(Vector<int>, Vector<int>): Shuffle and clear (换位并清零). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle(Vector<long>, Vector<long>): Shuffle and clear (换位并清零). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle(Vector<sbyte>, Vector<sbyte>): Shuffle and clear (换位并清零). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle(Vector<float>, Vector<int>): Shuffle and clear (换位并清零). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle(Vector<ushort>, Vector<ushort>): Shuffle and clear (换位并清零). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle(Vector<uint>, Vector<uint>): Shuffle and clear (换位并清零). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle(Vector<ulong>, Vector<ulong>): Shuffle and clear (换位并清零). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Args(Vector<byte>): Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Args(Vector<byte>, out Vector<byte>, out Vector<byte>): Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Args(Vector<short>): Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Args(Vector<short>, out Vector<short>, out Vector<short>): Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Args(Vector<int>): Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Args(Vector<int>, out Vector<int>, out Vector<int>): Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Args(Vector<long>): Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Args(Vector<long>, out Vector<long>, out Vector<long>): Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Args(Vector<sbyte>): Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Args(Vector<ushort>): Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>): Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Args(Vector<uint>): Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Args(Vector<uint>, out Vector<uint>, out Vector<uint>): Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Args(Vector<ulong>): Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>): Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Args<TIdx>(Vector<TIdx>): Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Args<TIdx>(Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>): Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Core(Vector<byte>, Vector<byte>, Vector<byte>): Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Core(Vector<byte>, (Vector<byte> args0, Vector<byte> args1)): Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Core(Vector<double>, Vector<long>, Vector<long>): Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Core(Vector<double>, (Vector<long> args0, Vector<long> args1)): Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Core(Vector<short>, Vector<short>, Vector<short>): Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Core(Vector<short>, (Vector<short> args0, Vector<short> args1)): Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Core(Vector<int>, Vector<int>, Vector<int>): Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Core(Vector<int>, (Vector<int> args0, Vector<int> args1)): Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Core(Vector<long>, Vector<long>, Vector<long>): Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Core(Vector<long>, (Vector<long> args0, Vector<long> args1)): Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Core(Vector<sbyte>, (Vector<sbyte> args0, Vector<sbyte> args1)): Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Core(Vector<float>, Vector<int>, Vector<int>): Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Core(Vector<float>, (Vector<int> args0, Vector<int> args1)): Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>): Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Core(Vector<ushort>, (Vector<ushort> args0, Vector<ushort> args1)): Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Core(Vector<uint>, Vector<uint>, Vector<uint>): Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Core(Vector<uint>, (Vector<uint> args0, Vector<uint> args1)): Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>): Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Shuffle_Core(Vector<ulong>, (Vector<ulong> args0, Vector<ulong> args1)): Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.

Sqrt(Vector<byte>): Computes the square root of a vector on a per-element basis (计算向量中每个元素的平方根). Mnemonic: rt[i] := sqrt(vector[i]) = pow(vector[i], 1.0/2). When x is less than 0, floating-point types return NaN, integer types return 0.

Sqrt(Vector<double>): Computes the square root of a vector on a per-element basis (计算向量中每个元素的平方根). Mnemonic: rt[i] := sqrt(vector[i]) = pow(vector[i], 1.0/2). When x is less than 0, floating-point types return NaN, integer types return 0.

Sqrt(Vector<short>): Computes the square root of a vector on a per-element basis (计算向量中每个元素的平方根). Mnemonic: rt[i] := sqrt(vector[i]) = pow(vector[i], 1.0/2). When x is less than 0, floating-point types return NaN, integer types return 0.

Sqrt(Vector<int>): Computes the square root of a vector on a per-element basis (计算向量中每个元素的平方根). Mnemonic: rt[i] := sqrt(vector[i]) = pow(vector[i], 1.0/2). When x is less than 0, floating-point types return NaN, integer types return 0.

Sqrt(Vector<long>): Computes the square root of a vector on a per-element basis (计算向量中每个元素的平方根). Mnemonic: rt[i] := sqrt(vector[i]) = pow(vector[i], 1.0/2). When x is less than 0, floating-point types return NaN, integer types return 0.

Sqrt(Vector<sbyte>): Computes the square root of a vector on a per-element basis (计算向量中每个元素的平方根). Mnemonic: rt[i] := sqrt(vector[i]) = pow(vector[i], 1.0/2). When x is less than 0, floating-point types return NaN, integer types return 0.

Sqrt(Vector<float>): Computes the square root of a vector on a per-element basis (计算向量中每个元素的平方根). Mnemonic: rt[i] := sqrt(vector[i]) = pow(vector[i], 1.0/2). When x is less than 0, floating-point types return NaN, integer types return 0.

Sqrt(Vector<ushort>): Computes the square root of a vector on a per-element basis (计算向量中每个元素的平方根). Mnemonic: rt[i] := sqrt(vector[i]) = pow(vector[i], 1.0/2). When x is less than 0, floating-point types return NaN, integer types return 0.

Sqrt(Vector<uint>): Computes the square root of a vector on a per-element basis (计算向量中每个元素的平方根). Mnemonic: rt[i] := sqrt(vector[i]) = pow(vector[i], 1.0/2). When x is less than 0, floating-point types return NaN, integer types return 0.

Sqrt(Vector<ulong>): Computes the square root of a vector on a per-element basis (计算向量中每个元素的平方根). Mnemonic: rt[i] := sqrt(vector[i]) = pow(vector[i], 1.0/2). When x is less than 0, floating-point types return NaN, integer types return 0.

Sum(Vector<byte>): Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic: rt := value[0] + value[1] + value[2] + ... + value[Count-1].

Sum(Vector<double>): Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic: rt := value[0] + value[1] + value[2] + ... + value[Count-1].

Sum(Vector<short>): Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic: rt := value[0] + value[1] + value[2] + ... + value[Count-1].

Sum(Vector<int>): Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic: rt := value[0] + value[1] + value[2] + ... + value[Count-1].

Sum(Vector<long>): Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic: rt := value[0] + value[1] + value[2] + ... + value[Count-1].

Sum(Vector<sbyte>): Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic: rt := value[0] + value[1] + value[2] + ... + value[Count-1].

Sum(Vector<float>): Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic: rt := value[0] + value[1] + value[2] + ... + value[Count-1].

Sum(Vector<ushort>): Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic: rt := value[0] + value[1] + value[2] + ... + value[Count-1].

Sum(Vector<uint>): Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic: rt := value[0] + value[1] + value[2] + ... + value[Count-1].

Sum(Vector<ulong>): Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic: rt := value[0] + value[1] + value[2] + ... + value[Count-1].

ThrowForUnsupported(bool): Throw exception when not supported. (当不支持时抛出异常).

Widen(Vector<byte>): Widens a Vector<T> into two Vector<T> instances - Generic version (将一个 Vector<T> 扩宽为两个 Vector<T> 实例 - 泛型版). Mnemonic: element_ref(i, lower, upper) := widen(source[i]).

Widen(Vector<byte>, out Vector<ushort>, out Vector<ushort>): Widens a Vector<T> into two Vector<T> instances (将一个 Vector<T> 扩宽为两个 Vector<T> 实例). Mnemonic: element_ref(i, lower, upper) := widen(source[i]).

Widen(Vector<short>): Widens a Vector<T> into two Vector<T> instances - Generic version (将一个 Vector<T> 扩宽为两个 Vector<T> 实例 - 泛型版). Mnemonic: element_ref(i, lower, upper) := widen(source[i]).

Widen(Vector<short>, out Vector<int>, out Vector<int>): Widens a Vector<T> into two Vector<T> instances (将一个 Vector<T> 扩宽为两个 Vector<T> 实例). Mnemonic: element_ref(i, lower, upper) := widen(source[i]).

Widen(Vector<int>): Widens a Vector<T> into two Vector<T> instances - Generic version (将一个 Vector<T> 扩宽为两个 Vector<T> 实例 - 泛型版). Mnemonic: element_ref(i, lower, upper) := widen(source[i]).

Widen(Vector<int>, out Vector<long>, out Vector<long>): Widens a Vector<T> into two Vector<T> instances (将一个 Vector<T> 扩宽为两个 Vector<T> 实例). Mnemonic: element_ref(i, lower, upper) := widen(source[i]).

Widen(Vector<sbyte>): Widens a Vector<T> into two Vector<T> instances - Generic version (将一个 Vector<T> 扩宽为两个 Vector<T> 实例 - 泛型版). Mnemonic: element_ref(i, lower, upper) := widen(source[i]).

Widen(Vector<sbyte>, out Vector<short>, out Vector<short>): Widens a Vector<T> into two Vector<T> instances (将一个 Vector<T> 扩宽为两个 Vector<T> 实例). Mnemonic: element_ref(i, lower, upper) := widen(source[i]).

Widen(Vector<float>): Widens a Vector<T> into two Vector<T> instances - Generic version (将一个 Vector<T> 扩宽为两个 Vector<T> 实例 - 泛型版). Mnemonic: element_ref(i, lower, upper) := widen(source[i]).

Widen(Vector<float>, out Vector<double>, out Vector<double>): Widens a Vector<T> into two Vector<T> instances (将一个 Vector<T> 扩宽为两个 Vector<T> 实例). Mnemonic: element_ref(i, lower, upper) := widen(source[i]).

Widen(Vector<ushort>): Widens a Vector<T> into two Vector<T> instances - Generic version (将一个 Vector<T> 扩宽为两个 Vector<T> 实例 - 泛型版). Mnemonic: element_ref(i, lower, upper) := widen(source[i]).

Widen(Vector<ushort>, out Vector<uint>, out Vector<uint>): Widens a Vector<T> into two Vector<T> instances (将一个 Vector<T> 扩宽为两个 Vector<T> 实例). Mnemonic: element_ref(i, lower, upper) := widen(source[i]).

Widen(Vector<uint>): Widens a Vector<T> into two Vector<T> instances - Generic version (将一个 Vector<T> 扩宽为两个 Vector<T> 实例 - 泛型版). Mnemonic: element_ref(i, lower, upper) := widen(source[i]).

Widen(Vector<uint>, out Vector<ulong>, out Vector<ulong>): Widens a Vector<T> into two Vector<T> instances (将一个 Vector<T> 扩宽为两个 Vector<T> 实例). Mnemonic: element_ref(i, lower, upper) := widen(source[i]).

WidenLower(Vector<byte>): Widens the lower half of a Vector into a Vector (将向量的低半部分扩宽为一个向量). Mnemonic: rt[i] := widen(source[i]).

WidenLower(Vector<short>): Widens the lower half of a Vector into a Vector (将向量的低半部分扩宽为一个向量). Mnemonic: rt[i] := widen(source[i]).

WidenLower(Vector<int>): Widens the lower half of a Vector into a Vector (将向量的低半部分扩宽为一个向量). Mnemonic: rt[i] := widen(source[i]).

WidenLower(Vector<sbyte>): Widens the lower half of a Vector into a Vector (将向量的低半部分扩宽为一个向量). Mnemonic: rt[i] := widen(source[i]).

WidenLower(Vector<float>): Widens the lower half of a Vector into a Vector (将向量的低半部分扩宽为一个向量). Mnemonic: rt[i] := widen(source[i]).

WidenLower(Vector<ushort>): Widens the lower half of a Vector into a Vector (将向量的低半部分扩宽为一个向量). Mnemonic: rt[i] := widen(source[i]).

WidenLower(Vector<uint>): Widens the lower half of a Vector into a Vector (将向量的低半部分扩宽为一个向量). Mnemonic: rt[i] := widen(source[i]).

WidenUpper(Vector<byte>): Widens the upper half of a Vector into a Vector (将向量的高半部分扩宽为一个向量). Mnemonic: rt[i] := widen(source[i]).

WidenUpper(Vector<short>): Widens the upper half of a Vector into a Vector (将向量的高半部分扩宽为一个向量). Mnemonic: rt[i] := widen(source[i]).

WidenUpper(Vector<int>): Widens the upper half of a Vector into a Vector (将向量的高半部分扩宽为一个向量). Mnemonic: rt[i] := widen(source[i]).

WidenUpper(Vector<sbyte>): Widens the upper half of a Vector into a Vector (将向量的高半部分扩宽为一个向量). Mnemonic: rt[i] := widen(source[i]).

WidenUpper(Vector<float>): Widens the upper half of a Vector into a Vector (将向量的高半部分扩宽为一个向量). Mnemonic: rt[i] := widen(source[i]).

WidenUpper(Vector<ushort>): Widens the upper half of a Vector into a Vector (将向量的高半部分扩宽为一个向量). Mnemonic: rt[i] := widen(source[i]).

WidenUpper(Vector<uint>): Widens the upper half of a Vector into a Vector (将向量的高半部分扩宽为一个向量). Mnemonic: rt[i] := widen(source[i]).

Widen<T, TOut>(Vector<T>, out Vector<TOut>, out Vector<TOut>): Widens a Vector<T> into two Vector<T> instances - Generic version (将一个 Vector<T> 扩宽为两个 Vector<T> 实例 - 泛型版). Mnemonic: element_ref(i, lower, upper) := widen(source[i]).

YBitToByte(ulong): Converts binary bits to each element of the Byte vector (将各个二进制位转换为 Byte 向量的每个元素). Bit 0 meaning is 0, bit 1 meaning is 1 for all bits (MaxValue). Mnemonic: rt[i] := to_mask(0 != ((mask>>i)&1)).

YBitToInt16(ulong): Converts binary bits to each element of the Int16 vector (将各个二进制位转换为 Int16 向量的每个元素). Bit 0 meaning is 0, bit 1 meaning is 1 for all bits (-1). Mnemonic: rt[i] := to_mask(0 != ((mask>>i)&1)).

YBitToInt32(ulong): Converts binary bits to each element of the Int32 vector (将各个二进制位转换为 Int32 向量的每个元素). Bit 0 meaning is 0, bit 1 meaning is 1 for all bits (-1). Mnemonic: rt[i] := to_mask(0 != ((mask>>i)&1)).

YBitToInt64(ulong): Converts binary bits to each element of the Int64 vector (将各个二进制位转换为 Int64 向量的每个元素). Bit 0 meaning is 0, bit 1 meaning is 1 for all bits (-1). Mnemonic: rt[i] := to_mask(0 != ((mask>>i)&1)).

YClamp(Vector<byte>, Vector<byte>, Vector<byte>): Computes the numerical clamp of each element in a vector (计算向量中每个元素的数值限制). Mnemonic: rt[i] := clamp(value[i], amin[i], amax[i]) = min(max(amin[i], value[i]), amax[i]).

YClamp(Vector<double>, Vector<double>, Vector<double>): Computes the numerical clamp of each element in a vector (计算向量中每个元素的数值限制). Mnemonic: rt[i] := clamp(value[i], amin[i], amax[i]) = min(max(amin[i], value[i]), amax[i]).

YClamp(Vector<short>, Vector<short>, Vector<short>): Computes the numerical clamp of each element in a vector (计算向量中每个元素的数值限制). Mnemonic: rt[i] := clamp(value[i], amin[i], amax[i]) = min(max(amin[i], value[i]), amax[i]).

YClamp(Vector<int>, Vector<int>, Vector<int>): Computes the numerical clamp of each element in a vector (计算向量中每个元素的数值限制). Mnemonic: rt[i] := clamp(value[i], amin[i], amax[i]) = min(max(amin[i], value[i]), amax[i]).

YClamp(Vector<long>, Vector<long>, Vector<long>): Computes the numerical clamp of each element in a vector (计算向量中每个元素的数值限制). Mnemonic: rt[i] := clamp(value[i], amin[i], amax[i]) = min(max(amin[i], value[i]), amax[i]).

YClamp(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Computes the numerical clamp of each element in a vector (计算向量中每个元素的数值限制). Mnemonic: rt[i] := clamp(value[i], amin[i], amax[i]) = min(max(amin[i], value[i]), amax[i]).

YClamp(Vector<float>, Vector<float>, Vector<float>): Computes the numerical clamp of each element in a vector (计算向量中每个元素的数值限制). Mnemonic: rt[i] := clamp(value[i], amin[i], amax[i]) = min(max(amin[i], value[i]), amax[i]).

YClamp(Vector<ushort>, Vector<ushort>, Vector<ushort>): Computes the numerical clamp of each element in a vector (计算向量中每个元素的数值限制). Mnemonic: rt[i] := clamp(value[i], amin[i], amax[i]) = min(max(amin[i], value[i]), amax[i]).

YClamp(Vector<uint>, Vector<uint>, Vector<uint>): Computes the numerical clamp of each element in a vector (计算向量中每个元素的数值限制). Mnemonic: rt[i] := clamp(value[i], amin[i], amax[i]) = min(max(amin[i], value[i]), amax[i]).

YClamp(Vector<ulong>, Vector<ulong>, Vector<ulong>): Computes the numerical clamp of each element in a vector (计算向量中每个元素的数值限制). Mnemonic: rt[i] := clamp(value[i], amin[i], amax[i]) = min(max(amin[i], value[i]), amax[i]).

YCopySign(Vector<double>, Vector<double>): Copies the sign of a value to the sign of another value (将一个值的符号复制到另一个值). Mnemonic: rt[i] := copySign(value[i], sign[i]).

YCopySign(Vector<short>, Vector<short>): Copies the sign of a value to the sign of another value (将一个值的符号复制到另一个值). Mnemonic: rt[i] := copySign(value[i], sign[i]).

YCopySign(Vector<int>, Vector<int>): Copies the sign of a value to the sign of another value (将一个值的符号复制到另一个值). Mnemonic: rt[i] := copySign(value[i], sign[i]).

YCopySign(Vector<long>, Vector<long>): Copies the sign of a value to the sign of another value (将一个值的符号复制到另一个值). Mnemonic: rt[i] := copySign(value[i], sign[i]).

YCopySign(Vector<sbyte>, Vector<sbyte>): Copies the sign of a value to the sign of another value (将一个值的符号复制到另一个值). Mnemonic: rt[i] := copySign(value[i], sign[i]).

YCopySign(Vector<float>, Vector<float>): Copies the sign of a value to the sign of another value (将一个值的符号复制到另一个值). Mnemonic: rt[i] := copySign(value[i], sign[i]).

YGroup1ToGroup3(Vector<byte>): Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将灰度像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(x, x, x). View for element: element_ref(i, result0, result1, result2) := x[i/3].

YGroup1ToGroup3(Vector<byte>, out Vector<byte>, out Vector<byte>): Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将灰度像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(x, x, x). View for element: element_ref(i, result0, result1, result2) := x[i/3].

YGroup1ToGroup3(Vector<double>): Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将灰度像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(x, x, x). View for element: element_ref(i, result0, result1, result2) := x[i/3].

YGroup1ToGroup3(Vector<double>, out Vector<double>, out Vector<double>): Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将灰度像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(x, x, x). View for element: element_ref(i, result0, result1, result2) := x[i/3].

YGroup1ToGroup3(Vector<short>): Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将灰度像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(x, x, x). View for element: element_ref(i, result0, result1, result2) := x[i/3].

YGroup1ToGroup3(Vector<short>, out Vector<short>, out Vector<short>): Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将灰度像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(x, x, x). View for element: element_ref(i, result0, result1, result2) := x[i/3].

YGroup1ToGroup3(Vector<int>): Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将灰度像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(x, x, x). View for element: element_ref(i, result0, result1, result2) := x[i/3].

YGroup1ToGroup3(Vector<int>, out Vector<int>, out Vector<int>): Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将灰度像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(x, x, x). View for element: element_ref(i, result0, result1, result2) := x[i/3].

YGroup1ToGroup3(Vector<long>): Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将灰度像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(x, x, x). View for element: element_ref(i, result0, result1, result2) := x[i/3].

YGroup1ToGroup3(Vector<long>, out Vector<long>, out Vector<long>): Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将灰度像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(x, x, x). View for element: element_ref(i, result0, result1, result2) := x[i/3].

YGroup1ToGroup3(Vector<sbyte>): Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将灰度像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(x, x, x). View for element: element_ref(i, result0, result1, result2) := x[i/3].

YGroup1ToGroup3(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将灰度像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(x, x, x). View for element: element_ref(i, result0, result1, result2) := x[i/3].

YGroup1ToGroup3(Vector<float>): Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将灰度像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(x, x, x). View for element: element_ref(i, result0, result1, result2) := x[i/3].

YGroup1ToGroup3(Vector<float>, out Vector<float>, out Vector<float>): Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将灰度像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(x, x, x). View for element: element_ref(i, result0, result1, result2) := x[i/3].

YGroup1ToGroup3(Vector<ushort>): Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将灰度像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(x, x, x). View for element: element_ref(i, result0, result1, result2) := x[i/3].

YGroup1ToGroup3(Vector<ushort>, out Vector<ushort>, out Vector<ushort>): Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将灰度像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(x, x, x). View for element: element_ref(i, result0, result1, result2) := x[i/3].

YGroup1ToGroup3(Vector<uint>): Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将灰度像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(x, x, x). View for element: element_ref(i, result0, result1, result2) := x[i/3].

YGroup1ToGroup3(Vector<uint>, out Vector<uint>, out Vector<uint>): Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将灰度像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(x, x, x). View for element: element_ref(i, result0, result1, result2) := x[i/3].

YGroup1ToGroup3(Vector<ulong>): Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将灰度像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(x, x, x). View for element: element_ref(i, result0, result1, result2) := x[i/3].

YGroup1ToGroup3(Vector<ulong>, out Vector<ulong>, out Vector<ulong>): Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将灰度像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(x, x, x). View for element: element_ref(i, result0, result1, result2) := x[i/3].

YGroup1ToGroup3<T>(Vector<T>): Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将灰度像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(x, x, x). View for element: element_ref(i, result0, result1, result2) := x[i/3].

YGroup1ToGroup4(Vector<byte>): Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element: element_ref(i, result0, result1, result2, result4) := x[i/4].

YGroup1ToGroup4(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>): Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element: element_ref(i, result0, result1, result2, result4) := x[i/4].

YGroup1ToGroup4(Vector<double>): Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element: element_ref(i, result0, result1, result2, result4) := x[i/4].

YGroup1ToGroup4(Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>): Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element: element_ref(i, result0, result1, result2, result4) := x[i/4].

YGroup1ToGroup4(Vector<short>): Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element: element_ref(i, result0, result1, result2, result4) := x[i/4].

YGroup1ToGroup4(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>): Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element: element_ref(i, result0, result1, result2, result4) := x[i/4].

YGroup1ToGroup4(Vector<int>): Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element: element_ref(i, result0, result1, result2, result4) := x[i/4].

YGroup1ToGroup4(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>): Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element: element_ref(i, result0, result1, result2, result4) := x[i/4].

YGroup1ToGroup4(Vector<long>): Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element: element_ref(i, result0, result1, result2, result4) := x[i/4].

YGroup1ToGroup4(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>): Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element: element_ref(i, result0, result1, result2, result4) := x[i/4].

YGroup1ToGroup4(Vector<sbyte>): Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element: element_ref(i, result0, result1, result2, result4) := x[i/4].

YGroup1ToGroup4(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element: element_ref(i, result0, result1, result2, result4) := x[i/4].

YGroup1ToGroup4(Vector<float>): Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element: element_ref(i, result0, result1, result2, result4) := x[i/4].

YGroup1ToGroup4(Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>): Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element: element_ref(i, result0, result1, result2, result4) := x[i/4].

YGroup1ToGroup4(Vector<ushort>): Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element: element_ref(i, result0, result1, result2, result4) := x[i/4].

YGroup1ToGroup4(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>): Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element: element_ref(i, result0, result1, result2, result4) := x[i/4].

YGroup1ToGroup4(Vector<uint>): Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element: element_ref(i, result0, result1, result2, result4) := x[i/4].

YGroup1ToGroup4(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>): Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element: element_ref(i, result0, result1, result2, result4) := x[i/4].

YGroup1ToGroup4(Vector<ulong>): Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element: element_ref(i, result0, result1, result2, result4) := x[i/4].

YGroup1ToGroup4(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>): Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element: element_ref(i, result0, result1, result2, result4) := x[i/4].

YGroup1ToGroup4WithW(Vector<byte>, Vector<byte>): Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element: element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ), i2 := i/4.

YGroup1ToGroup4WithW(Vector<byte>, Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>): Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element: element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ), i2 := i/4.

YGroup1ToGroup4WithW(Vector<double>, Vector<double>): Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element: element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ), i2 := i/4.

YGroup1ToGroup4WithW(Vector<double>, Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>): Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element: element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ), i2 := i/4.

YGroup1ToGroup4WithW(Vector<short>, Vector<short>): Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element: element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ), i2 := i/4.

YGroup1ToGroup4WithW(Vector<short>, Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>): Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element: element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ), i2 := i/4.

YGroup1ToGroup4WithW(Vector<int>, Vector<int>): Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element: element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ), i2 := i/4.

YGroup1ToGroup4WithW(Vector<int>, Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>): Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element: element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ), i2 := i/4.

YGroup1ToGroup4WithW(Vector<long>, Vector<long>): Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element: element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ), i2 := i/4.

YGroup1ToGroup4WithW(Vector<long>, Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>): Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element: element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ), i2 := i/4.

YGroup1ToGroup4WithW(Vector<sbyte>, Vector<sbyte>): Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element: element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ), i2 := i/4.

YGroup1ToGroup4WithW(Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element: element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ), i2 := i/4.

YGroup1ToGroup4WithW(Vector<float>, Vector<float>): Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element: element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ), i2 := i/4.

YGroup1ToGroup4WithW(Vector<float>, Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>): Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element: element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ), i2 := i/4.

YGroup1ToGroup4WithW(Vector<ushort>, Vector<ushort>): Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element: element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ), i2 := i/4.

YGroup1ToGroup4WithW(Vector<ushort>, Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>): Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element: element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ), i2 := i/4.

YGroup1ToGroup4WithW(Vector<uint>, Vector<uint>): Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element: element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ), i2 := i/4.

YGroup1ToGroup4WithW(Vector<uint>, Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>): Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element: element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ), i2 := i/4.

YGroup1ToGroup4WithW(Vector<ulong>, Vector<ulong>): Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element: element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ), i2 := i/4.

YGroup1ToGroup4WithW(Vector<ulong>, Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>): Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element: element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ), i2 := i/4.

YGroup1ToGroup4WithW<T>(Vector<T>, Vector<T>): Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element: element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ), i2 := i/4.

YGroup1ToGroup4<T>(Vector<T>): Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将灰度像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element: element_ref(i, result0, result1, result2, result4) := x[i/4].

YGroup2Transpose(Vector<byte>, Vector<byte>): Transpose a 22 matrix (对22矩阵进行转置). Mnemonic: result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ), result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2Transpose(Vector<byte>, Vector<byte>, out Vector<byte>): Transpose a 22 matrix (对22矩阵进行转置). Mnemonic: result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ), result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2Transpose(Vector<double>, Vector<double>): Transpose a 22 matrix (对22矩阵进行转置). Mnemonic: result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ), result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2Transpose(Vector<double>, Vector<double>, out Vector<double>): Transpose a 22 matrix (对22矩阵进行转置). Mnemonic: result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ), result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2Transpose(Vector<short>, Vector<short>): Transpose a 22 matrix (对22矩阵进行转置). Mnemonic: result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ), result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2Transpose(Vector<short>, Vector<short>, out Vector<short>): Transpose a 22 matrix (对22矩阵进行转置). Mnemonic: result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ), result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2Transpose(Vector<int>, Vector<int>): Transpose a 22 matrix (对22矩阵进行转置). Mnemonic: result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ), result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2Transpose(Vector<int>, Vector<int>, out Vector<int>): Transpose a 22 matrix (对22矩阵进行转置). Mnemonic: result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ), result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2Transpose(Vector<long>, Vector<long>): Transpose a 22 matrix (对22矩阵进行转置). Mnemonic: result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ), result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2Transpose(Vector<long>, Vector<long>, out Vector<long>): Transpose a 22 matrix (对22矩阵进行转置). Mnemonic: result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ), result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2Transpose(Vector<sbyte>, Vector<sbyte>): Transpose a 22 matrix (对22矩阵进行转置). Mnemonic: result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ), result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2Transpose(Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>): Transpose a 22 matrix (对22矩阵进行转置). Mnemonic: result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ), result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2Transpose(Vector<float>, Vector<float>): Transpose a 22 matrix (对22矩阵进行转置). Mnemonic: result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ), result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2Transpose(Vector<float>, Vector<float>, out Vector<float>): Transpose a 22 matrix (对22矩阵进行转置). Mnemonic: result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ), result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2Transpose(Vector<ushort>, Vector<ushort>): Transpose a 22 matrix (对22矩阵进行转置). Mnemonic: result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ), result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2Transpose(Vector<ushort>, Vector<ushort>, out Vector<ushort>): Transpose a 22 matrix (对22矩阵进行转置). Mnemonic: result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ), result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2Transpose(Vector<uint>, Vector<uint>): Transpose a 22 matrix (对22矩阵进行转置). Mnemonic: result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ), result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2Transpose(Vector<uint>, Vector<uint>, out Vector<uint>): Transpose a 22 matrix (对22矩阵进行转置). Mnemonic: result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ), result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2Transpose(Vector<ulong>, Vector<ulong>): Transpose a 22 matrix (对22矩阵进行转置). Mnemonic: result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ), result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2Transpose(Vector<ulong>, Vector<ulong>, out Vector<ulong>): Transpose a 22 matrix (对22矩阵进行转置). Mnemonic: result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ), result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2TransposeEven(Vector<byte>, Vector<byte>): Transpose a 22 matrix and return a data in even positions (对22矩阵进行转置, 并返回偶数位置的数据). Mnemonic: rt[i] =: (0==(i&1))?( x[i&~1] ):( y[i&~1] ).

YGroup2TransposeEven(Vector<double>, Vector<double>): Transpose a 22 matrix and return a data in even positions (对22矩阵进行转置, 并返回偶数位置的数据). Mnemonic: rt[i] =: (0==(i&1))?( x[i&~1] ):( y[i&~1] ).

YGroup2TransposeEven(Vector<short>, Vector<short>): Transpose a 22 matrix and return a data in even positions (对22矩阵进行转置, 并返回偶数位置的数据). Mnemonic: rt[i] =: (0==(i&1))?( x[i&~1] ):( y[i&~1] ).

YGroup2TransposeEven(Vector<int>, Vector<int>): Transpose a 22 matrix and return a data in even positions (对22矩阵进行转置, 并返回偶数位置的数据). Mnemonic: rt[i] =: (0==(i&1))?( x[i&~1] ):( y[i&~1] ).

YGroup2TransposeEven(Vector<long>, Vector<long>): Transpose a 22 matrix and return a data in even positions (对22矩阵进行转置, 并返回偶数位置的数据). Mnemonic: rt[i] =: (0==(i&1))?( x[i&~1] ):( y[i&~1] ).

YGroup2TransposeEven(Vector<sbyte>, Vector<sbyte>): Transpose a 22 matrix and return a data in even positions (对22矩阵进行转置, 并返回偶数位置的数据). Mnemonic: rt[i] =: (0==(i&1))?( x[i&~1] ):( y[i&~1] ).

YGroup2TransposeEven(Vector<float>, Vector<float>): Transpose a 22 matrix and return a data in even positions (对22矩阵进行转置, 并返回偶数位置的数据). Mnemonic: rt[i] =: (0==(i&1))?( x[i&~1] ):( y[i&~1] ).

YGroup2TransposeEven(Vector<ushort>, Vector<ushort>): Transpose a 22 matrix and return a data in even positions (对22矩阵进行转置, 并返回偶数位置的数据). Mnemonic: rt[i] =: (0==(i&1))?( x[i&~1] ):( y[i&~1] ).

YGroup2TransposeEven(Vector<uint>, Vector<uint>): Transpose a 22 matrix and return a data in even positions (对22矩阵进行转置, 并返回偶数位置的数据). Mnemonic: rt[i] =: (0==(i&1))?( x[i&~1] ):( y[i&~1] ).

YGroup2TransposeEven(Vector<ulong>, Vector<ulong>): Transpose a 22 matrix and return a data in even positions (对22矩阵进行转置, 并返回偶数位置的数据). Mnemonic: rt[i] =: (0==(i&1))?( x[i&~1] ):( y[i&~1] ).

YGroup2TransposeOdd(Vector<byte>, Vector<byte>): Transpose a 22 matrix and return a data in odd positions (对22矩阵进行转置, 并返回奇数位置的数据). Mnemonic: rt[i] =: (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2TransposeOdd(Vector<double>, Vector<double>): Transpose a 22 matrix and return a data in odd positions (对22矩阵进行转置, 并返回奇数位置的数据). Mnemonic: rt[i] =: (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2TransposeOdd(Vector<short>, Vector<short>): Transpose a 22 matrix and return a data in odd positions (对22矩阵进行转置, 并返回奇数位置的数据). Mnemonic: rt[i] =: (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2TransposeOdd(Vector<int>, Vector<int>): Transpose a 22 matrix and return a data in odd positions (对22矩阵进行转置, 并返回奇数位置的数据). Mnemonic: rt[i] =: (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2TransposeOdd(Vector<long>, Vector<long>): Transpose a 22 matrix and return a data in odd positions (对22矩阵进行转置, 并返回奇数位置的数据). Mnemonic: rt[i] =: (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2TransposeOdd(Vector<sbyte>, Vector<sbyte>): Transpose a 22 matrix and return a data in odd positions (对22矩阵进行转置, 并返回奇数位置的数据). Mnemonic: rt[i] =: (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2TransposeOdd(Vector<float>, Vector<float>): Transpose a 22 matrix and return a data in odd positions (对22矩阵进行转置, 并返回奇数位置的数据). Mnemonic: rt[i] =: (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2TransposeOdd(Vector<ushort>, Vector<ushort>): Transpose a 22 matrix and return a data in odd positions (对22矩阵进行转置, 并返回奇数位置的数据). Mnemonic: rt[i] =: (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2TransposeOdd(Vector<uint>, Vector<uint>): Transpose a 22 matrix and return a data in odd positions (对22矩阵进行转置, 并返回奇数位置的数据). Mnemonic: rt[i] =: (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2TransposeOdd(Vector<ulong>, Vector<ulong>): Transpose a 22 matrix and return a data in odd positions (对22矩阵进行转置, 并返回奇数位置的数据). Mnemonic: rt[i] =: (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2Transpose<T>(Vector<T>, Vector<T>): Transpose a 22 matrix (对22矩阵进行转置). Mnemonic: result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ), result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).

YGroup2Unzip(Vector<byte>, Vector<byte>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<byte>, Vector<byte>, out Vector<byte>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<double>, Vector<double>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<double>, Vector<double>, out Vector<double>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<Int128>, Vector<Int128>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<Int128>, Vector<Int128>, out Vector<Int128>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<short>, Vector<short>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<short>, Vector<short>, out Vector<short>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<int>, Vector<int>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<int>, Vector<int>, out Vector<int>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<long>, Vector<long>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<long>, Vector<long>, out Vector<long>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<sbyte>, Vector<sbyte>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<float>, Vector<float>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<float>, Vector<float>, out Vector<float>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<UInt128>, Vector<UInt128>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<UInt128>, Vector<UInt128>, out Vector<UInt128>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<ushort>, Vector<ushort>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<ushort>, Vector<ushort>, out Vector<ushort>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<uint>, Vector<uint>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<uint>, Vector<uint>, out Vector<uint>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<ulong>, Vector<ulong>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<ulong>, Vector<ulong>, out Vector<ulong>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<ExInt128>, Vector<ExInt128>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<ExInt128>, Vector<ExInt128>, out Vector<ExInt128>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<ExUInt128>, Vector<ExUInt128>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip(Vector<ExUInt128>, Vector<ExUInt128>, out Vector<ExUInt128>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2UnzipEven(Vector<byte>, Vector<byte>): De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic: rt[i] =: element_ref(2*i, data0, data1).

YGroup2UnzipEven(Vector<double>, Vector<double>): De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic: rt[i] =: element_ref(2*i, data0, data1).

YGroup2UnzipEven(Vector<Int128>, Vector<Int128>): De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic: rt[i] =: element_ref(2*i, data0, data1).

YGroup2UnzipEven(Vector<short>, Vector<short>): De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic: rt[i] =: element_ref(2*i, data0, data1).

YGroup2UnzipEven(Vector<int>, Vector<int>): De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic: rt[i] =: element_ref(2*i, data0, data1).

YGroup2UnzipEven(Vector<long>, Vector<long>): De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic: rt[i] =: element_ref(2*i, data0, data1).

YGroup2UnzipEven(Vector<sbyte>, Vector<sbyte>): De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic: rt[i] =: element_ref(2*i, data0, data1).

YGroup2UnzipEven(Vector<float>, Vector<float>): De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic: rt[i] =: element_ref(2*i, data0, data1).

YGroup2UnzipEven(Vector<UInt128>, Vector<UInt128>): De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic: rt[i] =: element_ref(2*i, data0, data1).

YGroup2UnzipEven(Vector<ushort>, Vector<ushort>): De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic: rt[i] =: element_ref(2*i, data0, data1).

YGroup2UnzipEven(Vector<uint>, Vector<uint>): De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic: rt[i] =: element_ref(2*i, data0, data1).

YGroup2UnzipEven(Vector<ulong>, Vector<ulong>): De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic: rt[i] =: element_ref(2*i, data0, data1).

YGroup2UnzipEven(Vector<ExInt128>, Vector<ExInt128>): De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic: rt[i] =: element_ref(2*i, data0, data1).

YGroup2UnzipEven(Vector<ExUInt128>, Vector<ExUInt128>): De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic: rt[i] =: element_ref(2*i, data0, data1).

YGroup2UnzipEven<T>(Vector<T>, Vector<T>): De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic: rt[i] =: element_ref(2*i, data0, data1).

YGroup2UnzipOdd(Vector<byte>, Vector<byte>): De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic: rt[i] =: element_ref(2*i+1, data0, data1).

YGroup2UnzipOdd(Vector<double>, Vector<double>): De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic: rt[i] =: element_ref(2*i+1, data0, data1).

YGroup2UnzipOdd(Vector<Int128>, Vector<Int128>): De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic: rt[i] =: element_ref(2*i+1, data0, data1).

YGroup2UnzipOdd(Vector<short>, Vector<short>): De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic: rt[i] =: element_ref(2*i+1, data0, data1).

YGroup2UnzipOdd(Vector<int>, Vector<int>): De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic: rt[i] =: element_ref(2*i+1, data0, data1).

YGroup2UnzipOdd(Vector<long>, Vector<long>): De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic: rt[i] =: element_ref(2*i+1, data0, data1).

YGroup2UnzipOdd(Vector<sbyte>, Vector<sbyte>): De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic: rt[i] =: element_ref(2*i+1, data0, data1).

YGroup2UnzipOdd(Vector<float>, Vector<float>): De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic: rt[i] =: element_ref(2*i+1, data0, data1).

YGroup2UnzipOdd(Vector<UInt128>, Vector<UInt128>): De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic: rt[i] =: element_ref(2*i+1, data0, data1).

YGroup2UnzipOdd(Vector<ushort>, Vector<ushort>): De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic: rt[i] =: element_ref(2*i+1, data0, data1).

YGroup2UnzipOdd(Vector<uint>, Vector<uint>): De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic: rt[i] =: element_ref(2*i+1, data0, data1).

YGroup2UnzipOdd(Vector<ulong>, Vector<ulong>): De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic: rt[i] =: element_ref(2*i+1, data0, data1).

YGroup2UnzipOdd(Vector<ExInt128>, Vector<ExInt128>): De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic: rt[i] =: element_ref(2*i+1, data0, data1).

YGroup2UnzipOdd(Vector<ExUInt128>, Vector<ExUInt128>): De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic: rt[i] =: element_ref(2*i+1, data0, data1).

YGroup2UnzipOdd<T>(Vector<T>, Vector<T>): De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic: rt[i] =: element_ref(2*i+1, data0, data1).

YGroup2Unzip_Bit128<T>(Vector<T>, Vector<T>, out Vector<T>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). It is specialized for process 128-bit element (它专门用于处理128位元素). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Unzip<T>(Vector<T>, Vector<T>): De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的数组结构体转为结构体数组). Mnemonic: x[i] =: element_ref(2i, data0, data1), y[i] =: element_ref(2i+1, data0, data1).

YGroup2Zip(Vector<byte>, Vector<byte>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<byte>, Vector<byte>, out Vector<byte>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<double>, Vector<double>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<double>, Vector<double>, out Vector<double>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<Int128>, Vector<Int128>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<Int128>, Vector<Int128>, out Vector<Int128>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<short>, Vector<short>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<short>, Vector<short>, out Vector<short>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<int>, Vector<int>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<int>, Vector<int>, out Vector<int>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<long>, Vector<long>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<long>, Vector<long>, out Vector<long>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<sbyte>, Vector<sbyte>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<float>, Vector<float>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<float>, Vector<float>, out Vector<float>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<UInt128>, Vector<UInt128>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<UInt128>, Vector<UInt128>, out Vector<UInt128>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<ushort>, Vector<ushort>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<ushort>, Vector<ushort>, out Vector<ushort>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<uint>, Vector<uint>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<uint>, Vector<uint>, out Vector<uint>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<ulong>, Vector<ulong>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<ulong>, Vector<ulong>, out Vector<ulong>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<ExInt128>, Vector<ExInt128>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<ExInt128>, Vector<ExInt128>, out Vector<ExInt128>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<ExUInt128>, Vector<ExUInt128>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip(Vector<ExUInt128>, Vector<ExUInt128>, out Vector<ExUInt128>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2ZipHigh(Vector<byte>, Vector<byte>): Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := (i+T.Count)/2.

YGroup2ZipHigh(Vector<double>, Vector<double>): Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := (i+T.Count)/2.

YGroup2ZipHigh(Vector<Int128>, Vector<Int128>): Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := (i+T.Count)/2.

YGroup2ZipHigh(Vector<short>, Vector<short>): Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := (i+T.Count)/2.

YGroup2ZipHigh(Vector<int>, Vector<int>): Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := (i+T.Count)/2.

YGroup2ZipHigh(Vector<long>, Vector<long>): Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := (i+T.Count)/2.

YGroup2ZipHigh(Vector<sbyte>, Vector<sbyte>): Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := (i+T.Count)/2.

YGroup2ZipHigh(Vector<float>, Vector<float>): Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := (i+T.Count)/2.

YGroup2ZipHigh(Vector<UInt128>, Vector<UInt128>): Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := (i+T.Count)/2.

YGroup2ZipHigh(Vector<ushort>, Vector<ushort>): Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := (i+T.Count)/2.

YGroup2ZipHigh(Vector<uint>, Vector<uint>): Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := (i+T.Count)/2.

YGroup2ZipHigh(Vector<ulong>, Vector<ulong>): Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := (i+T.Count)/2.

YGroup2ZipHigh(Vector<ExInt128>, Vector<ExInt128>): Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := (i+T.Count)/2.

YGroup2ZipHigh(Vector<ExUInt128>, Vector<ExUInt128>): Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := (i+T.Count)/2.

YGroup2ZipHigh<T>(Vector<T>, Vector<T>): Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := (i+T.Count)/2.

YGroup2ZipLow(Vector<byte>, Vector<byte>): Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2ZipLow(Vector<double>, Vector<double>): Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2ZipLow(Vector<Int128>, Vector<Int128>): Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2ZipLow(Vector<short>, Vector<short>): Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2ZipLow(Vector<int>, Vector<int>): Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2ZipLow(Vector<long>, Vector<long>): Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2ZipLow(Vector<sbyte>, Vector<sbyte>): Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2ZipLow(Vector<float>, Vector<float>): Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2ZipLow(Vector<UInt128>, Vector<UInt128>): Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2ZipLow(Vector<ushort>, Vector<ushort>): Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2ZipLow(Vector<uint>, Vector<uint>): Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2ZipLow(Vector<ulong>, Vector<ulong>): Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2ZipLow(Vector<ExInt128>, Vector<ExInt128>): Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2ZipLow(Vector<ExUInt128>, Vector<ExUInt128>): Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2ZipLow<T>(Vector<T>, Vector<T>): Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic: rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip_Bit128<T>(Vector<T>, Vector<T>, out Vector<T>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). It is specialized for process 128-bit element (它专门用于处理128位元素). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup2Zip<T>(Vector<T>, Vector<T>): Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的结构体数组转为数组结构体). Mnemonic: element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ), i2 := i/2.

YGroup3ToGroup4(Vector<byte>, Vector<byte>, Vector<byte>): Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将已打包的RGB像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element: element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.

YGroup3ToGroup4(Vector<byte>, Vector<byte>, Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>): Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将已打包的RGB像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element: element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.

YGroup3ToGroup4(Vector<double>, Vector<double>, Vector<double>): Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将已打包的RGB像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element: element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.

YGroup3ToGroup4(Vector<double>, Vector<double>, Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>): Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将已打包的RGB像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element: element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.

YGroup3ToGroup4(Vector<short>, Vector<short>, Vector<short>): Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将已打包的RGB像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element: element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.

YGroup3ToGroup4(Vector<short>, Vector<short>, Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>): Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将已打包的RGB像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element: element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.

YGroup3ToGroup4(Vector<int>, Vector<int>, Vector<int>): Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将已打包的RGB像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element: element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.

YGroup3ToGroup4(Vector<int>, Vector<int>, Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>): Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将已打包的RGB像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element: element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.

YGroup3ToGroup4(Vector<long>, Vector<long>, Vector<long>): Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将已打包的RGB像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element: element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.

YGroup3ToGroup4(Vector<long>, Vector<long>, Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>): Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将已打包的RGB像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element: element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.

YGroup3ToGroup4(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将已打包的RGB像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element: element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.

YGroup3ToGroup4(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将已打包的RGB像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element: element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.

YGroup3ToGroup4(Vector<float>, Vector<float>, Vector<float>): Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将已打包的RGB像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element: element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.

YGroup3ToGroup4(Vector<float>, Vector<float>, Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>): Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将已打包的RGB像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element: element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.

YGroup3ToGroup4(Vector<ushort>, Vector<ushort>, Vector<ushort>): Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将已打包的RGB像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element: element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.

YGroup3ToGroup4(Vector<ushort>, Vector<ushort>, Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>): Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将已打包的RGB像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element: element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.

YGroup3ToGroup4(Vector<uint>, Vector<uint>, Vector<uint>): Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将已打包的RGB像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element: element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.

YGroup3ToGroup4(Vector<uint>, Vector<uint>, Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>): Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将已打包的RGB像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element: element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.

YGroup3ToGroup4(Vector<ulong>, Vector<ulong>, Vector<ulong>): Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将已打包的RGB像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element: element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.

YGroup3ToGroup4(Vector<ulong>, Vector<ulong>, Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>): Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将已打包的RGB像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element: element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.

YGroup3ToGroup4<T>(Vector<T>, Vector<T>, Vector<T>): Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将已打包的RGB像素数据, 转换为已打包的RGBA像素数据). Mnemonic: View for group: (result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element: element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.

YGroup3Unzip(Vector<byte>, Vector<byte>, Vector<byte>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3Unzip(Vector<byte>, Vector<byte>, Vector<byte>, out Vector<byte>, out Vector<byte>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3Unzip(Vector<double>, Vector<double>, Vector<double>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3Unzip(Vector<double>, Vector<double>, Vector<double>, out Vector<double>, out Vector<double>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3Unzip(Vector<short>, Vector<short>, Vector<short>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3Unzip(Vector<short>, Vector<short>, Vector<short>, out Vector<short>, out Vector<short>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3Unzip(Vector<int>, Vector<int>, Vector<int>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3Unzip(Vector<int>, Vector<int>, Vector<int>, out Vector<int>, out Vector<int>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3Unzip(Vector<long>, Vector<long>, Vector<long>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3Unzip(Vector<long>, Vector<long>, Vector<long>, out Vector<long>, out Vector<long>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3Unzip(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3Unzip(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3Unzip(Vector<float>, Vector<float>, Vector<float>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3Unzip(Vector<float>, Vector<float>, Vector<float>, out Vector<float>, out Vector<float>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3Unzip(Vector<ushort>, Vector<ushort>, Vector<ushort>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3Unzip(Vector<ushort>, Vector<ushort>, Vector<ushort>, out Vector<ushort>, out Vector<ushort>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3Unzip(Vector<uint>, Vector<uint>, Vector<uint>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3Unzip(Vector<uint>, Vector<uint>, Vector<uint>, out Vector<uint>, out Vector<uint>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3Unzip(Vector<ulong>, Vector<ulong>, Vector<ulong>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3Unzip(Vector<ulong>, Vector<ulong>, Vector<ulong>, out Vector<ulong>, out Vector<ulong>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3UnzipX2(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3UnzipX2(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3UnzipX2(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<double>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3UnzipX2(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3UnzipX2(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3UnzipX2(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3UnzipX2(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3UnzipX2(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3UnzipX2(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3UnzipX2(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3UnzipX2(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3UnzipX2(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3UnzipX2(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<float>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3UnzipX2(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3UnzipX2(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3UnzipX2(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3UnzipX2(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3UnzipX2(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3UnzipX2(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3UnzipX2(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3UnzipX2_Bit128<T>(Vector<T>, Vector<T>, Vector<T>, Vector<T>, Vector<T>, Vector<T>, out Vector<T>, out Vector<T>, out Vector<T>, out Vector<T>, out Vector<T>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). It is specialized for process 128-bit element (它专门用于处理128位元素). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3UnzipX2<T>(Vector<T>, Vector<T>, Vector<T>, Vector<T>, Vector<T>, Vector<T>): De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic: (x, y, z) = YGroup3Unzip(data0, data1, data2), (xB, yB, zB) = YGroup3Unzip(data3, data4, data5).

YGroup3Unzip_Bit128<T>(Vector<T>, Vector<T>, Vector<T>, out Vector<T>, out Vector<T>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). It is specialized for process 128-bit element (它专门用于处理128位元素). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3Unzip<T>(Vector<T>, Vector<T>, Vector<T>): De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的数组结构体转为结构体数组. 它还能将已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic: x[i] =: element_ref(3i, data0, data1, data2), y[i] =: element_ref(3i+1, data0, data1, data2), z[i] =: element_ref(3*i+2, data0, data1, data2).

YGroup3Zip(Vector<byte>, Vector<byte>, Vector<byte>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup3Zip(Vector<byte>, Vector<byte>, Vector<byte>, out Vector<byte>, out Vector<byte>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup3Zip(Vector<double>, Vector<double>, Vector<double>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup3Zip(Vector<double>, Vector<double>, Vector<double>, out Vector<double>, out Vector<double>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup3Zip(Vector<short>, Vector<short>, Vector<short>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup3Zip(Vector<short>, Vector<short>, Vector<short>, out Vector<short>, out Vector<short>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup3Zip(Vector<int>, Vector<int>, Vector<int>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup3Zip(Vector<int>, Vector<int>, Vector<int>, out Vector<int>, out Vector<int>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup3Zip(Vector<long>, Vector<long>, Vector<long>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup3Zip(Vector<long>, Vector<long>, Vector<long>, out Vector<long>, out Vector<long>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup3Zip(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup3Zip(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup3Zip(Vector<float>, Vector<float>, Vector<float>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup3Zip(Vector<float>, Vector<float>, Vector<float>, out Vector<float>, out Vector<float>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup3Zip(Vector<ushort>, Vector<ushort>, Vector<ushort>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup3Zip(Vector<ushort>, Vector<ushort>, Vector<ushort>, out Vector<ushort>, out Vector<ushort>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup3Zip(Vector<uint>, Vector<uint>, Vector<uint>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup3Zip(Vector<uint>, Vector<uint>, Vector<uint>, out Vector<uint>, out Vector<uint>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup3Zip(Vector<ulong>, Vector<ulong>, Vector<ulong>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup3Zip(Vector<ulong>, Vector<ulong>, Vector<ulong>, out Vector<ulong>, out Vector<ulong>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup3ZipX2(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3ZipX2(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3ZipX2(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<double>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3ZipX2(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3ZipX2(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3ZipX2(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3ZipX2(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3ZipX2(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3ZipX2(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3ZipX2(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3ZipX2(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3ZipX2(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3ZipX2(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<float>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3ZipX2(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3ZipX2(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3ZipX2(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3ZipX2(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3ZipX2(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3ZipX2(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3ZipX2(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3ZipX2_Bit128<T>(Vector<T>, Vector<T>, Vector<T>, Vector<T>, Vector<T>, Vector<T>, out Vector<T>, out Vector<T>, out Vector<T>, out Vector<T>, out Vector<T>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3ZipX2<T>(Vector<T>, Vector<T>, Vector<T>, Vector<T>, Vector<T>, Vector<T>): Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic: (data0, data1, data2) = YGroup3Zip(x, y, z), (data3, data4, data5) = YGroup3Zip(xB, yB, zB).

YGroup3Zip_Bit128<T>(Vector<T>, Vector<T>, Vector<T>, out Vector<T>, out Vector<T>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup3Zip<T>(Vector<T>, Vector<T>, Vector<T>): Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的结构体数组转为数组结构体. 它还能将 R,G,B 平面数据, 交织为已打包的RGB像素数据). Mnemonic: element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ), i2 := i/3.

YGroup4ToGroup3(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将已打包的RGBA像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element: element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).

YGroup4ToGroup3(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, out Vector<byte>, out Vector<byte>): Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将已打包的RGBA像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element: element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).

YGroup4ToGroup3(Vector<double>, Vector<double>, Vector<double>, Vector<double>): Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将已打包的RGBA像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element: element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).

YGroup4ToGroup3(Vector<double>, Vector<double>, Vector<double>, Vector<double>, out Vector<double>, out Vector<double>): Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将已打包的RGBA像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element: element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).

YGroup4ToGroup3(Vector<short>, Vector<short>, Vector<short>, Vector<short>): Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将已打包的RGBA像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element: element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).

YGroup4ToGroup3(Vector<short>, Vector<short>, Vector<short>, Vector<short>, out Vector<short>, out Vector<short>): Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将已打包的RGBA像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element: element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).

YGroup4ToGroup3(Vector<int>, Vector<int>, Vector<int>, Vector<int>): Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将已打包的RGBA像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element: element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).

YGroup4ToGroup3(Vector<int>, Vector<int>, Vector<int>, Vector<int>, out Vector<int>, out Vector<int>): Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将已打包的RGBA像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element: element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).

YGroup4ToGroup3(Vector<long>, Vector<long>, Vector<long>, Vector<long>): Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将已打包的RGBA像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element: element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).

YGroup4ToGroup3(Vector<long>, Vector<long>, Vector<long>, Vector<long>, out Vector<long>, out Vector<long>): Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将已打包的RGBA像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element: element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).

YGroup4ToGroup3(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将已打包的RGBA像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element: element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).

YGroup4ToGroup3(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将已打包的RGBA像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element: element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).

YGroup4ToGroup3(Vector<float>, Vector<float>, Vector<float>, Vector<float>): Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将已打包的RGBA像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element: element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).

YGroup4ToGroup3(Vector<float>, Vector<float>, Vector<float>, Vector<float>, out Vector<float>, out Vector<float>): Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将已打包的RGBA像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element: element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).

YGroup4ToGroup3(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将已打包的RGBA像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element: element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).

YGroup4ToGroup3(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, out Vector<ushort>, out Vector<ushort>): Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将已打包的RGBA像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element: element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).

YGroup4ToGroup3(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将已打包的RGBA像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element: element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).

YGroup4ToGroup3(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, out Vector<uint>, out Vector<uint>): Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将已打包的RGBA像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element: element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).

YGroup4ToGroup3(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将已打包的RGBA像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element: element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).

YGroup4ToGroup3(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, out Vector<ulong>, out Vector<ulong>): Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将已打包的RGBA像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element: element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).

YGroup4ToGroup3<T>(Vector<T>, Vector<T>, Vector<T>, Vector<T>): Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将已打包的RGBA像素数据, 转换为已打包的RGB像素数据). Mnemonic: View for group: (result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element: element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).

YGroup4Unzip(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<double>, Vector<double>, Vector<double>, Vector<double>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<double>, Vector<double>, Vector<double>, Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<Int128>, Vector<Int128>, Vector<Int128>, Vector<Int128>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<Int128>, Vector<Int128>, Vector<Int128>, Vector<Int128>, out Vector<Int128>, out Vector<Int128>, out Vector<Int128>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<short>, Vector<short>, Vector<short>, Vector<short>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<short>, Vector<short>, Vector<short>, Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<int>, Vector<int>, Vector<int>, Vector<int>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<int>, Vector<int>, Vector<int>, Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<long>, Vector<long>, Vector<long>, Vector<long>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<long>, Vector<long>, Vector<long>, Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<float>, Vector<float>, Vector<float>, Vector<float>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<float>, Vector<float>, Vector<float>, Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<UInt128>, Vector<UInt128>, Vector<UInt128>, Vector<UInt128>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<UInt128>, Vector<UInt128>, Vector<UInt128>, Vector<UInt128>, out Vector<UInt128>, out Vector<UInt128>, out Vector<UInt128>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<ExInt128>, Vector<ExInt128>, Vector<ExInt128>, Vector<ExInt128>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<ExInt128>, Vector<ExInt128>, Vector<ExInt128>, Vector<ExInt128>, out Vector<ExInt128>, out Vector<ExInt128>, out Vector<ExInt128>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<ExUInt128>, Vector<ExUInt128>, Vector<ExUInt128>, Vector<ExUInt128>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip(Vector<ExUInt128>, Vector<ExUInt128>, Vector<ExUInt128>, Vector<ExUInt128>, out Vector<ExUInt128>, out Vector<ExUInt128>, out Vector<ExUInt128>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip_Bit128<T>(Vector<T>, Vector<T>, Vector<T>, Vector<T>, out Vector<T>, out Vector<T>, out Vector<T>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). It is specialized for process 128-bit element (它专门用于处理128位元素). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Unzip<T>(Vector<T>, Vector<T>, Vector<T>, Vector<T>): De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的数组结构体转为结构体数组. 它还能将已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic: x[i] =: element_ref(4i, data0, data1, data2, data3), y[i] =: element_ref(4i+1, data0, data1, data2, data3), z[i] =: element_ref(4i+2, data0, data1, data2, data3), w[i] =: element_ref(4i+3, data0, data1, data2, data3).

YGroup4Zip(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<double>, Vector<double>, Vector<double>, Vector<double>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<double>, Vector<double>, Vector<double>, Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<Int128>, Vector<Int128>, Vector<Int128>, Vector<Int128>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<Int128>, Vector<Int128>, Vector<Int128>, Vector<Int128>, out Vector<Int128>, out Vector<Int128>, out Vector<Int128>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<short>, Vector<short>, Vector<short>, Vector<short>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<short>, Vector<short>, Vector<short>, Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<int>, Vector<int>, Vector<int>, Vector<int>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<int>, Vector<int>, Vector<int>, Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<long>, Vector<long>, Vector<long>, Vector<long>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<long>, Vector<long>, Vector<long>, Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<float>, Vector<float>, Vector<float>, Vector<float>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<float>, Vector<float>, Vector<float>, Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<UInt128>, Vector<UInt128>, Vector<UInt128>, Vector<UInt128>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<UInt128>, Vector<UInt128>, Vector<UInt128>, Vector<UInt128>, out Vector<UInt128>, out Vector<UInt128>, out Vector<UInt128>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<ExInt128>, Vector<ExInt128>, Vector<ExInt128>, Vector<ExInt128>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<ExInt128>, Vector<ExInt128>, Vector<ExInt128>, Vector<ExInt128>, out Vector<ExInt128>, out Vector<ExInt128>, out Vector<ExInt128>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<ExUInt128>, Vector<ExUInt128>, Vector<ExUInt128>, Vector<ExUInt128>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip(Vector<ExUInt128>, Vector<ExUInt128>, Vector<ExUInt128>, Vector<ExUInt128>, out Vector<ExUInt128>, out Vector<ExUInt128>, out Vector<ExUInt128>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip_Bit128<T>(Vector<T>, Vector<T>, Vector<T>, Vector<T>, out Vector<T>, out Vector<T>, out Vector<T>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). It is specialized for process 128-bit element (它专门用于处理128位元素). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YGroup4Zip<T>(Vector<T>, Vector<T>, Vector<T>, Vector<T>): Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的结构体数组转为数组结构体. 它还能将 R,G,B,A 平面数据, 交织为已打包的RGBA像素数据). Mnemonic: element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ), i2 := i/4.

YIsAllTrue<T>(Vector<T>): Checks if all elements of the vector is true (检查向量中所有元素是不是都为true). Mnemonic: rt := value[0] && value[1] && value[2] && ... && value[Count-1]. The element of value must be 0 or AllBitsSet (Signed integer value -1).

YIsAnyTrue<T>(Vector<T>): Checks if any elements of the vector is true (检查向量中任一元素是不是为true). Mnemonic: rt := value[0] || value[1] || value[2] || ... || value[Count-1]. The element of value must be 0 or AllBitsSet (Signed integer value -1).

YIsEvenInteger(Vector<byte>): Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic: rt[i] := to_mask(isEvenInteger(value[i])).

YIsEvenInteger(Vector<double>): Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic: rt[i] := to_mask(isEvenInteger(value[i])).

YIsEvenInteger(Vector<short>): Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic: rt[i] := to_mask(isEvenInteger(value[i])).

YIsEvenInteger(Vector<int>): Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic: rt[i] := to_mask(isEvenInteger(value[i])).

YIsEvenInteger(Vector<long>): Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic: rt[i] := to_mask(isEvenInteger(value[i])).

YIsEvenInteger(Vector<sbyte>): Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic: rt[i] := to_mask(isEvenInteger(value[i])).

YIsEvenInteger(Vector<float>): Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic: rt[i] := to_mask(isEvenInteger(value[i])).

YIsEvenInteger(Vector<ushort>): Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic: rt[i] := to_mask(isEvenInteger(value[i])).

YIsEvenInteger(Vector<uint>): Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic: rt[i] := to_mask(isEvenInteger(value[i])).

YIsEvenInteger(Vector<ulong>): Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic: rt[i] := to_mask(isEvenInteger(value[i])).

YIsFinite(Vector<double>): Determines if a element is finite. It contains zero, subnormal, and normal. It does not contain infinity, NaN (确定元素是否为有限值. 它包含零、次正规数、正规数. 它不含无穷大、非数). Mnemonic: rt[i] := to_mask(isFinite(value[i])).

YIsFinite(Vector<float>): Determines if a element is finite. It contains zero, subnormal, and normal. It does not contain infinity, NaN (确定元素是否为有限值. 它包含零、次正规数、正规数. 它不含无穷大、非数). Mnemonic: rt[i] := to_mask(isFinite(value[i])).

YIsInfinity(Vector<double>): Determines if a element is infinite (确定元素是否为无穷大). Mnemonic: rt[i] := to_mask(isInfinity(value[i])).

YIsInfinity(Vector<float>): Determines if a element is infinite (确定元素是否为无穷大). Mnemonic: rt[i] := to_mask(isInfinity(value[i])).

YIsInfinityOrNaN(Vector<double>): Determines if a element is infinite or NaN (确定元素是否为无穷大或非数). Mnemonic: rt[i] := to_mask(isInfinityOrNaN(value[i])).

YIsInfinityOrNaN(Vector<float>): Determines if a element is infinite or NaN (确定元素是否为无穷大或非数). Mnemonic: rt[i] := to_mask(isInfinityOrNaN(value[i])).

YIsInteger(Vector<double>): Determines if a element represents an integral number (确定元素是否为整数). Mnemonic: rt[i] := to_mask(isInteger(value[i])).

YIsInteger(Vector<float>): Determines if a element represents an integral number (确定元素是否为整数). Mnemonic: rt[i] := to_mask(isInteger(value[i])).

YIsNaN(Vector<double>): Determines if a element is NaN (确定元素是否为非数). Mnemonic: rt[i] := to_mask(isNaN(value[i])).

YIsNaN(Vector<float>): Determines if a element is NaN (确定元素是否为非数). Mnemonic: rt[i] := to_mask(isNaN(value[i])).

YIsNegative(Vector<double>): Determines if a element represents a negative number or negative zero (确定元素是否为负数或负零). Mnemonic: rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).

YIsNegative(Vector<short>): Determines if a element represents a negative number or negative zero (确定元素是否为负数或负零). Mnemonic: rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).

YIsNegative(Vector<int>): Determines if a element represents a negative number or negative zero (确定元素是否为负数或负零). Mnemonic: rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).

YIsNegative(Vector<long>): Determines if a element represents a negative number or negative zero (确定元素是否为负数或负零). Mnemonic: rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).

YIsNegative(Vector<sbyte>): Determines if a element represents a negative number or negative zero (确定元素是否为负数或负零). Mnemonic: rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).

YIsNegative(Vector<float>): Determines if a element represents a negative number or negative zero (确定元素是否为负数或负零). Mnemonic: rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).

YIsNegativeInfinity(Vector<double>): Determines if a element is negative infinity (确定元素是否为负无穷大). Mnemonic: rt[i] := to_mask(isNegativeInfinity(value[i])).

YIsNegativeInfinity(Vector<float>): Determines if a element is negative infinity (确定元素是否为负无穷大). Mnemonic: rt[i] := to_mask(isNegativeInfinity(value[i])).

YIsNegativeZero(Vector<double>): Determines if a element represents a negative zero (确定元素是否为负零). Mnemonic: rt[i] := to_mask(isNegativeZero(value[i])).

YIsNegativeZero(Vector<float>): Determines if a element represents a negative zero (确定元素是否为负零). Mnemonic: rt[i] := to_mask(isNegativeZero(value[i])).

YIsNormal(Vector<double>): Determines if a element is normal (确定元素是否为正规数). Mnemonic: rt[i] := to_mask(isFinite(value[i])).

YIsNormal(Vector<float>): Determines if a element is normal (确定元素是否为正规数). Mnemonic: rt[i] := to_mask(isFinite(value[i])).

YIsNotEquals(Vector<byte>, Vector<byte>): Compares two vectors to determine if they are not equal on a per-element basis (比较两个向量，确定它们每个元素是否不相等). Mnemonic: rt[i] := to_mask(left[i] != right[i]).

YIsNotEquals(Vector<double>, Vector<double>): Compares two vectors to determine if they are not equal on a per-element basis (比较两个向量，确定它们每个元素是否不相等). Mnemonic: rt[i] := to_mask(left[i] != right[i]).

YIsNotEquals(Vector<short>, Vector<short>): Compares two vectors to determine if they are not equal on a per-element basis (比较两个向量，确定它们每个元素是否不相等). Mnemonic: rt[i] := to_mask(left[i] != right[i]).

YIsNotEquals(Vector<int>, Vector<int>): Compares two vectors to determine if they are not equal on a per-element basis (比较两个向量，确定它们每个元素是否不相等). Mnemonic: rt[i] := to_mask(left[i] != right[i]).

YIsNotEquals(Vector<long>, Vector<long>): Compares two vectors to determine if they are not equal on a per-element basis (比较两个向量，确定它们每个元素是否不相等). Mnemonic: rt[i] := to_mask(left[i] != right[i]).

YIsNotEquals(Vector<sbyte>, Vector<sbyte>): Compares two vectors to determine if they are not equal on a per-element basis (比较两个向量，确定它们每个元素是否不相等). Mnemonic: rt[i] := to_mask(left[i] != right[i]).

YIsNotEquals(Vector<float>, Vector<float>): Compares two vectors to determine if they are not equal on a per-element basis (比较两个向量，确定它们每个元素是否不相等). Mnemonic: rt[i] := to_mask(left[i] != right[i]).

YIsNotEquals(Vector<ushort>, Vector<ushort>): Compares two vectors to determine if they are not equal on a per-element basis (比较两个向量，确定它们每个元素是否不相等). Mnemonic: rt[i] := to_mask(left[i] != right[i]).

YIsNotEquals(Vector<uint>, Vector<uint>): Compares two vectors to determine if they are not equal on a per-element basis (比较两个向量，确定它们每个元素是否不相等). Mnemonic: rt[i] := to_mask(left[i] != right[i]).

YIsNotEquals(Vector<ulong>, Vector<ulong>): Compares two vectors to determine if they are not equal on a per-element basis (比较两个向量，确定它们每个元素是否不相等). Mnemonic: rt[i] := to_mask(left[i] != right[i]).

YIsNotNaN(Vector<double>): Determines if a element is not NaN (确定元素是否不为非数). Mnemonic: rt[i] := to_mask(isNotNaN(value[i])) = to_mask(!isNaN(value[i])).

YIsNotNaN(Vector<float>): Determines if a element is not NaN (确定元素是否不为非数). Mnemonic: rt[i] := to_mask(isNotNaN(value[i])) = to_mask(!isNaN(value[i])).

YIsOddInteger(Vector<byte>): Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic: rt[i] := to_mask(isOddInteger(value[i])).

YIsOddInteger(Vector<double>): Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic: rt[i] := to_mask(isOddInteger(value[i])).

YIsOddInteger(Vector<short>): Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic: rt[i] := to_mask(isOddInteger(value[i])).

YIsOddInteger(Vector<int>): Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic: rt[i] := to_mask(isOddInteger(value[i])).

YIsOddInteger(Vector<long>): Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic: rt[i] := to_mask(isOddInteger(value[i])).

YIsOddInteger(Vector<sbyte>): Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic: rt[i] := to_mask(isOddInteger(value[i])).

YIsOddInteger(Vector<float>): Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic: rt[i] := to_mask(isOddInteger(value[i])).

YIsOddInteger(Vector<ushort>): Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic: rt[i] := to_mask(isOddInteger(value[i])).

YIsOddInteger(Vector<uint>): Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic: rt[i] := to_mask(isOddInteger(value[i])).

YIsOddInteger(Vector<ulong>): Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic: rt[i] := to_mask(isOddInteger(value[i])).

YIsPositive(Vector<double>): Determines if a element represents zero or a positive number (确定元素是否为零或正数). Mnemonic: rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).

YIsPositive(Vector<short>): Determines if a element represents zero or a positive number (确定元素是否为零或正数). Mnemonic: rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).

YIsPositive(Vector<int>): Determines if a element represents zero or a positive number (确定元素是否为零或正数). Mnemonic: rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).

YIsPositive(Vector<long>): Determines if a element represents zero or a positive number (确定元素是否为零或正数). Mnemonic: rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).

YIsPositive(Vector<sbyte>): Determines if a element represents zero or a positive number (确定元素是否为零或正数). Mnemonic: rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).

YIsPositive(Vector<float>): Determines if a element represents zero or a positive number (确定元素是否为零或正数). Mnemonic: rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).

YIsPositiveInfinity(Vector<double>): Determines if a element is positive infinity (确定元素是否为正无穷大). Mnemonic: rt[i] := to_mask(isNegativeInfinity(value[i])).

YIsPositiveInfinity(Vector<float>): Determines if a element is positive infinity (确定元素是否为正无穷大). Mnemonic: rt[i] := to_mask(isNegativeInfinity(value[i])).

YIsSubnormal(Vector<double>): Determines if a element is subnormal (确定元素是否为次正规数). Mnemonic: rt[i] := to_mask(IsSubnormal(value[i])).

YIsSubnormal(Vector<float>): Determines if a element is subnormal (确定元素是否为次正规数). Mnemonic: rt[i] := to_mask(IsSubnormal(value[i])).

YIsZero(Vector<byte>): Determines if a element is zero (确定元素是否为零). Mnemonic: rt[i] := to_mask(0==value[i]).

YIsZero(Vector<double>): Determines if a element is zero (确定元素是否为零). Mnemonic: rt[i] := to_mask(0==value[i]).

YIsZero(Vector<short>): Determines if a element is zero (确定元素是否为零). Mnemonic: rt[i] := to_mask(0==value[i]).

YIsZero(Vector<int>): Determines if a element is zero (确定元素是否为零). Mnemonic: rt[i] := to_mask(0==value[i]).

YIsZero(Vector<long>): Determines if a element is zero (确定元素是否为零). Mnemonic: rt[i] := to_mask(0==value[i]).

YIsZero(Vector<sbyte>): Determines if a element is zero (确定元素是否为零). Mnemonic: rt[i] := to_mask(0==value[i]).

YIsZero(Vector<float>): Determines if a element is zero (确定元素是否为零). Mnemonic: rt[i] := to_mask(0==value[i]).

YIsZero(Vector<ushort>): Determines if a element is zero (确定元素是否为零). Mnemonic: rt[i] := to_mask(0==value[i]).

YIsZero(Vector<uint>): Determines if a element is zero (确定元素是否为零). Mnemonic: rt[i] := to_mask(0==value[i]).

YIsZero(Vector<ulong>): Determines if a element is zero (确定元素是否为零). Mnemonic: rt[i] := to_mask(0==value[i]).

YIsZeroOrSubnormal(Vector<double>): Determines if a element is zero or subnormal (确定元素是否为零或次正规数). Mnemonic: rt[i] := to_mask(isZeroOrSubnormal(value[i])).

YIsZeroOrSubnormal(Vector<float>): Determines if a element is zero or subnormal (确定元素是否为零或次正规数). Mnemonic: rt[i] := to_mask(isZeroOrSubnormal(value[i])).

YMaxNumber(Vector<double>, Vector<double>): Computes the maximum number of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最大数值). The maxNumber method matches the IEEE 754:2019 maximumNumber function. This requires NaN inputs to not be propagated back to the caller and for -0.0 to be treated as less than +0.0 (maxNumber方法与 IEEE 754:2019 maximumNumber 函数匹配。这要求 NaN 输入不传播回调用方，且 -0.0 被视为小于 +0.0). Mnemonic: rt[i] := maxNumber(left[i], right[i]).

YMaxNumber(Vector<float>, Vector<float>): Computes the maximum number of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最大数值). The maxNumber method matches the IEEE 754:2019 maximumNumber function. This requires NaN inputs to not be propagated back to the caller and for -0.0 to be treated as less than +0.0 (maxNumber方法与 IEEE 754:2019 maximumNumber 函数匹配。这要求 NaN 输入不传播回调用方，且 -0.0 被视为小于 +0.0). Mnemonic: rt[i] := maxNumber(left[i], right[i]).

YMinNumber(Vector<double>, Vector<double>): Computes the minimum number of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最小数值). The minNumber method matches the IEEE 754:2019 minimumNumber function. This requires NaN inputs to not be propagated back to the caller and for -0.0 to be treated as less than +0.0 (minNumber方法与 IEEE 754:2019 minimumNumber 函数匹配。这要求 NaN 输入不传播回调用方，且 -0.0 被视为小于 +0.0). Mnemonic: rt[i] := minNumber(left[i], right[i]).

YMinNumber(Vector<float>, Vector<float>): Computes the minimum number of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最小数值). The minNumber method matches the IEEE 754:2019 minimumNumber function. This requires NaN inputs to not be propagated back to the caller and for -0.0 to be treated as less than +0.0 (minNumber方法与 IEEE 754:2019 minimumNumber 函数匹配。这要求 NaN 输入不传播回调用方，且 -0.0 被视为小于 +0.0). Mnemonic: rt[i] := minNumber(left[i], right[i]).

YNarrowSaturate(Vector<short>, Vector<short>): Saturate narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例饱和缩窄为一个 Vector<T> ). />. Mnemonic: rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), TOut.MinValue, TOut.MaxValue)).

YNarrowSaturate(Vector<int>, Vector<int>): Saturate narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例饱和缩窄为一个 Vector<T> ). />. Mnemonic: rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), TOut.MinValue, TOut.MaxValue)).

YNarrowSaturate(Vector<long>, Vector<long>): Saturate narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例饱和缩窄为一个 Vector<T> ). />. Mnemonic: rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), TOut.MinValue, TOut.MaxValue)).

YNarrowSaturate(Vector<ushort>, Vector<ushort>): Saturate narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例饱和缩窄为一个 Vector<T> ). />. Mnemonic: rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), TOut.MinValue, TOut.MaxValue)).

YNarrowSaturate(Vector<uint>, Vector<uint>): Saturate narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例饱和缩窄为一个 Vector<T> ). />. Mnemonic: rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), TOut.MinValue, TOut.MaxValue)).

YNarrowSaturate(Vector<ulong>, Vector<ulong>): Saturate narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例饱和缩窄为一个 Vector<T> ). />. Mnemonic: rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), TOut.MinValue, TOut.MaxValue)).

YNarrowSaturateUnsigned(Vector<short>, Vector<short>): Saturate narrows two signed Vector<T> instances into one unsigned Vector<T>" (将两个有符号 Vector<T> 实例饱和缩窄为一个无符号 Vector<T> ). />. Mnemonic: rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), 0, TOut.MaxValue)).

YNarrowSaturateUnsigned(Vector<int>, Vector<int>): Saturate narrows two signed Vector<T> instances into one unsigned Vector<T>" (将两个有符号 Vector<T> 实例饱和缩窄为一个无符号 Vector<T> ). />. Mnemonic: rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), 0, TOut.MaxValue)).

YNarrowSaturateUnsigned(Vector<long>, Vector<long>): Saturate narrows two signed Vector<T> instances into one unsigned Vector<T>" (将两个有符号 Vector<T> 实例饱和缩窄为一个无符号 Vector<T> ). />. Mnemonic: rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), 0, TOut.MaxValue)).

YOrNot<T>(Vector<T>, Vector<T>): Computes the bitwise-or of a given vector or the ones complement of another vector (计算一个给定的向量和另一个向量反码的位或). Mnemonic: rt[i] := left[i] | ~right[i].

YRoundToEven(Vector<double>): Computes the round to even of each element in a vector (计算向量中每个元素的向偶数舍入). It is also known as rounding half to even/round to nearest integer (它也被称作四舍六入五成双/舍入到最近整数). See more: ToEven. Mnemonic: rt[i] := round_to_even(value[i]).

YRoundToEven(Vector<float>): Computes the round to even of each element in a vector (计算向量中每个元素的向偶数舍入). It is also known as rounding half to even/round to nearest integer (它也被称作四舍六入五成双/舍入到最近整数). See more: ToEven. Mnemonic: rt[i] := round_to_even(value[i]).

YRoundToZero(Vector<double>): Computes the round to zero of each element in a vector (计算向量中每个元素的向零舍入). It is also known as truncate (它也被称作截断取整). See more: ToZero. Mnemonic: rt[i] := round_to_zero(value[i]).

YRoundToZero(Vector<float>): Computes the round to zero of each element in a vector (计算向量中每个元素的向零舍入). It is also known as truncate (它也被称作截断取整). See more: ToZero. Mnemonic: rt[i] := round_to_zero(value[i]).

YShuffleG2(Vector<byte>, ShuffleControlG2): For each 2-element group in a vector, shuffle is performed (对于一个向量中的每个 2-元素组, 进行换位). Mnemonic: View for group: rt.xy = shuffleG2_ref(control, source). View for element: rt[i] := source[(i&(~1)) | ((control >> (i&1)) & 1)].

YShuffleG2(Vector<double>, ShuffleControlG2): For each 2-element group in a vector, shuffle is performed (对于一个向量中的每个 2-元素组, 进行换位). Mnemonic: View for group: rt.xy = shuffleG2_ref(control, source). View for element: rt[i] := source[(i&(~1)) | ((control >> (i&1)) & 1)].

YShuffleG2(Vector<short>, ShuffleControlG2): For each 2-element group in a vector, shuffle is performed (对于一个向量中的每个 2-元素组, 进行换位). Mnemonic: View for group: rt.xy = shuffleG2_ref(control, source). View for element: rt[i] := source[(i&(~1)) | ((control >> (i&1)) & 1)].

YShuffleG2(Vector<int>, ShuffleControlG2): For each 2-element group in a vector, shuffle is performed (对于一个向量中的每个 2-元素组, 进行换位). Mnemonic: View for group: rt.xy = shuffleG2_ref(control, source). View for element: rt[i] := source[(i&(~1)) | ((control >> (i&1)) & 1)].

YShuffleG2(Vector<long>, ShuffleControlG2): For each 2-element group in a vector, shuffle is performed (对于一个向量中的每个 2-元素组, 进行换位). Mnemonic: View for group: rt.xy = shuffleG2_ref(control, source). View for element: rt[i] := source[(i&(~1)) | ((control >> (i&1)) & 1)].

YShuffleG2(Vector<sbyte>, ShuffleControlG2): For each 2-element group in a vector, shuffle is performed (对于一个向量中的每个 2-元素组, 进行换位). Mnemonic: View for group: rt.xy = shuffleG2_ref(control, source). View for element: rt[i] := source[(i&(~1)) | ((control >> (i&1)) & 1)].

YShuffleG2(Vector<float>, ShuffleControlG2): For each 2-element group in a vector, shuffle is performed (对于一个向量中的每个 2-元素组, 进行换位). Mnemonic: View for group: rt.xy = shuffleG2_ref(control, source). View for element: rt[i] := source[(i&(~1)) | ((control >> (i&1)) & 1)].

YShuffleG2(Vector<ushort>, ShuffleControlG2): For each 2-element group in a vector, shuffle is performed (对于一个向量中的每个 2-元素组, 进行换位). Mnemonic: View for group: rt.xy = shuffleG2_ref(control, source). View for element: rt[i] := source[(i&(~1)) | ((control >> (i&1)) & 1)].

YShuffleG2(Vector<uint>, ShuffleControlG2): For each 2-element group in a vector, shuffle is performed (对于一个向量中的每个 2-元素组, 进行换位). Mnemonic: View for group: rt.xy = shuffleG2_ref(control, source). View for element: rt[i] := source[(i&(~1)) | ((control >> (i&1)) & 1)].

YShuffleG2(Vector<ulong>, ShuffleControlG2): For each 2-element group in a vector, shuffle is performed (对于一个向量中的每个 2-元素组, 进行换位). Mnemonic: View for group: rt.xy = shuffleG2_ref(control, source). View for element: rt[i] := source[(i&(~1)) | ((control >> (i&1)) & 1)].

YShuffleG4(Vector<byte>, ShuffleControlG4): For each 4-element group in a vector, shuffle is performed (对于一个向量中的每个 4-元素组, 进行换位). If the count of elements in a vector is less than 4, please use YShuffleG4X2 instead (如果向量的元素数量小于4，请使用 YShuffleG4X2 代替). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source). View for element: rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].

YShuffleG4(Vector<double>, ShuffleControlG4): For each 4-element group in a vector, shuffle is performed (对于一个向量中的每个 4-元素组, 进行换位). If the count of elements in a vector is less than 4, please use YShuffleG4X2 instead (如果向量的元素数量小于4，请使用 YShuffleG4X2 代替). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source). View for element: rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].

YShuffleG4(Vector<short>, ShuffleControlG4): For each 4-element group in a vector, shuffle is performed (对于一个向量中的每个 4-元素组, 进行换位). If the count of elements in a vector is less than 4, please use YShuffleG4X2 instead (如果向量的元素数量小于4，请使用 YShuffleG4X2 代替). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source). View for element: rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].

YShuffleG4(Vector<int>, ShuffleControlG4): For each 4-element group in a vector, shuffle is performed (对于一个向量中的每个 4-元素组, 进行换位). If the count of elements in a vector is less than 4, please use YShuffleG4X2 instead (如果向量的元素数量小于4，请使用 YShuffleG4X2 代替). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source). View for element: rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].

YShuffleG4(Vector<long>, ShuffleControlG4): For each 4-element group in a vector, shuffle is performed (对于一个向量中的每个 4-元素组, 进行换位). If the count of elements in a vector is less than 4, please use YShuffleG4X2 instead (如果向量的元素数量小于4，请使用 YShuffleG4X2 代替). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source). View for element: rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].

YShuffleG4(Vector<sbyte>, ShuffleControlG4): For each 4-element group in a vector, shuffle is performed (对于一个向量中的每个 4-元素组, 进行换位). If the count of elements in a vector is less than 4, please use YShuffleG4X2 instead (如果向量的元素数量小于4，请使用 YShuffleG4X2 代替). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source). View for element: rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].

YShuffleG4(Vector<float>, ShuffleControlG4): For each 4-element group in a vector, shuffle is performed (对于一个向量中的每个 4-元素组, 进行换位). If the count of elements in a vector is less than 4, please use YShuffleG4X2 instead (如果向量的元素数量小于4，请使用 YShuffleG4X2 代替). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source). View for element: rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].

YShuffleG4(Vector<ushort>, ShuffleControlG4): For each 4-element group in a vector, shuffle is performed (对于一个向量中的每个 4-元素组, 进行换位). If the count of elements in a vector is less than 4, please use YShuffleG4X2 instead (如果向量的元素数量小于4，请使用 YShuffleG4X2 代替). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source). View for element: rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].

YShuffleG4(Vector<uint>, ShuffleControlG4): For each 4-element group in a vector, shuffle is performed (对于一个向量中的每个 4-元素组, 进行换位). If the count of elements in a vector is less than 4, please use YShuffleG4X2 instead (如果向量的元素数量小于4，请使用 YShuffleG4X2 代替). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source). View for element: rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].

YShuffleG4(Vector<ulong>, ShuffleControlG4): For each 4-element group in a vector, shuffle is performed (对于一个向量中的每个 4-元素组, 进行换位). If the count of elements in a vector is less than 4, please use YShuffleG4X2 instead (如果向量的元素数量小于4，请使用 YShuffleG4X2 代替). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source). View for element: rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].

YShuffleG4X2(Vector<byte>, Vector<byte>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2(Vector<byte>, Vector<byte>, ShuffleControlG4, out Vector<byte>): For each 4-element group in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2(Vector<double>, Vector<double>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2(Vector<double>, Vector<double>, ShuffleControlG4, out Vector<double>): For each 4-element group in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2(Vector<short>, Vector<short>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2(Vector<short>, Vector<short>, ShuffleControlG4, out Vector<short>): For each 4-element group in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2(Vector<int>, Vector<int>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2(Vector<int>, Vector<int>, ShuffleControlG4, out Vector<int>): For each 4-element group in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2(Vector<long>, Vector<long>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2(Vector<long>, Vector<long>, ShuffleControlG4, out Vector<long>): For each 4-element group in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2(Vector<sbyte>, Vector<sbyte>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2(Vector<sbyte>, Vector<sbyte>, ShuffleControlG4, out Vector<sbyte>): For each 4-element group in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2(Vector<float>, Vector<float>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2(Vector<float>, Vector<float>, ShuffleControlG4, out Vector<float>): For each 4-element group in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2(Vector<ushort>, Vector<ushort>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2(Vector<ushort>, Vector<ushort>, ShuffleControlG4, out Vector<ushort>): For each 4-element group in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2(Vector<uint>, Vector<uint>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2(Vector<uint>, Vector<uint>, ShuffleControlG4, out Vector<uint>): For each 4-element group in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2(Vector<ulong>, Vector<ulong>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2(Vector<ulong>, Vector<ulong>, ShuffleControlG4, out Vector<ulong>): For each 4-element group in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2_Const(Vector<byte>, Vector<byte>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2_Const(Vector<byte>, Vector<byte>, ShuffleControlG4, out Vector<byte>): For each 4-element group in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2_Const(Vector<double>, Vector<double>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2_Const(Vector<double>, Vector<double>, ShuffleControlG4, out Vector<double>): For each 4-element group in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2_Const(Vector<short>, Vector<short>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2_Const(Vector<short>, Vector<short>, ShuffleControlG4, out Vector<short>): For each 4-element group in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2_Const(Vector<int>, Vector<int>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2_Const(Vector<int>, Vector<int>, ShuffleControlG4, out Vector<int>): For each 4-element group in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2_Const(Vector<long>, Vector<long>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2_Const(Vector<long>, Vector<long>, ShuffleControlG4, out Vector<long>): For each 4-element group in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2_Const(Vector<sbyte>, Vector<sbyte>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2_Const(Vector<sbyte>, Vector<sbyte>, ShuffleControlG4, out Vector<sbyte>): For each 4-element group in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2_Const(Vector<float>, Vector<float>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2_Const(Vector<float>, Vector<float>, ShuffleControlG4, out Vector<float>): For each 4-element group in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2_Const(Vector<ushort>, Vector<ushort>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2_Const(Vector<ushort>, Vector<ushort>, ShuffleControlG4, out Vector<ushort>): For each 4-element group in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2_Const(Vector<uint>, Vector<uint>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2_Const(Vector<uint>, Vector<uint>, ShuffleControlG4, out Vector<uint>): For each 4-element group in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2_Const(Vector<ulong>, Vector<ulong>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2_Const(Vector<ulong>, Vector<ulong>, ShuffleControlG4, out Vector<ulong>): For each 4-element group in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2_Const<T>(Vector<T>, Vector<T>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4X2<T>(Vector<T>, Vector<T>, ShuffleControlG4): For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source0, source1). View for element: element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).

YShuffleG4_Const(Vector<byte>, ShuffleControlG4): For each 4-element group in a vector, shuffle is performed - Constant version (对于一个向量中的每个 4-元素组, 进行换位 - 常量版). If the count of the vector is less than 4, please use YShuffleG4X2_Const instead (如果向量的数量小于4，请使用 YShuffleG4X2_Const 代替). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source). View for element: rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].

YShuffleG4_Const(Vector<double>, ShuffleControlG4): For each 4-element group in a vector, shuffle is performed - Constant version (对于一个向量中的每个 4-元素组, 进行换位 - 常量版). If the count of the vector is less than 4, please use YShuffleG4X2_Const instead (如果向量的数量小于4，请使用 YShuffleG4X2_Const 代替). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source). View for element: rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].

YShuffleG4_Const(Vector<short>, ShuffleControlG4): For each 4-element group in a vector, shuffle is performed - Constant version (对于一个向量中的每个 4-元素组, 进行换位 - 常量版). If the count of the vector is less than 4, please use YShuffleG4X2_Const instead (如果向量的数量小于4，请使用 YShuffleG4X2_Const 代替). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source). View for element: rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].

YShuffleG4_Const(Vector<int>, ShuffleControlG4): For each 4-element group in a vector, shuffle is performed - Constant version (对于一个向量中的每个 4-元素组, 进行换位 - 常量版). If the count of the vector is less than 4, please use YShuffleG4X2_Const instead (如果向量的数量小于4，请使用 YShuffleG4X2_Const 代替). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source). View for element: rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].

YShuffleG4_Const(Vector<long>, ShuffleControlG4): For each 4-element group in a vector, shuffle is performed - Constant version (对于一个向量中的每个 4-元素组, 进行换位 - 常量版). If the count of the vector is less than 4, please use YShuffleG4X2_Const instead (如果向量的数量小于4，请使用 YShuffleG4X2_Const 代替). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source). View for element: rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].

YShuffleG4_Const(Vector<sbyte>, ShuffleControlG4): For each 4-element group in a vector, shuffle is performed - Constant version (对于一个向量中的每个 4-元素组, 进行换位 - 常量版). If the count of the vector is less than 4, please use YShuffleG4X2_Const instead (如果向量的数量小于4，请使用 YShuffleG4X2_Const 代替). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source). View for element: rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].

YShuffleG4_Const(Vector<float>, ShuffleControlG4): For each 4-element group in a vector, shuffle is performed - Constant version (对于一个向量中的每个 4-元素组, 进行换位 - 常量版). If the count of the vector is less than 4, please use YShuffleG4X2_Const instead (如果向量的数量小于4，请使用 YShuffleG4X2_Const 代替). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source). View for element: rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].

YShuffleG4_Const(Vector<ushort>, ShuffleControlG4): For each 4-element group in a vector, shuffle is performed - Constant version (对于一个向量中的每个 4-元素组, 进行换位 - 常量版). If the count of the vector is less than 4, please use YShuffleG4X2_Const instead (如果向量的数量小于4，请使用 YShuffleG4X2_Const 代替). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source). View for element: rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].

YShuffleG4_Const(Vector<uint>, ShuffleControlG4): For each 4-element group in a vector, shuffle is performed - Constant version (对于一个向量中的每个 4-元素组, 进行换位 - 常量版). If the count of the vector is less than 4, please use YShuffleG4X2_Const instead (如果向量的数量小于4，请使用 YShuffleG4X2_Const 代替). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source). View for element: rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].

YShuffleG4_Const(Vector<ulong>, ShuffleControlG4): For each 4-element group in a vector, shuffle is performed - Constant version (对于一个向量中的每个 4-元素组, 进行换位 - 常量版). If the count of the vector is less than 4, please use YShuffleG4X2_Const instead (如果向量的数量小于4，请使用 YShuffleG4X2_Const 代替). Mnemonic: View for group: rt.xyzw = shuffleG4_ref(control, source). View for element: rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].

YShuffleInsert(Vector<byte>, Vector<byte>, Vector<byte>): Shuffle and insert (换位并插入). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert(Vector<double>, Vector<double>, Vector<long>): Shuffle and insert (换位并插入). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert(Vector<short>, Vector<short>, Vector<short>): Shuffle and insert (换位并插入). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert(Vector<int>, Vector<int>, Vector<int>): Shuffle and insert (换位并插入). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert(Vector<long>, Vector<long>, Vector<long>): Shuffle and insert (换位并插入). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Shuffle and insert (换位并插入). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert(Vector<float>, Vector<float>, Vector<int>): Shuffle and insert (换位并插入). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert(Vector<ushort>, Vector<ushort>, Vector<ushort>): Shuffle and insert (换位并插入). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert(Vector<uint>, Vector<uint>, Vector<uint>): Shuffle and insert (换位并插入). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert(Vector<ulong>, Vector<ulong>, Vector<ulong>): Shuffle and insert (换位并插入). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Args(Vector<byte>): Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Args(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>): Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Args(Vector<short>): Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Args(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>): Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Args(Vector<int>): Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Args(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>): Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Args(Vector<long>): Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Args(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>): Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Args(Vector<sbyte>): Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Args(Vector<ushort>): Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>): Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Args(Vector<uint>): Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Args(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>): Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Args(Vector<ulong>): Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>): Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Args<TIdx>(Vector<TIdx>): Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Args<TIdx>(Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>): Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Core(Vector<byte>, Vector<byte>, (Vector<byte> args0, Vector<byte> args1, Vector<byte> args2)): Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Core(Vector<double>, Vector<double>, Vector<long>, Vector<long>, Vector<long>): Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Core(Vector<double>, Vector<double>, (Vector<long> args0, Vector<long> args1, Vector<long> args2)): Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>): Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Core(Vector<short>, Vector<short>, (Vector<short> args0, Vector<short> args1, Vector<short> args2)): Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Core(Vector<int>, Vector<int>, (Vector<int> args0, Vector<int> args1, Vector<int> args2)): Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Core(Vector<long>, Vector<long>, (Vector<long> args0, Vector<long> args1, Vector<long> args2)): Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Core(Vector<sbyte>, Vector<sbyte>, (Vector<sbyte> args0, Vector<sbyte> args1, Vector<sbyte> args2)): Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Core(Vector<float>, Vector<float>, Vector<int>, Vector<int>, Vector<int>): Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Core(Vector<float>, Vector<float>, (Vector<int> args0, Vector<int> args1, Vector<int> args2)): Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Core(Vector<ushort>, Vector<ushort>, (Vector<ushort> args0, Vector<ushort> args1, Vector<ushort> args2)): Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Core(Vector<uint>, Vector<uint>, (Vector<uint> args0, Vector<uint> args1, Vector<uint> args2)): Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleInsert_Core(Vector<ulong>, Vector<ulong>, (Vector<ulong> args0, Vector<ulong> args1, Vector<ulong> args2)): Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].

YShuffleKernel(Vector<byte>, Vector<byte>): Only shuffle (仅换位). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel(Vector<double>, Vector<long>): Only shuffle (仅换位). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel(Vector<short>, Vector<short>): Only shuffle (仅换位). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel(Vector<int>, Vector<int>): Only shuffle (仅换位). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel(Vector<long>, Vector<long>): Only shuffle (仅换位). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel(Vector<sbyte>, Vector<sbyte>): Only shuffle (仅换位). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel(Vector<float>, Vector<int>): Only shuffle (仅换位). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel(Vector<ushort>, Vector<ushort>): Only shuffle (仅换位). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel(Vector<uint>, Vector<uint>): Only shuffle (仅换位). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel(Vector<ulong>, Vector<ulong>): Only shuffle (仅换位). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Args(Vector<byte>): Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Args(Vector<byte>, out Vector<byte>, out Vector<byte>): Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Args(Vector<short>): Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Args(Vector<short>, out Vector<short>, out Vector<short>): Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Args(Vector<int>): Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Args(Vector<int>, out Vector<int>, out Vector<int>): Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Args(Vector<long>): Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Args(Vector<long>, out Vector<long>, out Vector<long>): Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Args(Vector<sbyte>): Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Args(Vector<ushort>): Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>): Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Args(Vector<uint>): Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Args(Vector<uint>, out Vector<uint>, out Vector<uint>): Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Args(Vector<ulong>): Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>): Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Args<TIdx>(Vector<TIdx>): Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Args<TIdx>(Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>): Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Core(Vector<byte>, Vector<byte>, Vector<byte>): Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Core(Vector<byte>, (Vector<byte> args0, Vector<byte> args1)): Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Core(Vector<double>, Vector<long>, Vector<long>): Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Core(Vector<double>, (Vector<long> args0, Vector<long> args1)): Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Core(Vector<short>, Vector<short>, Vector<short>): Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Core(Vector<short>, (Vector<short> args0, Vector<short> args1)): Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Core(Vector<int>, Vector<int>, Vector<int>): Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Core(Vector<int>, (Vector<int> args0, Vector<int> args1)): Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Core(Vector<long>, Vector<long>, Vector<long>): Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Core(Vector<long>, (Vector<long> args0, Vector<long> args1)): Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Core(Vector<sbyte>, (Vector<sbyte> args0, Vector<sbyte> args1)): Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Core(Vector<float>, Vector<int>, Vector<int>): Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Core(Vector<float>, (Vector<int> args0, Vector<int> args1)): Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>): Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Core(Vector<ushort>, (Vector<ushort> args0, Vector<ushort> args1)): Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Core(Vector<uint>, Vector<uint>, Vector<uint>): Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Core(Vector<uint>, (Vector<uint> args0, Vector<uint> args1)): Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>): Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleKernel_Core(Vector<ulong>, (Vector<ulong> args0, Vector<ulong> args1)): Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic: rt[i] := vector[indices[i]]. Conditions: 0<=indices[i] && indices[i]<Count.

YShuffleX2(Vector<byte>, Vector<byte>, Vector<byte>): Shuffle and clear on 2 vectors (在2个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2(Vector<double>, Vector<double>, Vector<long>): Shuffle and clear on 2 vectors (在2个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2(Vector<short>, Vector<short>, Vector<short>): Shuffle and clear on 2 vectors (在2个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2(Vector<int>, Vector<int>, Vector<int>): Shuffle and clear on 2 vectors (在2个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2(Vector<long>, Vector<long>, Vector<long>): Shuffle and clear on 2 vectors (在2个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Shuffle and clear on 2 vectors (在2个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2(Vector<float>, Vector<float>, Vector<int>): Shuffle and clear on 2 vectors (在2个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2(Vector<ushort>, Vector<ushort>, Vector<ushort>): Shuffle and clear on 2 vectors (在2个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2(Vector<uint>, Vector<uint>, Vector<uint>): Shuffle and clear on 2 vectors (在2个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2(Vector<ulong>, Vector<ulong>, Vector<ulong>): Shuffle and clear on 2 vectors (在2个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2Insert(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): Shuffle and insert on 2 vectors (在2个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert(Vector<double>, Vector<double>, Vector<double>, Vector<long>): Shuffle and insert on 2 vectors (在2个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert(Vector<short>, Vector<short>, Vector<short>, Vector<short>): Shuffle and insert on 2 vectors (在2个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert(Vector<int>, Vector<int>, Vector<int>, Vector<int>): Shuffle and insert on 2 vectors (在2个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert(Vector<long>, Vector<long>, Vector<long>, Vector<long>): Shuffle and insert on 2 vectors (在2个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Shuffle and insert on 2 vectors (在2个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert(Vector<float>, Vector<float>, Vector<float>, Vector<int>): Shuffle and insert on 2 vectors (在2个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): Shuffle and insert on 2 vectors (在2个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): Shuffle and insert on 2 vectors (在2个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): Shuffle and insert on 2 vectors (在2个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Args(Vector<byte>): Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Args(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>): Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Args(Vector<short>): Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Args(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>): Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Args(Vector<int>): Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Args(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>): Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Args(Vector<long>): Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Args(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>): Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Args(Vector<sbyte>): Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Args(Vector<ushort>): Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>): Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Args(Vector<uint>): Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Args(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>): Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Args(Vector<ulong>): Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>): Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Args<TIdx>(Vector<TIdx>): Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Args<TIdx>(Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>): Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Core(Vector<byte>, Vector<byte>, Vector<byte>, (Vector<byte> args0, Vector<byte> args1, Vector<byte> args2, Vector<byte> args3, Vector<byte> args4)): Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Core(Vector<double>, Vector<double>, Vector<double>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Core(Vector<double>, Vector<double>, Vector<double>, (Vector<long> args0, Vector<long> args1, Vector<long> args2, Vector<long> args3, Vector<long> args4)): Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>): Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Core(Vector<short>, Vector<short>, Vector<short>, (Vector<short> args0, Vector<short> args1, Vector<short> args2, Vector<short> args3, Vector<short> args4)): Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Core(Vector<int>, Vector<int>, Vector<int>, (Vector<int> args0, Vector<int> args1, Vector<int> args2, Vector<int> args3, Vector<int> args4)): Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Core(Vector<long>, Vector<long>, Vector<long>, (Vector<long> args0, Vector<long> args1, Vector<long> args2, Vector<long> args3, Vector<long> args4)): Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, (Vector<sbyte> args0, Vector<sbyte> args1, Vector<sbyte> args2, Vector<sbyte> args3, Vector<sbyte> args4)): Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Core(Vector<float>, Vector<float>, Vector<float>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Core(Vector<float>, Vector<float>, Vector<float>, (Vector<int> args0, Vector<int> args1, Vector<int> args2, Vector<int> args3, Vector<int> args4)): Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, (Vector<ushort> args0, Vector<ushort> args1, Vector<ushort> args2, Vector<ushort> args3, Vector<ushort> args4)): Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Core(Vector<uint>, Vector<uint>, Vector<uint>, (Vector<uint> args0, Vector<uint> args1, Vector<uint> args2, Vector<uint> args3, Vector<uint> args4)): Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Insert_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, (Vector<ulong> args0, Vector<ulong> args1, Vector<ulong> args2, Vector<ulong> args3, Vector<ulong> args4)): Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].

YShuffleX2Kernel(Vector<byte>, Vector<byte>, Vector<byte>): Only shuffle on 2 vectors (在2个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel(Vector<double>, Vector<double>, Vector<long>): Only shuffle on 2 vectors (在2个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel(Vector<short>, Vector<short>, Vector<short>): Only shuffle on 2 vectors (在2个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel(Vector<int>, Vector<int>, Vector<int>): Only shuffle on 2 vectors (在2个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel(Vector<long>, Vector<long>, Vector<long>): Only shuffle on 2 vectors (在2个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Only shuffle on 2 vectors (在2个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel(Vector<float>, Vector<float>, Vector<int>): Only shuffle on 2 vectors (在2个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel(Vector<ushort>, Vector<ushort>, Vector<ushort>): Only shuffle on 2 vectors (在2个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel(Vector<uint>, Vector<uint>, Vector<uint>): Only shuffle on 2 vectors (在2个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel(Vector<ulong>, Vector<ulong>, Vector<ulong>): Only shuffle on 2 vectors (在2个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Args(Vector<byte>): Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Args(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>): Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Args(Vector<short>): Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Args(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>): Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Args(Vector<int>): Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Args(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>): Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Args(Vector<long>): Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Args(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>): Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Args(Vector<sbyte>): Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Args(Vector<ushort>): Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>): Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Args(Vector<uint>): Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Args(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>): Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Args(Vector<ulong>): Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>): Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Args<TIdx>(Vector<TIdx>): Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Args<TIdx>(Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>): Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Core(Vector<byte>, Vector<byte>, (Vector<byte> args0, Vector<byte> args1, Vector<byte> args2, Vector<byte> args3)): Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Core(Vector<double>, Vector<double>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Core(Vector<double>, Vector<double>, (Vector<long> args0, Vector<long> args1, Vector<long> args2, Vector<long> args3)): Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>): Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Core(Vector<short>, Vector<short>, (Vector<short> args0, Vector<short> args1, Vector<short> args2, Vector<short> args3)): Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Core(Vector<int>, Vector<int>, (Vector<int> args0, Vector<int> args1, Vector<int> args2, Vector<int> args3)): Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Core(Vector<long>, Vector<long>, (Vector<long> args0, Vector<long> args1, Vector<long> args2, Vector<long> args3)): Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Core(Vector<sbyte>, Vector<sbyte>, (Vector<sbyte> args0, Vector<sbyte> args1, Vector<sbyte> args2, Vector<sbyte> args3)): Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Core(Vector<float>, Vector<float>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Core(Vector<float>, Vector<float>, (Vector<int> args0, Vector<int> args1, Vector<int> args2, Vector<int> args3)): Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Core(Vector<ushort>, Vector<ushort>, (Vector<ushort> args0, Vector<ushort> args1, Vector<ushort> args2, Vector<ushort> args3)): Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Core(Vector<uint>, Vector<uint>, (Vector<uint> args0, Vector<uint> args1, Vector<uint> args2, Vector<uint> args3)): Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2Kernel_Core(Vector<ulong>, Vector<ulong>, (Vector<ulong> args0, Vector<ulong> args1, Vector<ulong> args2, Vector<ulong> args3)): Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1). Conditions: 0<=indices[i] && indices[i]<(Count*2).

YShuffleX2_Args(Vector<byte>): Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Args(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>): Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Args(Vector<short>): Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Args(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>): Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Args(Vector<int>): Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Args(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>): Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Args(Vector<long>): Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Args(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>): Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Args(Vector<sbyte>): Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Args(Vector<ushort>): Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>): Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Args(Vector<uint>): Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Args(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>): Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Args(Vector<ulong>): Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>): Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Args<TIdx>(Vector<TIdx>): Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Args<TIdx>(Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>): Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Core(Vector<byte>, Vector<byte>, (Vector<byte> args0, Vector<byte> args1, Vector<byte> args2, Vector<byte> args3, Vector<byte> args4)): Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Core(Vector<double>, Vector<double>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Core(Vector<double>, Vector<double>, (Vector<long> args0, Vector<long> args1, Vector<long> args2, Vector<long> args3, Vector<long> args4)): Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>): Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Core(Vector<short>, Vector<short>, (Vector<short> args0, Vector<short> args1, Vector<short> args2, Vector<short> args3, Vector<short> args4)): Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Core(Vector<int>, Vector<int>, (Vector<int> args0, Vector<int> args1, Vector<int> args2, Vector<int> args3, Vector<int> args4)): Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Core(Vector<long>, Vector<long>, (Vector<long> args0, Vector<long> args1, Vector<long> args2, Vector<long> args3, Vector<long> args4)): Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Core(Vector<sbyte>, Vector<sbyte>, (Vector<sbyte> args0, Vector<sbyte> args1, Vector<sbyte> args2, Vector<sbyte> args3, Vector<sbyte> args4)): Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Core(Vector<float>, Vector<float>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Core(Vector<float>, Vector<float>, (Vector<int> args0, Vector<int> args1, Vector<int> args2, Vector<int> args3, Vector<int> args4)): Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Core(Vector<ushort>, Vector<ushort>, (Vector<ushort> args0, Vector<ushort> args1, Vector<ushort> args2, Vector<ushort> args3, Vector<ushort> args4)): Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Core(Vector<uint>, Vector<uint>, (Vector<uint> args0, Vector<uint> args1, Vector<uint> args2, Vector<uint> args3, Vector<uint> args4)): Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX2_Core(Vector<ulong>, Vector<ulong>, (Vector<ulong> args0, Vector<ulong> args1, Vector<ulong> args2, Vector<ulong> args3, Vector<ulong> args4)): Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.

YShuffleX3(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): Shuffle and clear on 3 vectors (在3个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3(Vector<double>, Vector<double>, Vector<double>, Vector<long>): Shuffle and clear on 3 vectors (在3个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3(Vector<short>, Vector<short>, Vector<short>, Vector<short>): Shuffle and clear on 3 vectors (在3个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3(Vector<int>, Vector<int>, Vector<int>, Vector<int>): Shuffle and clear on 3 vectors (在3个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3(Vector<long>, Vector<long>, Vector<long>, Vector<long>): Shuffle and clear on 3 vectors (在3个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Shuffle and clear on 3 vectors (在3个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3(Vector<float>, Vector<float>, Vector<float>, Vector<int>): Shuffle and clear on 3 vectors (在3个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): Shuffle and clear on 3 vectors (在3个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): Shuffle and clear on 3 vectors (在3个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): Shuffle and clear on 3 vectors (在3个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3Insert(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): Shuffle and insert on 3 vectors (在3个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<long>): Shuffle and insert on 3 vectors (在3个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>): Shuffle and insert on 3 vectors (在3个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Shuffle and insert on 3 vectors (在3个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Shuffle and insert on 3 vectors (在3个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Shuffle and insert on 3 vectors (在3个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<int>): Shuffle and insert on 3 vectors (在3个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): Shuffle and insert on 3 vectors (在3个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): Shuffle and insert on 3 vectors (在3个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): Shuffle and insert on 3 vectors (在3个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Args(Vector<byte>): Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Args(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>): Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Args(Vector<short>): Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Args(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>): Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Args(Vector<int>): Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Args(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>): Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Args(Vector<long>): Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Args(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>): Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Args(Vector<sbyte>): Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Args(Vector<ushort>): Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>): Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Args(Vector<uint>): Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Args(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>): Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Args(Vector<ulong>): Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>): Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Args<TIdx>(Vector<TIdx>): Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Args<TIdx>(Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>): Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, (Vector<byte> args0, Vector<byte> args1, Vector<byte> args2, Vector<byte> args3, Vector<byte> args4)): Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Core(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Core(Vector<double>, Vector<double>, Vector<double>, Vector<double>, (Vector<long> args0, Vector<long> args1, Vector<long> args2, Vector<long> args3, Vector<long> args4)): Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>): Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, (Vector<short> args0, Vector<short> args1, Vector<short> args2, Vector<short> args3, Vector<short> args4)): Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, (Vector<int> args0, Vector<int> args1, Vector<int> args2, Vector<int> args3, Vector<int> args4)): Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, (Vector<long> args0, Vector<long> args1, Vector<long> args2, Vector<long> args3, Vector<long> args4)): Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, (Vector<sbyte> args0, Vector<sbyte> args1, Vector<sbyte> args2, Vector<sbyte> args3, Vector<sbyte> args4)): Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Core(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Core(Vector<float>, Vector<float>, Vector<float>, Vector<float>, (Vector<int> args0, Vector<int> args1, Vector<int> args2, Vector<int> args3, Vector<int> args4)): Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, (Vector<ushort> args0, Vector<ushort> args1, Vector<ushort> args2, Vector<ushort> args3, Vector<ushort> args4)): Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, (Vector<uint> args0, Vector<uint> args1, Vector<uint> args2, Vector<uint> args3, Vector<uint> args4)): Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Insert_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, (Vector<ulong> args0, Vector<ulong> args1, Vector<ulong> args2, Vector<ulong> args3, Vector<ulong> args4)): Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].

YShuffleX3Kernel(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): Only shuffle on 3 vectors (在3个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel(Vector<double>, Vector<double>, Vector<double>, Vector<long>): Only shuffle on 3 vectors (在3个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel(Vector<short>, Vector<short>, Vector<short>, Vector<short>): Only shuffle on 3 vectors (在3个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel(Vector<int>, Vector<int>, Vector<int>, Vector<int>): Only shuffle on 3 vectors (在3个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel(Vector<long>, Vector<long>, Vector<long>, Vector<long>): Only shuffle on 3 vectors (在3个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Only shuffle on 3 vectors (在3个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel(Vector<float>, Vector<float>, Vector<float>, Vector<int>): Only shuffle on 3 vectors (在3个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): Only shuffle on 3 vectors (在3个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): Only shuffle on 3 vectors (在3个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): Only shuffle on 3 vectors (在3个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Args(Vector<byte>): Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Args(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>): Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Args(Vector<short>): Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Args(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>): Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Args(Vector<int>): Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Args(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>): Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Args(Vector<long>): Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Args(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>): Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Args(Vector<sbyte>): Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Args(Vector<ushort>): Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>): Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Args(Vector<uint>): Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Args(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>): Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Args(Vector<ulong>): Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>): Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Args<TIdx>(Vector<TIdx>): Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Args<TIdx>(Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>): Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Core(Vector<byte>, Vector<byte>, Vector<byte>, (Vector<byte> args0, Vector<byte> args1, Vector<byte> args2, Vector<byte> args3)): Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Core(Vector<double>, Vector<double>, Vector<double>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Core(Vector<double>, Vector<double>, Vector<double>, (Vector<long> args0, Vector<long> args1, Vector<long> args2, Vector<long> args3)): Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>): Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Core(Vector<short>, Vector<short>, Vector<short>, (Vector<short> args0, Vector<short> args1, Vector<short> args2, Vector<short> args3)): Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Core(Vector<int>, Vector<int>, Vector<int>, (Vector<int> args0, Vector<int> args1, Vector<int> args2, Vector<int> args3)): Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Core(Vector<long>, Vector<long>, Vector<long>, (Vector<long> args0, Vector<long> args1, Vector<long> args2, Vector<long> args3)): Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, (Vector<sbyte> args0, Vector<sbyte> args1, Vector<sbyte> args2, Vector<sbyte> args3)): Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Core(Vector<float>, Vector<float>, Vector<float>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Core(Vector<float>, Vector<float>, Vector<float>, (Vector<int> args0, Vector<int> args1, Vector<int> args2, Vector<int> args3)): Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, (Vector<ushort> args0, Vector<ushort> args1, Vector<ushort> args2, Vector<ushort> args3)): Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Core(Vector<uint>, Vector<uint>, Vector<uint>, (Vector<uint> args0, Vector<uint> args1, Vector<uint> args2, Vector<uint> args3)): Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3Kernel_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, (Vector<ulong> args0, Vector<ulong> args1, Vector<ulong> args2, Vector<ulong> args3)): Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions: 0<=indices[i] && indices[i]<(Count*3).

YShuffleX3_Args(Vector<byte>): Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Args(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>): Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Args(Vector<short>): Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Args(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>): Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Args(Vector<int>): Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Args(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>): Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Args(Vector<long>): Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Args(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>): Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Args(Vector<sbyte>): Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Args(Vector<ushort>): Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>): Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Args(Vector<uint>): Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Args(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>): Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Args(Vector<ulong>): Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>): Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Args<TIdx>(Vector<TIdx>): Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Args<TIdx>(Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>): Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Core(Vector<byte>, Vector<byte>, Vector<byte>, (Vector<byte> args0, Vector<byte> args1, Vector<byte> args2, Vector<byte> args3, Vector<byte> args4)): Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Core(Vector<double>, Vector<double>, Vector<double>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Core(Vector<double>, Vector<double>, Vector<double>, (Vector<long> args0, Vector<long> args1, Vector<long> args2, Vector<long> args3, Vector<long> args4)): Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>): Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Core(Vector<short>, Vector<short>, Vector<short>, (Vector<short> args0, Vector<short> args1, Vector<short> args2, Vector<short> args3, Vector<short> args4)): Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Core(Vector<int>, Vector<int>, Vector<int>, (Vector<int> args0, Vector<int> args1, Vector<int> args2, Vector<int> args3, Vector<int> args4)): Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Core(Vector<long>, Vector<long>, Vector<long>, (Vector<long> args0, Vector<long> args1, Vector<long> args2, Vector<long> args3, Vector<long> args4)): Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, (Vector<sbyte> args0, Vector<sbyte> args1, Vector<sbyte> args2, Vector<sbyte> args3, Vector<sbyte> args4)): Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Core(Vector<float>, Vector<float>, Vector<float>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Core(Vector<float>, Vector<float>, Vector<float>, (Vector<int> args0, Vector<int> args1, Vector<int> args2, Vector<int> args3, Vector<int> args4)): Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, (Vector<ushort> args0, Vector<ushort> args1, Vector<ushort> args2, Vector<ushort> args3, Vector<ushort> args4)): Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Core(Vector<uint>, Vector<uint>, Vector<uint>, (Vector<uint> args0, Vector<uint> args1, Vector<uint> args2, Vector<uint> args3, Vector<uint> args4)): Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX3_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, (Vector<ulong> args0, Vector<ulong> args1, Vector<ulong> args2, Vector<ulong> args3, Vector<ulong> args4)): Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.

YShuffleX4(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): Shuffle and clear on 4 vectors (在4个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<long>): Shuffle and clear on 4 vectors (在4个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>): Shuffle and clear on 4 vectors (在4个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Shuffle and clear on 4 vectors (在4个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Shuffle and clear on 4 vectors (在4个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Shuffle and clear on 4 vectors (在4个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<int>): Shuffle and clear on 4 vectors (在4个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): Shuffle and clear on 4 vectors (在4个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): Shuffle and clear on 4 vectors (在4个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): Shuffle and clear on 4 vectors (在4个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4Insert(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): Shuffle and insert on 4 vectors (在4个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<long>): Shuffle and insert on 4 vectors (在4个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>): Shuffle and insert on 4 vectors (在4个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Shuffle and insert on 4 vectors (在4个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Shuffle and insert on 4 vectors (在4个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Shuffle and insert on 4 vectors (在4个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<int>): Shuffle and insert on 4 vectors (在4个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): Shuffle and insert on 4 vectors (在4个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): Shuffle and insert on 4 vectors (在4个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): Shuffle and insert on 4 vectors (在4个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Args(Vector<byte>): Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Args(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>): Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Args(Vector<short>): Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Args(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>): Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Args(Vector<int>): Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Args(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>): Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Args(Vector<long>): Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Args(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>): Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Args(Vector<sbyte>): Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Args(Vector<ushort>): Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>): Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Args(Vector<uint>): Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Args(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>): Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Args(Vector<ulong>): Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>): Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Args<TIdx>(Vector<TIdx>): Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Args<TIdx>(Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>): Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, (Vector<byte> args0, Vector<byte> args1, Vector<byte> args2, Vector<byte> args3, Vector<byte> args4)): Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Core(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Core(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<double>, (Vector<long> args0, Vector<long> args1, Vector<long> args2, Vector<long> args3, Vector<long> args4)): Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>): Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, (Vector<short> args0, Vector<short> args1, Vector<short> args2, Vector<short> args3, Vector<short> args4)): Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, (Vector<int> args0, Vector<int> args1, Vector<int> args2, Vector<int> args3, Vector<int> args4)): Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, (Vector<long> args0, Vector<long> args1, Vector<long> args2, Vector<long> args3, Vector<long> args4)): Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, (Vector<sbyte> args0, Vector<sbyte> args1, Vector<sbyte> args2, Vector<sbyte> args3, Vector<sbyte> args4)): Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Core(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Core(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<float>, (Vector<int> args0, Vector<int> args1, Vector<int> args2, Vector<int> args3, Vector<int> args4)): Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, (Vector<ushort> args0, Vector<ushort> args1, Vector<ushort> args2, Vector<ushort> args3, Vector<ushort> args4)): Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, (Vector<uint> args0, Vector<uint> args1, Vector<uint> args2, Vector<uint> args3, Vector<uint> args4)): Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Insert_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, (Vector<ulong> args0, Vector<ulong> args1, Vector<ulong> args2, Vector<ulong> args3, Vector<ulong> args4)): Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].

YShuffleX4Kernel(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): Only shuffle on 4 vectors (在4个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<long>): Only shuffle on 4 vectors (在4个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>): Only shuffle on 4 vectors (在4个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Only shuffle on 4 vectors (在4个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Only shuffle on 4 vectors (在4个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Only shuffle on 4 vectors (在4个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<int>): Only shuffle on 4 vectors (在4个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): Only shuffle on 4 vectors (在4个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): Only shuffle on 4 vectors (在4个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): Only shuffle on 4 vectors (在4个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Args(Vector<byte>): Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Args(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>): Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Args(Vector<short>): Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Args(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>): Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Args(Vector<int>): Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Args(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>): Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Args(Vector<long>): Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Args(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>): Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Args(Vector<sbyte>): Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Args(Vector<ushort>): Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>): Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Args(Vector<uint>): Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Args(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>): Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Args(Vector<ulong>): Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>): Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Args<TIdx>(Vector<TIdx>): Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Args<TIdx>(Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>): Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, (Vector<byte> args0, Vector<byte> args1, Vector<byte> args2, Vector<byte> args3)): Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Core(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Core(Vector<double>, Vector<double>, Vector<double>, Vector<double>, (Vector<long> args0, Vector<long> args1, Vector<long> args2, Vector<long> args3)): Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>): Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, (Vector<short> args0, Vector<short> args1, Vector<short> args2, Vector<short> args3)): Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, (Vector<int> args0, Vector<int> args1, Vector<int> args2, Vector<int> args3)): Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, (Vector<long> args0, Vector<long> args1, Vector<long> args2, Vector<long> args3)): Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, (Vector<sbyte> args0, Vector<sbyte> args1, Vector<sbyte> args2, Vector<sbyte> args3)): Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Core(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Core(Vector<float>, Vector<float>, Vector<float>, Vector<float>, (Vector<int> args0, Vector<int> args1, Vector<int> args2, Vector<int> args3)): Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, (Vector<ushort> args0, Vector<ushort> args1, Vector<ushort> args2, Vector<ushort> args3)): Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, (Vector<uint> args0, Vector<uint> args1, Vector<uint> args2, Vector<uint> args3)): Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4Kernel_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, (Vector<ulong> args0, Vector<ulong> args1, Vector<ulong> args2, Vector<ulong> args3)): Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic: rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions: 0<=indices[i] && indices[i]<(Count*4).

YShuffleX4_Args(Vector<byte>): Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Args(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>): Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Args(Vector<short>): Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Args(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>): Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Args(Vector<int>): Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Args(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>): Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Args(Vector<long>): Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Args(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>): Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Args(Vector<sbyte>): Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>): Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Args(Vector<ushort>): Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>): Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Args(Vector<uint>): Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Args(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>): Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Args(Vector<ulong>): Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>): Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Args<TIdx>(Vector<TIdx>): Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Args<TIdx>(Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>, out Vector<TIdx>): Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>): Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, (Vector<byte> args0, Vector<byte> args1, Vector<byte> args2, Vector<byte> args3, Vector<byte> args4)): Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Core(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Core(Vector<double>, Vector<double>, Vector<double>, Vector<double>, (Vector<long> args0, Vector<long> args1, Vector<long> args2, Vector<long> args3, Vector<long> args4)): Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>): Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, (Vector<short> args0, Vector<short> args1, Vector<short> args2, Vector<short> args3, Vector<short> args4)): Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, (Vector<int> args0, Vector<int> args1, Vector<int> args2, Vector<int> args3, Vector<int> args4)): Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>): Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, (Vector<long> args0, Vector<long> args1, Vector<long> args2, Vector<long> args3, Vector<long> args4)): Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>): Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, (Vector<sbyte> args0, Vector<sbyte> args1, Vector<sbyte> args2, Vector<sbyte> args3, Vector<sbyte> args4)): Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Core(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>): Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Core(Vector<float>, Vector<float>, Vector<float>, Vector<float>, (Vector<int> args0, Vector<int> args1, Vector<int> args2, Vector<int> args3, Vector<int> args4)): Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>): Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, (Vector<ushort> args0, Vector<ushort> args1, Vector<ushort> args2, Vector<ushort> args3, Vector<ushort> args4)): Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>): Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, (Vector<uint> args0, Vector<uint> args1, Vector<uint> args2, Vector<uint> args3, Vector<uint> args4)): Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>): Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YShuffleX4_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, (Vector<ulong> args0, Vector<ulong> args1, Vector<ulong> args2, Vector<ulong> args3, Vector<ulong> args4)): Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic: rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.

YSign(Vector<double>): Determine the sign of each element (判断各个元素的符号). Mnemonic: rt[i] := sign(value[i]).

YSign(Vector<short>): Determine the sign of each element (判断各个元素的符号). Mnemonic: rt[i] := sign(value[i]).

YSign(Vector<int>): Determine the sign of each element (判断各个元素的符号). Mnemonic: rt[i] := sign(value[i]).

YSign(Vector<long>): Determine the sign of each element (判断各个元素的符号). Mnemonic: rt[i] := sign(value[i]).

YSign(Vector<sbyte>): Determine the sign of each element (判断各个元素的符号). Mnemonic: rt[i] := sign(value[i]).

YSign(Vector<float>): Determine the sign of each element (判断各个元素的符号). Mnemonic: rt[i] := sign(value[i]).

YSignFloat(Vector<double>): Determine the sign of each element and returns a floating point number (判断各个元素的符号并返回浮点数). Mnemonic: rt[i] := signFloat(value[i]).

YSignFloat(Vector<float>): Determine the sign of each element and returns a floating point number (判断各个元素的符号并返回浮点数). Mnemonic: rt[i] := signFloat(value[i]).

Table of Contents

Class Vectors

Properties

Methods