Class Vector128s
- Namespace
- Zyl.VectorTraits
- Assembly
- VectorTraits.dll
Methods of Vector128<T>. It supports ExType, and the element type can also be (它支持扩展类型, 元素类型还可以为): ExInt128, ExUInt128, Int128, UInt128.
public static class Vector128s- Inheritance
-
Vector128s
- Inherited Members
Properties
- Abs_AcceleratedTypes
Types with hardware acceleration when running
Abs(运行Abs时具有硬件加速的类型).
- Add_AcceleratedTypes
Types with hardware acceleration when running
Add(运行Add时具有硬件加速的类型).
- AndNot_AcceleratedTypes
Types with hardware acceleration when running
AndNot(运行AndNot时具有硬件加速的类型).
- BaseInstance
Base traits instance (基本特征实例).
- BitwiseAnd_AcceleratedTypes
Types with hardware acceleration when running
BitwiseAnd(运行BitwiseAnd时具有硬件加速的类型).
- BitwiseOr_AcceleratedTypes
Types with hardware acceleration when running
BitwiseOr(运行BitwiseOr时具有硬件加速的类型).
- ByteCount
Get byte count (取得字节数量).
- Ceiling_AcceleratedTypes
Types with hardware acceleration when running
Ceiling(运行Ceiling时具有硬件加速的类型).
- ConditionalSelect_AcceleratedTypes
Types with hardware acceleration when running
ConditionalSelect(运行ConditionalSelect时具有硬件加速的类型).
- 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时具有硬件加速的类型).
- Divide_AcceleratedTypes
Types with hardware acceleration when running
Divide(运行Divide时具有硬件加速的类型).
- Dot_AcceleratedTypes
Types with hardware acceleration when running
Dot(运行Dot时具有硬件加速的类型).
- EqualsAll_AcceleratedTypes
Types with hardware acceleration when running
EqualsAll(运行EqualsAll时具有硬件加速的类型).
- EqualsAny_AcceleratedTypes
Types with hardware acceleration when running
EqualsAny(运行EqualsAny时具有硬件加速的类型).
- Equals_AcceleratedTypes
Types with hardware acceleration when running
Equals(运行Equals时具有硬件加速的类型).
- ExtractMostSignificantBits_AcceleratedTypes
Types with hardware acceleration when running
ExtractMostSignificantBits(运行ExtractMostSignificantBits时具有硬件加速的类型).
- Floor_AcceleratedTypes
Types with hardware acceleration when running
Floor(运行Floor时具有硬件加速的类型).
- GreaterThanAll_AcceleratedTypes
Types with hardware acceleration when running
GreaterThanAll(运行GreaterThanAll时具有硬件加速的类型).
- GreaterThanAny_AcceleratedTypes
Types with hardware acceleration when running
GreaterThanAny(运行GreaterThanAny时具有硬件加速的类型).
- GreaterThanOrEqualAll_AcceleratedTypes
Types with hardware acceleration when running
GreaterThanOrEqualAll(运行GreaterThanOrEqualAll时具有硬件加速的类型).
- GreaterThanOrEqualAny_AcceleratedTypes
Types with hardware acceleration when running
GreaterThanOrEqualAny(运行GreaterThanOrEqualAny时具有硬件加速的类型).
- GreaterThanOrEqual_AcceleratedTypes
Types with hardware acceleration when running
GreaterThanOrEqual(运行GreaterThanOrEqual时具有硬件加速的类型).
- GreaterThan_AcceleratedTypes
Types with hardware acceleration when running
GreaterThan(运行GreaterThan时具有硬件加速的类型).
- Instance
Best traits instance (最佳特征实例).
- InstanceDynamic
Best traits instance dynamic value (最佳特征实例动态值).
- IsHardwareAccelerated
Whether to exist hardware accelerated (是否存在硬件加速).
- IsSupported
Whether to support the run (是否支持运行).
- LessThanAll_AcceleratedTypes
Types with hardware acceleration when running
LessThanAll(运行LessThanAll时具有硬件加速的类型).
- LessThanAny_AcceleratedTypes
Types with hardware acceleration when running
LessThanAny(运行LessThanAny时具有硬件加速的类型).
- LessThanOrEqualAll_AcceleratedTypes
Types with hardware acceleration when running
LessThanOrEqualAll(运行LessThanOrEqualAll时具有硬件加速的类型).
- LessThanOrEqualAny_AcceleratedTypes
Types with hardware acceleration when running
LessThanOrEqualAny(运行LessThanOrEqualAny时具有硬件加速的类型).
- LessThanOrEqual_AcceleratedTypes
Types with hardware acceleration when running
LessThanOrEqual(运行LessThanOrEqual时具有硬件加速的类型).
- LessThan_AcceleratedTypes
Types with hardware acceleration when running
LessThan(运行LessThan时具有硬件加速的类型).
- Max_AcceleratedTypes
Types with hardware acceleration when running
Max(运行Max时具有硬件加速的类型).
- Min_AcceleratedTypes
Types with hardware acceleration when running
Min(运行Min时具有硬件加速的类型).
- 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时具有硬件加速的类型).
- Negate_AcceleratedTypes
Types with hardware acceleration when running
Negate(运行Negate时具有硬件加速的类型).
- OnesComplement_AcceleratedTypes
Types with hardware acceleration when running
OnesComplement(运行OnesComplement时具有硬件加速的类型).
- 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时具有硬件加速的类型).
- Subtract_AcceleratedTypes
Types with hardware acceleration when running
Subtract(运行Subtract时具有硬件加速的类型).
- 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时具有硬件加速的类型).
- Xor_AcceleratedTypes
Types with hardware acceleration when running
Xor(运行Xor时具有硬件加速的类型).
- 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
- Abs(Vector128<double>)
Computes the absolute value of each element in a vector (计算向量中每个元素的绝对值). Mnemonic:
rt[i] := abs(vector[i]).
- Abs(Vector128<short>)
Computes the absolute value of each element in a vector (计算向量中每个元素的绝对值). Mnemonic:
rt[i] := abs(vector[i]).
- Abs(Vector128<int>)
Computes the absolute value of each element in a vector (计算向量中每个元素的绝对值). Mnemonic:
rt[i] := abs(vector[i]).
- Abs(Vector128<long>)
Computes the absolute value of each element in a vector (计算向量中每个元素的绝对值). Mnemonic:
rt[i] := abs(vector[i]).
- Abs(Vector128<sbyte>)
Computes the absolute value of each element in a vector (计算向量中每个元素的绝对值). Mnemonic:
rt[i] := abs(vector[i]).
- Abs(Vector128<float>)
Computes the absolute value of each element in a vector (计算向量中每个元素的绝对值). Mnemonic:
rt[i] := abs(vector[i]).
- Add(Vector128<byte>, Vector128<byte>)
Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic:
rt[i] := left[i] + right[i].
- Add(Vector128<double>, Vector128<double>)
Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic:
rt[i] := left[i] + right[i].
- Add(Vector128<short>, Vector128<short>)
Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic:
rt[i] := left[i] + right[i].
- Add(Vector128<int>, Vector128<int>)
Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic:
rt[i] := left[i] + right[i].
- Add(Vector128<long>, Vector128<long>)
Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic:
rt[i] := left[i] + right[i].
- Add(Vector128<sbyte>, Vector128<sbyte>)
Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic:
rt[i] := left[i] + right[i].
- Add(Vector128<float>, Vector128<float>)
Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic:
rt[i] := left[i] + right[i].
- Add(Vector128<ushort>, Vector128<ushort>)
Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic:
rt[i] := left[i] + right[i].
- Add(Vector128<uint>, Vector128<uint>)
Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic:
rt[i] := left[i] + right[i].
- Add(Vector128<ulong>, Vector128<ulong>)
Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic:
rt[i] := left[i] + right[i].
- AndNot<T>(Vector128<T>, Vector128<T>)
Computes the bitwise-and of a given vector and the ones complement of another vector (计算一个给定的向量和另一个向量反码的位与). Mnemonic:
rt[i] := left[i] & ~right[i].
- BitEquals<T>(Vector128<T>, Vector128<T>)
Returns a value that indicates whether this instance is binary equal to a specified vector (返回一个值，该值指示此实例是否与指定的向量二进制相等).
- BitwiseAnd<T>(Vector128<T>, Vector128<T>)
Computes the bitwise-and of two vectors (计算两个向量的位与). Mnemonic:
rt[i] := left[i] & right[i].
- BitwiseOr<T>(Vector128<T>, Vector128<T>)
Computes the bitwise-or of two vectors (计算两个向量的位或). Mnemonic:
rt[i] := left[i] | right[i].
- Ceiling(Vector128<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(Vector128<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]).
- ConditionalSelect(Vector128<int>, Vector128<float>, Vector128<float>)
Conditionally selects a value from two vectors on a bitwise basis (按条件从两个向量中按位选择值). Mnemonic:
rt[i] := (left[i] & condition[i]) | (right[i] & ~condition[i]).
- ConditionalSelect(Vector128<long>, Vector128<double>, Vector128<double>)
Conditionally selects a value from two vectors on a bitwise basis (按条件从两个向量中按位选择值). Mnemonic:
rt[i] := (left[i] & condition[i]) | (right[i] & ~condition[i]).
- ConditionalSelect<T>(Vector128<T>, Vector128<T>, Vector128<T>)
Conditionally selects a value from two vectors on a bitwise basis (按条件从两个向量中按位选择值). Mnemonic:
rt[i] := (left[i] & condition[i]) | (right[i] & ~condition[i]).
- ConvertToDouble(Vector128<long>)
Convert to a vector whose elements are of type Double (转换为元素类型是Double的向量).. Mnemonic:
rt[i] := (Double)(value[i]).
- ConvertToDouble(Vector128<ulong>)
Convert to a vector whose elements are of type Double (转换为元素类型是Double的向量).. Mnemonic:
rt[i] := (Double)(value[i]).
- ConvertToDouble_Range52(Vector128<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(Vector128<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(Vector128<float>)
Convert to a vector whose elements are of type Int32 (转换为元素类型是Int32的向量).. Mnemonic:
rt[i] := (Int32)(value[i]).
- ConvertToInt64(Vector128<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(Vector128<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(Vector128<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(Vector128<int>)
Convert to a vector whose elements are of type Single (转换为元素类型是Single的向量).. Mnemonic:
rt[i] := (Single)(value[i]).
- ConvertToSingle(Vector128<uint>)
Convert to a vector whose elements are of type Single (转换为元素类型是Single的向量).. Mnemonic:
rt[i] := (Single)(value[i]).
- ConvertToUInt32(Vector128<float>)
Convert to a vector whose elements are of type UInt32 (转换为元素类型是UInt32的向量).. Mnemonic:
rt[i] := (UInt32)(value[i]).
- ConvertToUInt64(Vector128<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(Vector128<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(Vector128<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 Vector128<T> whose components are of a specified 128-bits integer (创建一个 Vector128<T>，其元素为指定的128位整数).
- CreateByBits<T>(long)
Creates a Vector128<T> whose components are of a specified integer bits (创建一个 Vector128<T>，其元素为指定的整数位).
- CreateByDoubleLoop<T>(double, double)
Creates a Vector128<T> from double value
forloop (创建一个 Vector128<T>，其元素来自双精度浮点值的for循环).
- CreateByDouble<T>(double)
Creates a Vector128<T> whose components are of a specified double value (创建一个 Vector128<T>，其元素为指定的双精度浮点值).
- CreateByFunc<T>(Func<int, T>)
Creates a new Vector128<T> from a from the given Func<T, TResult> (从给定 Func<T, TResult> 创建一个新的 Vector128<T> ) .
- CreateByFunc<T, TUserdata>(Func<int, TUserdata, T>, TUserdata)
Creates a new Vector128<T> from a from the given Func<T1, T2, TResult> (从给定 Func<T1, T2, TResult> 创建一个新的 Vector128<T> ) .
- CreatePadding<T>(ReadOnlySpan<T>)
Padding creates a new Vector128<T> from a given span (从指定跨度补齐创建一个 Vector128<T>). The element after values is initialized to 0(values 之后的元素会初始化为0).
- CreatePadding<T>(ReadOnlySpan<T>, int, int)
Padding creates a new Vector128<T> from a given span starting at a specified index position (于指定索引位置开始，从指定跨度补齐创建一个 Vector128<T>). The element after values is initialized to 0(values 之后的元素会初始化为0).
- CreatePadding<T>(params T[])
Padding creates a new Vector128<T> from a given array (从给定数组补齐创建一个新的 Vector128<T> ). The element after values is initialized to 0(values 之后的元素会初始化为0).
- CreatePadding<T>(T[], int, int)
Padding creates a new Vector128<T> from a given span starting at a specified index position (于指定索引位置开始，从指定跨度补齐创建一个 Vector128<T>). The element after values is initialized to 0(values 之后的元素会初始化为0).
- CreateRotate<T>(ReadOnlySpan<T>)
Rotate creates a new Vector128<T> from a given span (从指定跨度旋转创建一个 Vector128<T>).
- CreateRotate<T>(ReadOnlySpan<T>, int, int)
Rotate creates a new Vector128<T> from a given span starting at a specified index position (于指定索引位置开始，从指定跨度旋转创建一个 Vector128<T>).
- CreateRotate<T>(params T[])
Rotate creates a new Vector128<T> from a given array (从给定数组旋转创建一个新的 Vector128<T> ).
- CreateRotate<T>(T[], int, int)
Rotate creates a new Vector128<T> from a given span starting at a specified index position (于指定索引位置开始，从指定跨度旋转创建一个 Vector128<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 Vector128<T> from a given read-only span of bytes (根据给定的只读字节跨度构造一个 Vector128<T>).
- Create<T>(ReadOnlySpan<T>)
Creates a new Vector128<T> from a from the given ReadOnlySpan<T> (根据给定的 ReadOnlySpan<T> 构造一个 Vector128<T>).
- Create<T>(Vector64<T>, Vector64<T>)
Create a new vector instance from two shorter vector instances. (从两个更短的向量实例, 来创建新的向量实例).
- Create<T>(Span<T>)
Creates a new Vector128<T> from a from the given Span<T> (根据给定的 Span<T> 构造一个 Vector128<T>).
- Create<T>(T)
Creates a new Vector128<T> instance with all elements initialized to the specified value (创建新的 Vector128<T> 实例，其中所有元素已初始化为指定值).
- Create<T>(T[])
Creates a new Vector128<T> from a given array (从给定数组创建一个新的 Vector128<T> ).
- Create<T>(T[], int)
Creates a new Vector128<T> from a given array starting at a specified index position (于指定索引位置开始，从指定数组创建一个 Vector128<T>).
- Divide(Vector128<double>, Vector128<double>)
Divides two vectors to compute their quotient (将两个向量相除来计算它们的商). Mnemonic:
rt[i] := left[i] / right[i].
- Divide(Vector128<float>, Vector128<float>)
Divides two vectors to compute their quotient (将两个向量相除来计算它们的商). Mnemonic:
rt[i] := left[i] / right[i].
- Dot(Vector128<byte>, Vector128<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(Vector128<double>, Vector128<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(Vector128<short>, Vector128<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(Vector128<int>, Vector128<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(Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<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(Vector128<float>, Vector128<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(Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<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].
- Equals(Vector128<byte>, Vector128<byte>)
Compares two vectors to determine if they are equal on a per-element basis (比较两个向量，确定它们每个元素是否相等). Mnemonic:
rt[i] := to_mask(left[i] == right[i]).
- Equals(Vector128<double>, Vector128<double>)
Compares two vectors to determine if they are equal on a per-element basis (比较两个向量，确定它们每个元素是否相等). Mnemonic:
rt[i] := to_mask(left[i] == right[i]).
- Equals(Vector128<short>, Vector128<short>)
Compares two vectors to determine if they are equal on a per-element basis (比较两个向量，确定它们每个元素是否相等). Mnemonic:
rt[i] := to_mask(left[i] == right[i]).
- Equals(Vector128<int>, Vector128<int>)
Compares two vectors to determine if they are equal on a per-element basis (比较两个向量，确定它们每个元素是否相等). Mnemonic:
rt[i] := to_mask(left[i] == right[i]).
- Equals(Vector128<long>, Vector128<long>)
Compares two vectors to determine if they are equal on a per-element basis (比较两个向量，确定它们每个元素是否相等). Mnemonic:
rt[i] := to_mask(left[i] == right[i]).
- Equals(Vector128<sbyte>, Vector128<sbyte>)
Compares two vectors to determine if they are equal on a per-element basis (比较两个向量，确定它们每个元素是否相等). Mnemonic:
rt[i] := to_mask(left[i] == right[i]).
- Equals(Vector128<float>, Vector128<float>)
Compares two vectors to determine if they are equal on a per-element basis (比较两个向量，确定它们每个元素是否相等). Mnemonic:
rt[i] := to_mask(left[i] == right[i]).
- Equals(Vector128<ushort>, Vector128<ushort>)
Compares two vectors to determine if they are equal on a per-element basis (比较两个向量，确定它们每个元素是否相等). Mnemonic:
rt[i] := to_mask(left[i] == right[i]).
- Equals(Vector128<uint>, Vector128<uint>)
Compares two vectors to determine if they are equal on a per-element basis (比较两个向量，确定它们每个元素是否相等). Mnemonic:
rt[i] := to_mask(left[i] == right[i]).
- Equals(Vector128<ulong>, Vector128<ulong>)
Compares two vectors to determine if they are equal on a per-element basis (比较两个向量，确定它们每个元素是否相等). Mnemonic:
rt[i] := to_mask(left[i] == right[i]).
- EqualsAll(Vector128<byte>, Vector128<byte>)
Compares two vectors to determine if all elements are equal (比较两个向量以判定所有元素是否相等). Mnemonic:
rt := (left[0] == right[0]) && (left[1] == right[1]) && ... && (left[Count-1] == right[Count-1]).
- EqualsAll(Vector128<double>, Vector128<double>)
Compares two vectors to determine if all elements are equal (比较两个向量以判定所有元素是否相等). Mnemonic:
rt := (left[0] == right[0]) && (left[1] == right[1]) && ... && (left[Count-1] == right[Count-1]).
- EqualsAll(Vector128<short>, Vector128<short>)
Compares two vectors to determine if all elements are equal (比较两个向量以判定所有元素是否相等). Mnemonic:
rt := (left[0] == right[0]) && (left[1] == right[1]) && ... && (left[Count-1] == right[Count-1]).
- EqualsAll(Vector128<int>, Vector128<int>)
Compares two vectors to determine if all elements are equal (比较两个向量以判定所有元素是否相等). Mnemonic:
rt := (left[0] == right[0]) && (left[1] == right[1]) && ... && (left[Count-1] == right[Count-1]).
- EqualsAll(Vector128<long>, Vector128<long>)
Compares two vectors to determine if all elements are equal (比较两个向量以判定所有元素是否相等). Mnemonic:
rt := (left[0] == right[0]) && (left[1] == right[1]) && ... && (left[Count-1] == right[Count-1]).
- EqualsAll(Vector128<sbyte>, Vector128<sbyte>)
Compares two vectors to determine if all elements are equal (比较两个向量以判定所有元素是否相等). Mnemonic:
rt := (left[0] == right[0]) && (left[1] == right[1]) && ... && (left[Count-1] == right[Count-1]).
- EqualsAll(Vector128<float>, Vector128<float>)
Compares two vectors to determine if all elements are equal (比较两个向量以判定所有元素是否相等). Mnemonic:
rt := (left[0] == right[0]) && (left[1] == right[1]) && ... && (left[Count-1] == right[Count-1]).
- EqualsAll(Vector128<ushort>, Vector128<ushort>)
Compares two vectors to determine if all elements are equal (比较两个向量以判定所有元素是否相等). Mnemonic:
rt := (left[0] == right[0]) && (left[1] == right[1]) && ... && (left[Count-1] == right[Count-1]).
- EqualsAll(Vector128<uint>, Vector128<uint>)
Compares two vectors to determine if all elements are equal (比较两个向量以判定所有元素是否相等). Mnemonic:
rt := (left[0] == right[0]) && (left[1] == right[1]) && ... && (left[Count-1] == right[Count-1]).
- EqualsAll(Vector128<ulong>, Vector128<ulong>)
Compares two vectors to determine if all elements are equal (比较两个向量以判定所有元素是否相等). Mnemonic:
rt := (left[0] == right[0]) && (left[1] == right[1]) && ... && (left[Count-1] == right[Count-1]).
- EqualsAny(Vector128<byte>, Vector128<byte>)
Compares two vectors to determine if any elements are equal (比较两个向量以判定任一元素是否相等). Mnemonic:
rt := (left[0] == right[0]) || (left[1] == right[1]) || ... || (left[Count-1] == right[Count-1]).
- EqualsAny(Vector128<double>, Vector128<double>)
Compares two vectors to determine if any elements are equal (比较两个向量以判定任一元素是否相等). Mnemonic:
rt := (left[0] == right[0]) || (left[1] == right[1]) || ... || (left[Count-1] == right[Count-1]).
- EqualsAny(Vector128<short>, Vector128<short>)
Compares two vectors to determine if any elements are equal (比较两个向量以判定任一元素是否相等). Mnemonic:
rt := (left[0] == right[0]) || (left[1] == right[1]) || ... || (left[Count-1] == right[Count-1]).
- EqualsAny(Vector128<int>, Vector128<int>)
Compares two vectors to determine if any elements are equal (比较两个向量以判定任一元素是否相等). Mnemonic:
rt := (left[0] == right[0]) || (left[1] == right[1]) || ... || (left[Count-1] == right[Count-1]).
- EqualsAny(Vector128<long>, Vector128<long>)
Compares two vectors to determine if any elements are equal (比较两个向量以判定任一元素是否相等). Mnemonic:
rt := (left[0] == right[0]) || (left[1] == right[1]) || ... || (left[Count-1] == right[Count-1]).
- EqualsAny(Vector128<sbyte>, Vector128<sbyte>)
Compares two vectors to determine if any elements are equal (比较两个向量以判定任一元素是否相等). Mnemonic:
rt := (left[0] == right[0]) || (left[1] == right[1]) || ... || (left[Count-1] == right[Count-1]).
- EqualsAny(Vector128<float>, Vector128<float>)
Compares two vectors to determine if any elements are equal (比较两个向量以判定任一元素是否相等). Mnemonic:
rt := (left[0] == right[0]) || (left[1] == right[1]) || ... || (left[Count-1] == right[Count-1]).
- EqualsAny(Vector128<ushort>, Vector128<ushort>)
Compares two vectors to determine if any elements are equal (比较两个向量以判定任一元素是否相等). Mnemonic:
rt := (left[0] == right[0]) || (left[1] == right[1]) || ... || (left[Count-1] == right[Count-1]).
- EqualsAny(Vector128<uint>, Vector128<uint>)
Compares two vectors to determine if any elements are equal (比较两个向量以判定任一元素是否相等). Mnemonic:
rt := (left[0] == right[0]) || (left[1] == right[1]) || ... || (left[Count-1] == right[Count-1]).
- EqualsAny(Vector128<ulong>, Vector128<ulong>)
Compares two vectors to determine if any elements are equal (比较两个向量以判定任一元素是否相等). Mnemonic:
rt := (left[0] == right[0]) || (left[1] == right[1]) || ... || (left[Count-1] == right[Count-1]).
- ExAsByte<T>(Vector128<T>)
(ExType) Reinterprets a Vector128<T> as a new Vector128<T> of type byte (将 Vector128<T> 重新解释为 byte 类型的新 Vector128<T>).
- ExAsDouble<T>(Vector128<T>)
(ExType) Reinterprets a Vector128<T> as a new Vector128<T> of type double (将 Vector128<T> 重新解释为 double 类型的新 Vector128<T>).
- ExAsExInt128<T>(Vector128<T>)
(ExType) Reinterprets a Vector128<T> as a new Vector128<T> of type ExInt128 (将 Vector128<T> 重新解释为 ExInt128 类型的新 Vector128<T>).
- ExAsExUInt128<T>(Vector128<T>)
(ExType) Reinterprets a Vector128<T> as a new Vector128<T> of type ExUInt128 (将 Vector128<T> 重新解释为 ExUInt128 类型的新 Vector128<T>).
- ExAsInt128<T>(Vector128<T>)
(ExType) Reinterprets a Vector128<T> as a new Vector128<T> of type Int128 (将 Vector128<T> 重新解释为 Int128 类型的新 Vector128<T>).
- ExAsInt16<T>(Vector128<T>)
(ExType) Reinterprets a Vector128<T> as a new Vector128<T> of type short (将 Vector128<T> 重新解释为 short 类型的新 Vector128<T>).
- ExAsInt32<T>(Vector128<T>)
(ExType) Reinterprets a Vector128<T> as a new Vector128<T> of type int (将 Vector128<T> 重新解释为 int 类型的新 Vector128<T>).
- ExAsInt64<T>(Vector128<T>)
(ExType) Reinterprets a Vector128<T> as a new Vector128<T> of type long (将 Vector128<T> 重新解释为 long 类型的新 Vector128<T>).
- ExAsSByte<T>(Vector128<T>)
(ExType) Reinterprets a Vector128<T> as a new Vector128<T> of type sbyte (将 Vector128<T> 重新解释为 sbyte 类型的新 Vector128<T>).
- ExAsSingle<T>(Vector128<T>)
(ExType) Reinterprets a Vector128<T> as a new Vector128<T> of type float (将 Vector128<T> 重新解释为 float 类型的新 Vector128<T>).
- ExAsUInt128<T>(Vector128<T>)
(ExType) Reinterprets a Vector128<T> as a new Vector128<T> of type UInt128 (将 Vector128<T> 重新解释为 UInt128 类型的新 Vector128<T>).
- ExAsUInt16<T>(Vector128<T>)
(ExType) Reinterprets a Vector128<T> as a new Vector128<T> of type ushort (将 Vector128<T> 重新解释为 ushort 类型的新 Vector128<T>).
- ExAsUInt32<T>(Vector128<T>)
(ExType) Reinterprets a Vector128<T> as a new Vector128<T> of type uint (将 Vector128<T> 重新解释为 uint 类型的新 Vector128<T>).
- ExAsUInt64<T>(Vector128<T>)
(ExType) Reinterprets a Vector128<T> as a new Vector128<T> of type ulong (将 Vector128<T> 重新解释为 ulong 类型的新 Vector128<T>).
- ExAsVector128<T>(Vector<T>)
(ExType) Reinterprets a Vector<T> as a new Vector128<T> (将 Vector<T> 重新解释为新的 Vector128<T>). It supports ExType, so there is no element type check (它支持扩展类型, 故没有元素类型检查).
- ExAsVector<T>(Vector128<T>)
(ExType) Reinterprets a Vector128<T> as a new Vector<T> (将 Vector128<T> 重新解释为新的 Vector<T>). It supports ExType, so there is no element type check (它支持扩展类型, 故没有元素类型检查).
- ExAs<TFrom, TTo>(Vector128<TFrom>)
(ExType) Reinterprets a Vector128<T> of type
TFromas a new Vector128<T> of typeTTo. It supports ExType, so there is no element type check (将TFrom类型的 Vector128<T> 重新解释为TTo类型的新 Vector128<T>. 它支持扩展类型, 故没有元素类型检查).
- ExGetElement<T>(in Vector128<T>, int)
(ExType) Gets the element at the specified index. It is unsafe method, it ignores the index range check (获取指定索引处的元素. 它是非安全的, 它忽略了索引的范围检查).
- ExGetLower<T>(Vector128<T>)
Gets the value of the lower 64-bits as a new Vector64<T> (获取低 64 位的值作为新的 Vector64<T>).
- ExGetUpper<T>(Vector128<T>)
Gets the value of the upper 64-bits as a new Vector64<T> (获取高 64 位的值作为新的 Vector64<T>).
- ExToScalar<T>(Vector128<T>)
Converts the given vector to a scalar containing the value of the first element (将给定向量转换为首个元素的值的标量).
- ExToVector256Unsafe<T>(Vector128<T>)
Converts the given vector to a new Vector256<T> with the lower 128-bits set to the value of the given vector and the upper 128-bits left uninitialized (将给定向量转换为新 Vector256<T> 向量，其中低 128 位设置为给定向量的值，而高 128 位则未初始化).
- ExToVector256<T>(Vector128<T>)
Converts the given vector to a new Vector256<T> with the lower 128-bits set to the value of the given vector and the upper 128-bits initialized to zero (将给定向量转换为新 Vector256<T> 向量，其中较低的 128 位设置为给定向量的值，并将高 128 位初始化为零).
- ExWithLower<T>(Vector128<T>, Vector64<T>)
Creates a new Vector128<T> with the lower 64-bits set to the specified value and the upper 64-bits set to the same value as that in the given vector (创建一个新的 Vector128<T>，将低 64 位设置为指定值，并将高 64 位设置为与给定向量中的值相同的值).
- ExWithUpper<T>(Vector128<T>, Vector64<T>)
Creates a new Vector128<T> with the upper 64-bits set to the specified value and the lower 64-bits set to the same value as that in the given vector (创建一个新的 Vector128<T>，将高 64 位设置为指定值，并将低 64 位设置为与给定向量中的值相同的值).
- ExtractMostSignificantBits(Vector128<byte>)
Extracts the most significant bit from each element in a vector (从向量的每个元素中提取最高有效位). Mnemonic:
rt |= getMostSignificantBit(vector[i]) << i = ( vector[i] >>> (sizeof(T)*8-1) ) << i.
- ExtractMostSignificantBits(Vector128<double>)
Extracts the most significant bit from each element in a vector (从向量的每个元素中提取最高有效位). Mnemonic:
rt |= getMostSignificantBit(vector[i]) << i = ( vector[i] >>> (sizeof(T)*8-1) ) << i.
- ExtractMostSignificantBits(Vector128<short>)
Extracts the most significant bit from each element in a vector (从向量的每个元素中提取最高有效位). Mnemonic:
rt |= getMostSignificantBit(vector[i]) << i = ( vector[i] >>> (sizeof(T)*8-1) ) << i.
- ExtractMostSignificantBits(Vector128<int>)
Extracts the most significant bit from each element in a vector (从向量的每个元素中提取最高有效位). Mnemonic:
rt |= getMostSignificantBit(vector[i]) << i = ( vector[i] >>> (sizeof(T)*8-1) ) << i.
- ExtractMostSignificantBits(Vector128<long>)
Extracts the most significant bit from each element in a vector (从向量的每个元素中提取最高有效位). Mnemonic:
rt |= getMostSignificantBit(vector[i]) << i = ( vector[i] >>> (sizeof(T)*8-1) ) << i.
- ExtractMostSignificantBits(Vector128<sbyte>)
Extracts the most significant bit from each element in a vector (从向量的每个元素中提取最高有效位). Mnemonic:
rt |= getMostSignificantBit(vector[i]) << i = ( vector[i] >>> (sizeof(T)*8-1) ) << i.
- ExtractMostSignificantBits(Vector128<float>)
Extracts the most significant bit from each element in a vector (从向量的每个元素中提取最高有效位). Mnemonic:
rt |= getMostSignificantBit(vector[i]) << i = ( vector[i] >>> (sizeof(T)*8-1) ) << i.
- ExtractMostSignificantBits(Vector128<ushort>)
Extracts the most significant bit from each element in a vector (从向量的每个元素中提取最高有效位). Mnemonic:
rt |= getMostSignificantBit(vector[i]) << i = ( vector[i] >>> (sizeof(T)*8-1) ) << i.
- ExtractMostSignificantBits(Vector128<uint>)
Extracts the most significant bit from each element in a vector (从向量的每个元素中提取最高有效位). Mnemonic:
rt |= getMostSignificantBit(vector[i]) << i = ( vector[i] >>> (sizeof(T)*8-1) ) << i.
- ExtractMostSignificantBits(Vector128<ulong>)
Extracts the most significant bit from each element in a vector (从向量的每个元素中提取最高有效位). Mnemonic:
rt |= getMostSignificantBit(vector[i]) << i = ( vector[i] >>> (sizeof(T)*8-1) ) << i.
- Floor(Vector128<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(Vector128<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]).
- 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(Vector128<byte>, Vector128<byte>)
Compares two vectors to determine which is greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更大). Mnemonic:
rt[i] := to_mask(left[i] > right[i]).
- GreaterThan(Vector128<double>, Vector128<double>)
Compares two vectors to determine which is greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更大). Mnemonic:
rt[i] := to_mask(left[i] > right[i]).
- GreaterThan(Vector128<short>, Vector128<short>)
Compares two vectors to determine which is greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更大). Mnemonic:
rt[i] := to_mask(left[i] > right[i]).
- GreaterThan(Vector128<int>, Vector128<int>)
Compares two vectors to determine which is greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更大). Mnemonic:
rt[i] := to_mask(left[i] > right[i]).
- GreaterThan(Vector128<long>, Vector128<long>)
Compares two vectors to determine which is greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更大). Mnemonic:
rt[i] := to_mask(left[i] > right[i]).
- GreaterThan(Vector128<sbyte>, Vector128<sbyte>)
Compares two vectors to determine which is greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更大). Mnemonic:
rt[i] := to_mask(left[i] > right[i]).
- GreaterThan(Vector128<float>, Vector128<float>)
Compares two vectors to determine which is greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更大). Mnemonic:
rt[i] := to_mask(left[i] > right[i]).
- GreaterThan(Vector128<ushort>, Vector128<ushort>)
Compares two vectors to determine which is greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更大). Mnemonic:
rt[i] := to_mask(left[i] > right[i]).
- GreaterThan(Vector128<uint>, Vector128<uint>)
Compares two vectors to determine which is greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更大). Mnemonic:
rt[i] := to_mask(left[i] > right[i]).
- GreaterThan(Vector128<ulong>, Vector128<ulong>)
Compares two vectors to determine which is greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更大). Mnemonic:
rt[i] := to_mask(left[i] > right[i]).
- GreaterThanAll(Vector128<byte>, Vector128<byte>)
Compares two vectors to determine if all elements are greater (比较两个向量以判定所有元素是否大于). Mnemonic:
rt := (left[0] > right[0]) && (left[1] > right[1]) && ... && (left[Count-1] > right[Count-1]).
- GreaterThanAll(Vector128<double>, Vector128<double>)
Compares two vectors to determine if all elements are greater (比较两个向量以判定所有元素是否大于). Mnemonic:
rt := (left[0] > right[0]) && (left[1] > right[1]) && ... && (left[Count-1] > right[Count-1]).
- GreaterThanAll(Vector128<short>, Vector128<short>)
Compares two vectors to determine if all elements are greater (比较两个向量以判定所有元素是否大于). Mnemonic:
rt := (left[0] > right[0]) && (left[1] > right[1]) && ... && (left[Count-1] > right[Count-1]).
- GreaterThanAll(Vector128<int>, Vector128<int>)
Compares two vectors to determine if all elements are greater (比较两个向量以判定所有元素是否大于). Mnemonic:
rt := (left[0] > right[0]) && (left[1] > right[1]) && ... && (left[Count-1] > right[Count-1]).
- GreaterThanAll(Vector128<long>, Vector128<long>)
Compares two vectors to determine if all elements are greater (比较两个向量以判定所有元素是否大于). Mnemonic:
rt := (left[0] > right[0]) && (left[1] > right[1]) && ... && (left[Count-1] > right[Count-1]).
- GreaterThanAll(Vector128<sbyte>, Vector128<sbyte>)
Compares two vectors to determine if all elements are greater (比较两个向量以判定所有元素是否大于). Mnemonic:
rt := (left[0] > right[0]) && (left[1] > right[1]) && ... && (left[Count-1] > right[Count-1]).
- GreaterThanAll(Vector128<float>, Vector128<float>)
Compares two vectors to determine if all elements are greater (比较两个向量以判定所有元素是否大于). Mnemonic:
rt := (left[0] > right[0]) && (left[1] > right[1]) && ... && (left[Count-1] > right[Count-1]).
- GreaterThanAll(Vector128<ushort>, Vector128<ushort>)
Compares two vectors to determine if all elements are greater (比较两个向量以判定所有元素是否大于). Mnemonic:
rt := (left[0] > right[0]) && (left[1] > right[1]) && ... && (left[Count-1] > right[Count-1]).
- GreaterThanAll(Vector128<uint>, Vector128<uint>)
Compares two vectors to determine if all elements are greater (比较两个向量以判定所有元素是否大于). Mnemonic:
rt := (left[0] > right[0]) && (left[1] > right[1]) && ... && (left[Count-1] > right[Count-1]).
- GreaterThanAll(Vector128<ulong>, Vector128<ulong>)
Compares two vectors to determine if all elements are greater (比较两个向量以判定所有元素是否大于). Mnemonic:
rt := (left[0] > right[0]) && (left[1] > right[1]) && ... && (left[Count-1] > right[Count-1]).
- GreaterThanAny(Vector128<byte>, Vector128<byte>)
Compares two vectors to determine if any elements are greater (比较两个向量以判定任一元素是否大于). Mnemonic:
rt := (left[0] > right[0]) || (left[1] > right[1]) || ... || (left[Count-1] > right[Count-1]).
- GreaterThanAny(Vector128<double>, Vector128<double>)
Compares two vectors to determine if any elements are greater (比较两个向量以判定任一元素是否大于). Mnemonic:
rt := (left[0] > right[0]) || (left[1] > right[1]) || ... || (left[Count-1] > right[Count-1]).
- GreaterThanAny(Vector128<short>, Vector128<short>)
Compares two vectors to determine if any elements are greater (比较两个向量以判定任一元素是否大于). Mnemonic:
rt := (left[0] > right[0]) || (left[1] > right[1]) || ... || (left[Count-1] > right[Count-1]).
- GreaterThanAny(Vector128<int>, Vector128<int>)
Compares two vectors to determine if any elements are greater (比较两个向量以判定任一元素是否大于). Mnemonic:
rt := (left[0] > right[0]) || (left[1] > right[1]) || ... || (left[Count-1] > right[Count-1]).
- GreaterThanAny(Vector128<long>, Vector128<long>)
Compares two vectors to determine if any elements are greater (比较两个向量以判定任一元素是否大于). Mnemonic:
rt := (left[0] > right[0]) || (left[1] > right[1]) || ... || (left[Count-1] > right[Count-1]).
- GreaterThanAny(Vector128<sbyte>, Vector128<sbyte>)
Compares two vectors to determine if any elements are greater (比较两个向量以判定任一元素是否大于). Mnemonic:
rt := (left[0] > right[0]) || (left[1] > right[1]) || ... || (left[Count-1] > right[Count-1]).
- GreaterThanAny(Vector128<float>, Vector128<float>)
Compares two vectors to determine if any elements are greater (比较两个向量以判定任一元素是否大于). Mnemonic:
rt := (left[0] > right[0]) || (left[1] > right[1]) || ... || (left[Count-1] > right[Count-1]).
- GreaterThanAny(Vector128<ushort>, Vector128<ushort>)
Compares two vectors to determine if any elements are greater (比较两个向量以判定任一元素是否大于). Mnemonic:
rt := (left[0] > right[0]) || (left[1] > right[1]) || ... || (left[Count-1] > right[Count-1]).
- GreaterThanAny(Vector128<uint>, Vector128<uint>)
Compares two vectors to determine if any elements are greater (比较两个向量以判定任一元素是否大于). Mnemonic:
rt := (left[0] > right[0]) || (left[1] > right[1]) || ... || (left[Count-1] > right[Count-1]).
- GreaterThanAny(Vector128<ulong>, Vector128<ulong>)
Compares two vectors to determine if any elements are greater (比较两个向量以判定任一元素是否大于). Mnemonic:
rt := (left[0] > right[0]) || (left[1] > right[1]) || ... || (left[Count-1] > right[Count-1]).
- GreaterThanOrEqual(Vector128<byte>, Vector128<byte>)
Compares two vectors to determine which is greater or equal on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更大或等于). Mnemonic:
rt[i] := to_mask(left[i] >= right[i]).
- GreaterThanOrEqual(Vector128<double>, Vector128<double>)
Compares two vectors to determine which is greater or equal on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更大或等于). Mnemonic:
rt[i] := to_mask(left[i] >= right[i]).
- GreaterThanOrEqual(Vector128<short>, Vector128<short>)
Compares two vectors to determine which is greater or equal on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更大或等于). Mnemonic:
rt[i] := to_mask(left[i] >= right[i]).
- GreaterThanOrEqual(Vector128<int>, Vector128<int>)
Compares two vectors to determine which is greater or equal on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更大或等于). Mnemonic:
rt[i] := to_mask(left[i] >= right[i]).
- GreaterThanOrEqual(Vector128<long>, Vector128<long>)
Compares two vectors to determine which is greater or equal on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更大或等于). Mnemonic:
rt[i] := to_mask(left[i] >= right[i]).
- GreaterThanOrEqual(Vector128<sbyte>, Vector128<sbyte>)
Compares two vectors to determine which is greater or equal on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更大或等于). Mnemonic:
rt[i] := to_mask(left[i] >= right[i]).
- GreaterThanOrEqual(Vector128<float>, Vector128<float>)
Compares two vectors to determine which is greater or equal on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更大或等于). Mnemonic:
rt[i] := to_mask(left[i] >= right[i]).
- GreaterThanOrEqual(Vector128<ushort>, Vector128<ushort>)
Compares two vectors to determine which is greater or equal on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更大或等于). Mnemonic:
rt[i] := to_mask(left[i] >= right[i]).
- GreaterThanOrEqual(Vector128<uint>, Vector128<uint>)
Compares two vectors to determine which is greater or equal on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更大或等于). Mnemonic:
rt[i] := to_mask(left[i] >= right[i]).
- GreaterThanOrEqual(Vector128<ulong>, Vector128<ulong>)
Compares two vectors to determine which is greater or equal on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更大或等于). Mnemonic:
rt[i] := to_mask(left[i] >= right[i]).
- GreaterThanOrEqualAll(Vector128<byte>, Vector128<byte>)
Compares two vectors to determine if all elements are greater or equal (比较两个向量以判定所有元素是否大于或等于). Mnemonic:
rt := (left[0] >= right[0]) && (left[1] >= right[1]) && ... && (left[Count-1] >= right[Count-1]).
- GreaterThanOrEqualAll(Vector128<double>, Vector128<double>)
Compares two vectors to determine if all elements are greater or equal (比较两个向量以判定所有元素是否大于或等于). Mnemonic:
rt := (left[0] >= right[0]) && (left[1] >= right[1]) && ... && (left[Count-1] >= right[Count-1]).
- GreaterThanOrEqualAll(Vector128<short>, Vector128<short>)
Compares two vectors to determine if all elements are greater or equal (比较两个向量以判定所有元素是否大于或等于). Mnemonic:
rt := (left[0] >= right[0]) && (left[1] >= right[1]) && ... && (left[Count-1] >= right[Count-1]).
- GreaterThanOrEqualAll(Vector128<int>, Vector128<int>)
Compares two vectors to determine if all elements are greater or equal (比较两个向量以判定所有元素是否大于或等于). Mnemonic:
rt := (left[0] >= right[0]) && (left[1] >= right[1]) && ... && (left[Count-1] >= right[Count-1]).
- GreaterThanOrEqualAll(Vector128<long>, Vector128<long>)
Compares two vectors to determine if all elements are greater or equal (比较两个向量以判定所有元素是否大于或等于). Mnemonic:
rt := (left[0] >= right[0]) && (left[1] >= right[1]) && ... && (left[Count-1] >= right[Count-1]).
- GreaterThanOrEqualAll(Vector128<sbyte>, Vector128<sbyte>)
Compares two vectors to determine if all elements are greater or equal (比较两个向量以判定所有元素是否大于或等于). Mnemonic:
rt := (left[0] >= right[0]) && (left[1] >= right[1]) && ... && (left[Count-1] >= right[Count-1]).
- GreaterThanOrEqualAll(Vector128<float>, Vector128<float>)
Compares two vectors to determine if all elements are greater or equal (比较两个向量以判定所有元素是否大于或等于). Mnemonic:
rt := (left[0] >= right[0]) && (left[1] >= right[1]) && ... && (left[Count-1] >= right[Count-1]).
- GreaterThanOrEqualAll(Vector128<ushort>, Vector128<ushort>)
Compares two vectors to determine if all elements are greater or equal (比较两个向量以判定所有元素是否大于或等于). Mnemonic:
rt := (left[0] >= right[0]) && (left[1] >= right[1]) && ... && (left[Count-1] >= right[Count-1]).
- GreaterThanOrEqualAll(Vector128<uint>, Vector128<uint>)
Compares two vectors to determine if all elements are greater or equal (比较两个向量以判定所有元素是否大于或等于). Mnemonic:
rt := (left[0] >= right[0]) && (left[1] >= right[1]) && ... && (left[Count-1] >= right[Count-1]).
- GreaterThanOrEqualAll(Vector128<ulong>, Vector128<ulong>)
Compares two vectors to determine if all elements are greater or equal (比较两个向量以判定所有元素是否大于或等于). Mnemonic:
rt := (left[0] >= right[0]) && (left[1] >= right[1]) && ... && (left[Count-1] >= right[Count-1]).
- GreaterThanOrEqualAny(Vector128<byte>, Vector128<byte>)
Compares two vectors to determine if any elements are greater or equal (比较两个向量以判定任一元素是否大于或等于). Mnemonic:
rt := (left[0] >= right[0]) || (left[1] >= right[1]) || ... || (left[Count-1] >= right[Count-1]).
- GreaterThanOrEqualAny(Vector128<double>, Vector128<double>)
Compares two vectors to determine if any elements are greater or equal (比较两个向量以判定任一元素是否大于或等于). Mnemonic:
rt := (left[0] >= right[0]) || (left[1] >= right[1]) || ... || (left[Count-1] >= right[Count-1]).
- GreaterThanOrEqualAny(Vector128<short>, Vector128<short>)
Compares two vectors to determine if any elements are greater or equal (比较两个向量以判定任一元素是否大于或等于). Mnemonic:
rt := (left[0] >= right[0]) || (left[1] >= right[1]) || ... || (left[Count-1] >= right[Count-1]).
- GreaterThanOrEqualAny(Vector128<int>, Vector128<int>)
Compares two vectors to determine if any elements are greater or equal (比较两个向量以判定任一元素是否大于或等于). Mnemonic:
rt := (left[0] >= right[0]) || (left[1] >= right[1]) || ... || (left[Count-1] >= right[Count-1]).
- GreaterThanOrEqualAny(Vector128<long>, Vector128<long>)
Compares two vectors to determine if any elements are greater or equal (比较两个向量以判定任一元素是否大于或等于). Mnemonic:
rt := (left[0] >= right[0]) || (left[1] >= right[1]) || ... || (left[Count-1] >= right[Count-1]).
- GreaterThanOrEqualAny(Vector128<sbyte>, Vector128<sbyte>)
Compares two vectors to determine if any elements are greater or equal (比较两个向量以判定任一元素是否大于或等于). Mnemonic:
rt := (left[0] >= right[0]) || (left[1] >= right[1]) || ... || (left[Count-1] >= right[Count-1]).
- GreaterThanOrEqualAny(Vector128<float>, Vector128<float>)
Compares two vectors to determine if any elements are greater or equal (比较两个向量以判定任一元素是否大于或等于). Mnemonic:
rt := (left[0] >= right[0]) || (left[1] >= right[1]) || ... || (left[Count-1] >= right[Count-1]).
- GreaterThanOrEqualAny(Vector128<ushort>, Vector128<ushort>)
Compares two vectors to determine if any elements are greater or equal (比较两个向量以判定任一元素是否大于或等于). Mnemonic:
rt := (left[0] >= right[0]) || (left[1] >= right[1]) || ... || (left[Count-1] >= right[Count-1]).
- GreaterThanOrEqualAny(Vector128<uint>, Vector128<uint>)
Compares two vectors to determine if any elements are greater or equal (比较两个向量以判定任一元素是否大于或等于). Mnemonic:
rt := (left[0] >= right[0]) || (left[1] >= right[1]) || ... || (left[Count-1] >= right[Count-1]).
- GreaterThanOrEqualAny(Vector128<ulong>, Vector128<ulong>)
Compares two vectors to determine if any elements are greater or equal (比较两个向量以判定任一元素是否大于或等于). Mnemonic:
rt := (left[0] >= right[0]) || (left[1] >= right[1]) || ... || (left[Count-1] >= right[Count-1]).
- GreaterThan_Unsigned(Vector128<byte>, Vector128<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(Vector128<short>, Vector128<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(Vector128<int>, Vector128<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(Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<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(Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<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 (判断是否原生支持这种元素类型).
- LessThan(Vector128<byte>, Vector128<byte>)
Compares two vectors to determine which is less on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更小). Mnemonic:
rt[i] := to_mask(left[i] < right[i]).
- LessThan(Vector128<double>, Vector128<double>)
Compares two vectors to determine which is less on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更小). Mnemonic:
rt[i] := to_mask(left[i] < right[i]).
- LessThan(Vector128<short>, Vector128<short>)
Compares two vectors to determine which is less on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更小). Mnemonic:
rt[i] := to_mask(left[i] < right[i]).
- LessThan(Vector128<int>, Vector128<int>)
Compares two vectors to determine which is less on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更小). Mnemonic:
rt[i] := to_mask(left[i] < right[i]).
- LessThan(Vector128<long>, Vector128<long>)
Compares two vectors to determine which is less on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更小). Mnemonic:
rt[i] := to_mask(left[i] < right[i]).
- LessThan(Vector128<sbyte>, Vector128<sbyte>)
Compares two vectors to determine which is less on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更小). Mnemonic:
rt[i] := to_mask(left[i] < right[i]).
- LessThan(Vector128<float>, Vector128<float>)
Compares two vectors to determine which is less on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更小). Mnemonic:
rt[i] := to_mask(left[i] < right[i]).
- LessThan(Vector128<ushort>, Vector128<ushort>)
Compares two vectors to determine which is less on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更小). Mnemonic:
rt[i] := to_mask(left[i] < right[i]).
- LessThan(Vector128<uint>, Vector128<uint>)
Compares two vectors to determine which is less on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更小). Mnemonic:
rt[i] := to_mask(left[i] < right[i]).
- LessThan(Vector128<ulong>, Vector128<ulong>)
Compares two vectors to determine which is less on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更小). Mnemonic:
rt[i] := to_mask(left[i] < right[i]).
- LessThanAll(Vector128<byte>, Vector128<byte>)
Compares two vectors to determine if all elements are less (比较两个向量以判定所有元素是否小于). Mnemonic:
rt := (left[0] < right[0]) && (left[1] < right[1]) && ... && (left[Count-1] < right[Count-1]).
- LessThanAll(Vector128<double>, Vector128<double>)
Compares two vectors to determine if all elements are less (比较两个向量以判定所有元素是否小于). Mnemonic:
rt := (left[0] < right[0]) && (left[1] < right[1]) && ... && (left[Count-1] < right[Count-1]).
- LessThanAll(Vector128<short>, Vector128<short>)
Compares two vectors to determine if all elements are less (比较两个向量以判定所有元素是否小于). Mnemonic:
rt := (left[0] < right[0]) && (left[1] < right[1]) && ... && (left[Count-1] < right[Count-1]).
- LessThanAll(Vector128<int>, Vector128<int>)
Compares two vectors to determine if all elements are less (比较两个向量以判定所有元素是否小于). Mnemonic:
rt := (left[0] < right[0]) && (left[1] < right[1]) && ... && (left[Count-1] < right[Count-1]).
- LessThanAll(Vector128<long>, Vector128<long>)
Compares two vectors to determine if all elements are less (比较两个向量以判定所有元素是否小于). Mnemonic:
rt := (left[0] < right[0]) && (left[1] < right[1]) && ... && (left[Count-1] < right[Count-1]).
- LessThanAll(Vector128<sbyte>, Vector128<sbyte>)
Compares two vectors to determine if all elements are less (比较两个向量以判定所有元素是否小于). Mnemonic:
rt := (left[0] < right[0]) && (left[1] < right[1]) && ... && (left[Count-1] < right[Count-1]).
- LessThanAll(Vector128<float>, Vector128<float>)
Compares two vectors to determine if all elements are less (比较两个向量以判定所有元素是否小于). Mnemonic:
rt := (left[0] < right[0]) && (left[1] < right[1]) && ... && (left[Count-1] < right[Count-1]).
- LessThanAll(Vector128<ushort>, Vector128<ushort>)
Compares two vectors to determine if all elements are less (比较两个向量以判定所有元素是否小于). Mnemonic:
rt := (left[0] < right[0]) && (left[1] < right[1]) && ... && (left[Count-1] < right[Count-1]).
- LessThanAll(Vector128<uint>, Vector128<uint>)
Compares two vectors to determine if all elements are less (比较两个向量以判定所有元素是否小于). Mnemonic:
rt := (left[0] < right[0]) && (left[1] < right[1]) && ... && (left[Count-1] < right[Count-1]).
- LessThanAll(Vector128<ulong>, Vector128<ulong>)
Compares two vectors to determine if all elements are less (比较两个向量以判定所有元素是否小于). Mnemonic:
rt := (left[0] < right[0]) && (left[1] < right[1]) && ... && (left[Count-1] < right[Count-1]).
- LessThanAny(Vector128<byte>, Vector128<byte>)
Compares two vectors to determine if any elements are less (比较两个向量以判定任一元素是否小于). Mnemonic:
rt := (left[0] < right[0]) || (left[1] < right[1]) || ... || (left[Count-1] < right[Count-1]).
- LessThanAny(Vector128<double>, Vector128<double>)
Compares two vectors to determine if any elements are less (比较两个向量以判定任一元素是否小于). Mnemonic:
rt := (left[0] < right[0]) || (left[1] < right[1]) || ... || (left[Count-1] < right[Count-1]).
- LessThanAny(Vector128<short>, Vector128<short>)
Compares two vectors to determine if any elements are less (比较两个向量以判定任一元素是否小于). Mnemonic:
rt := (left[0] < right[0]) || (left[1] < right[1]) || ... || (left[Count-1] < right[Count-1]).
- LessThanAny(Vector128<int>, Vector128<int>)
Compares two vectors to determine if any elements are less (比较两个向量以判定任一元素是否小于). Mnemonic:
rt := (left[0] < right[0]) || (left[1] < right[1]) || ... || (left[Count-1] < right[Count-1]).
- LessThanAny(Vector128<long>, Vector128<long>)
Compares two vectors to determine if any elements are less (比较两个向量以判定任一元素是否小于). Mnemonic:
rt := (left[0] < right[0]) || (left[1] < right[1]) || ... || (left[Count-1] < right[Count-1]).
- LessThanAny(Vector128<sbyte>, Vector128<sbyte>)
Compares two vectors to determine if any elements are less (比较两个向量以判定任一元素是否小于). Mnemonic:
rt := (left[0] < right[0]) || (left[1] < right[1]) || ... || (left[Count-1] < right[Count-1]).
- LessThanAny(Vector128<float>, Vector128<float>)
Compares two vectors to determine if any elements are less (比较两个向量以判定任一元素是否小于). Mnemonic:
rt := (left[0] < right[0]) || (left[1] < right[1]) || ... || (left[Count-1] < right[Count-1]).
- LessThanAny(Vector128<ushort>, Vector128<ushort>)
Compares two vectors to determine if any elements are less (比较两个向量以判定任一元素是否小于). Mnemonic:
rt := (left[0] < right[0]) || (left[1] < right[1]) || ... || (left[Count-1] < right[Count-1]).
- LessThanAny(Vector128<uint>, Vector128<uint>)
Compares two vectors to determine if any elements are less (比较两个向量以判定任一元素是否小于). Mnemonic:
rt := (left[0] < right[0]) || (left[1] < right[1]) || ... || (left[Count-1] < right[Count-1]).
- LessThanAny(Vector128<ulong>, Vector128<ulong>)
Compares two vectors to determine if any elements are less (比较两个向量以判定任一元素是否小于). Mnemonic:
rt := (left[0] < right[0]) || (left[1] < right[1]) || ... || (left[Count-1] < right[Count-1]).
- LessThanOrEqual(Vector128<byte>, Vector128<byte>)
Compares two vectors to determine which is less or equal on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更小或等于). Mnemonic:
rt[i] := to_mask(left[i] <= right[i]).
- LessThanOrEqual(Vector128<double>, Vector128<double>)
Compares two vectors to determine which is less or equal on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更小或等于). Mnemonic:
rt[i] := to_mask(left[i] <= right[i]).
- LessThanOrEqual(Vector128<short>, Vector128<short>)
Compares two vectors to determine which is less or equal on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更小或等于). Mnemonic:
rt[i] := to_mask(left[i] <= right[i]).
- LessThanOrEqual(Vector128<int>, Vector128<int>)
Compares two vectors to determine which is less or equal on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更小或等于). Mnemonic:
rt[i] := to_mask(left[i] <= right[i]).
- LessThanOrEqual(Vector128<long>, Vector128<long>)
Compares two vectors to determine which is less or equal on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更小或等于). Mnemonic:
rt[i] := to_mask(left[i] <= right[i]).
- LessThanOrEqual(Vector128<sbyte>, Vector128<sbyte>)
Compares two vectors to determine which is less or equal on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更小或等于). Mnemonic:
rt[i] := to_mask(left[i] <= right[i]).
- LessThanOrEqual(Vector128<float>, Vector128<float>)
Compares two vectors to determine which is less or equal on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更小或等于). Mnemonic:
rt[i] := to_mask(left[i] <= right[i]).
- LessThanOrEqual(Vector128<ushort>, Vector128<ushort>)
Compares two vectors to determine which is less or equal on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更小或等于). Mnemonic:
rt[i] := to_mask(left[i] <= right[i]).
- LessThanOrEqual(Vector128<uint>, Vector128<uint>)
Compares two vectors to determine which is less or equal on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更小或等于). Mnemonic:
rt[i] := to_mask(left[i] <= right[i]).
- LessThanOrEqual(Vector128<ulong>, Vector128<ulong>)
Compares two vectors to determine which is less or equal on a per-element basis (比较两个向量，在每个元素的基础上确定哪个更小或等于). Mnemonic:
rt[i] := to_mask(left[i] <= right[i]).
- LessThanOrEqualAll(Vector128<byte>, Vector128<byte>)
Compares two vectors to determine if all elements are less or equal (比较两个向量以判定所有元素是否小于或等于). Mnemonic:
rt := (left[0] <= right[0]) && (left[1] <= right[1]) && ... && (left[Count-1] <= right[Count-1]).
- LessThanOrEqualAll(Vector128<double>, Vector128<double>)
Compares two vectors to determine if all elements are less or equal (比较两个向量以判定所有元素是否小于或等于). Mnemonic:
rt := (left[0] <= right[0]) && (left[1] <= right[1]) && ... && (left[Count-1] <= right[Count-1]).
- LessThanOrEqualAll(Vector128<short>, Vector128<short>)
Compares two vectors to determine if all elements are less or equal (比较两个向量以判定所有元素是否小于或等于). Mnemonic:
rt := (left[0] <= right[0]) && (left[1] <= right[1]) && ... && (left[Count-1] <= right[Count-1]).
- LessThanOrEqualAll(Vector128<int>, Vector128<int>)
Compares two vectors to determine if all elements are less or equal (比较两个向量以判定所有元素是否小于或等于). Mnemonic:
rt := (left[0] <= right[0]) && (left[1] <= right[1]) && ... && (left[Count-1] <= right[Count-1]).
- LessThanOrEqualAll(Vector128<long>, Vector128<long>)
Compares two vectors to determine if all elements are less or equal (比较两个向量以判定所有元素是否小于或等于). Mnemonic:
rt := (left[0] <= right[0]) && (left[1] <= right[1]) && ... && (left[Count-1] <= right[Count-1]).
- LessThanOrEqualAll(Vector128<sbyte>, Vector128<sbyte>)
Compares two vectors to determine if all elements are less or equal (比较两个向量以判定所有元素是否小于或等于). Mnemonic:
rt := (left[0] <= right[0]) && (left[1] <= right[1]) && ... && (left[Count-1] <= right[Count-1]).
- LessThanOrEqualAll(Vector128<float>, Vector128<float>)
Compares two vectors to determine if all elements are less or equal (比较两个向量以判定所有元素是否小于或等于). Mnemonic:
rt := (left[0] <= right[0]) && (left[1] <= right[1]) && ... && (left[Count-1] <= right[Count-1]).
- LessThanOrEqualAll(Vector128<ushort>, Vector128<ushort>)
Compares two vectors to determine if all elements are less or equal (比较两个向量以判定所有元素是否小于或等于). Mnemonic:
rt := (left[0] <= right[0]) && (left[1] <= right[1]) && ... && (left[Count-1] <= right[Count-1]).
- LessThanOrEqualAll(Vector128<uint>, Vector128<uint>)
Compares two vectors to determine if all elements are less or equal (比较两个向量以判定所有元素是否小于或等于). Mnemonic:
rt := (left[0] <= right[0]) && (left[1] <= right[1]) && ... && (left[Count-1] <= right[Count-1]).
- LessThanOrEqualAll(Vector128<ulong>, Vector128<ulong>)
Compares two vectors to determine if all elements are less or equal (比较两个向量以判定所有元素是否小于或等于). Mnemonic:
rt := (left[0] <= right[0]) && (left[1] <= right[1]) && ... && (left[Count-1] <= right[Count-1]).
- LessThanOrEqualAny(Vector128<byte>, Vector128<byte>)
Compares two vectors to determine if any elements are less or equal (比较两个向量以判定任一元素是否小于或等于). Mnemonic:
rt := (left[0] <= right[0]) || (left[1] <= right[1]) || ... || (left[Count-1] <= right[Count-1]).
- LessThanOrEqualAny(Vector128<double>, Vector128<double>)
Compares two vectors to determine if any elements are less or equal (比较两个向量以判定任一元素是否小于或等于). Mnemonic:
rt := (left[0] <= right[0]) || (left[1] <= right[1]) || ... || (left[Count-1] <= right[Count-1]).
- LessThanOrEqualAny(Vector128<short>, Vector128<short>)
Compares two vectors to determine if any elements are less or equal (比较两个向量以判定任一元素是否小于或等于). Mnemonic:
rt := (left[0] <= right[0]) || (left[1] <= right[1]) || ... || (left[Count-1] <= right[Count-1]).
- LessThanOrEqualAny(Vector128<int>, Vector128<int>)
Compares two vectors to determine if any elements are less or equal (比较两个向量以判定任一元素是否小于或等于). Mnemonic:
rt := (left[0] <= right[0]) || (left[1] <= right[1]) || ... || (left[Count-1] <= right[Count-1]).
- LessThanOrEqualAny(Vector128<long>, Vector128<long>)
Compares two vectors to determine if any elements are less or equal (比较两个向量以判定任一元素是否小于或等于). Mnemonic:
rt := (left[0] <= right[0]) || (left[1] <= right[1]) || ... || (left[Count-1] <= right[Count-1]).
- LessThanOrEqualAny(Vector128<sbyte>, Vector128<sbyte>)
Compares two vectors to determine if any elements are less or equal (比较两个向量以判定任一元素是否小于或等于). Mnemonic:
rt := (left[0] <= right[0]) || (left[1] <= right[1]) || ... || (left[Count-1] <= right[Count-1]).
- LessThanOrEqualAny(Vector128<float>, Vector128<float>)
Compares two vectors to determine if any elements are less or equal (比较两个向量以判定任一元素是否小于或等于). Mnemonic:
rt := (left[0] <= right[0]) || (left[1] <= right[1]) || ... || (left[Count-1] <= right[Count-1]).
- LessThanOrEqualAny(Vector128<ushort>, Vector128<ushort>)
Compares two vectors to determine if any elements are less or equal (比较两个向量以判定任一元素是否小于或等于). Mnemonic:
rt := (left[0] <= right[0]) || (left[1] <= right[1]) || ... || (left[Count-1] <= right[Count-1]).
- LessThanOrEqualAny(Vector128<uint>, Vector128<uint>)
Compares two vectors to determine if any elements are less or equal (比较两个向量以判定任一元素是否小于或等于). Mnemonic:
rt := (left[0] <= right[0]) || (left[1] <= right[1]) || ... || (left[Count-1] <= right[Count-1]).
- LessThanOrEqualAny(Vector128<ulong>, Vector128<ulong>)
Compares two vectors to determine if any elements are less or equal (比较两个向量以判定任一元素是否小于或等于). Mnemonic:
rt := (left[0] <= right[0]) || (left[1] <= right[1]) || ... || (left[Count-1] <= right[Count-1]).
- Max(Vector128<byte>, Vector128<byte>)
Computes the maximum of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最大值). Mnemonic:
rt[i] := max(left[i], right[i]).
- Max(Vector128<double>, Vector128<double>)
Computes the maximum of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最大值). Mnemonic:
rt[i] := max(left[i], right[i]).
- Max(Vector128<short>, Vector128<short>)
Computes the maximum of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最大值). Mnemonic:
rt[i] := max(left[i], right[i]).
- Max(Vector128<int>, Vector128<int>)
Computes the maximum of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最大值). Mnemonic:
rt[i] := max(left[i], right[i]).
- Max(Vector128<long>, Vector128<long>)
Computes the maximum of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最大值). Mnemonic:
rt[i] := max(left[i], right[i]).
- Max(Vector128<sbyte>, Vector128<sbyte>)
Computes the maximum of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最大值). Mnemonic:
rt[i] := max(left[i], right[i]).
- Max(Vector128<float>, Vector128<float>)
Computes the maximum of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最大值). Mnemonic:
rt[i] := max(left[i], right[i]).
- Max(Vector128<ushort>, Vector128<ushort>)
Computes the maximum of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最大值). Mnemonic:
rt[i] := max(left[i], right[i]).
- Max(Vector128<uint>, Vector128<uint>)
Computes the maximum of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最大值). Mnemonic:
rt[i] := max(left[i], right[i]).
- Max(Vector128<ulong>, Vector128<ulong>)
Computes the maximum of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最大值). Mnemonic:
rt[i] := max(left[i], right[i]).
- Min(Vector128<byte>, Vector128<byte>)
Computes the minimum of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最小值). Mnemonic:
rt[i] := min(left[i], right[i]).
- Min(Vector128<double>, Vector128<double>)
Computes the minimum of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最小值). Mnemonic:
rt[i] := min(left[i], right[i]).
- Min(Vector128<short>, Vector128<short>)
Computes the minimum of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最小值). Mnemonic:
rt[i] := min(left[i], right[i]).
- Min(Vector128<int>, Vector128<int>)
Computes the minimum of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最小值). Mnemonic:
rt[i] := min(left[i], right[i]).
- Min(Vector128<long>, Vector128<long>)
Computes the minimum of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最小值). Mnemonic:
rt[i] := min(left[i], right[i]).
- Min(Vector128<sbyte>, Vector128<sbyte>)
Computes the minimum of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最小值). Mnemonic:
rt[i] := min(left[i], right[i]).
- Min(Vector128<float>, Vector128<float>)
Computes the minimum of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最小值). Mnemonic:
rt[i] := min(left[i], right[i]).
- Min(Vector128<ushort>, Vector128<ushort>)
Computes the minimum of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最小值). Mnemonic:
rt[i] := min(left[i], right[i]).
- Min(Vector128<uint>, Vector128<uint>)
Computes the minimum of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最小值). Mnemonic:
rt[i] := min(left[i], right[i]).
- Min(Vector128<ulong>, Vector128<ulong>)
Computes the minimum of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最小值). Mnemonic:
rt[i] := min(left[i], right[i]).
- Multiply(Vector128<byte>, Vector128<byte>)
Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic:
rt[i] := left[i] * right[i].
- Multiply(Vector128<double>, Vector128<double>)
Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic:
rt[i] := left[i] * right[i].
- Multiply(Vector128<short>, Vector128<short>)
Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic:
rt[i] := left[i] * right[i].
- Multiply(Vector128<int>, Vector128<int>)
Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic:
rt[i] := left[i] * right[i].
- Multiply(Vector128<long>, Vector128<long>)
Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic:
rt[i] := left[i] * right[i].
- Multiply(Vector128<sbyte>, Vector128<sbyte>)
Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic:
rt[i] := left[i] * right[i].
- Multiply(Vector128<float>, Vector128<float>)
Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic:
rt[i] := left[i] * right[i].
- Multiply(Vector128<ushort>, Vector128<ushort>)
Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic:
rt[i] := left[i] * right[i].
- Multiply(Vector128<uint>, Vector128<uint>)
Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic:
rt[i] := left[i] * right[i].
- Multiply(Vector128<ulong>, Vector128<ulong>)
Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic:
rt[i] := left[i] * right[i].
- Narrow(Vector128<double>, Vector128<double>)
Narrows two Vector128<T> instances into one Vector128<T>" (将两个 Vector128<T> 实例缩窄为一个 Vector128<T> ). />. Mnemonic:
rt[i] := narrow(element_ref(i, lower, upper)).
- Narrow(Vector128<short>, Vector128<short>)
Narrows two Vector128<T> instances into one Vector128<T>" (将两个 Vector128<T> 实例缩窄为一个 Vector128<T> ). />. Mnemonic:
rt[i] := narrow(element_ref(i, lower, upper)).
- Narrow(Vector128<int>, Vector128<int>)
Narrows two Vector128<T> instances into one Vector128<T>" (将两个 Vector128<T> 实例缩窄为一个 Vector128<T> ). />. Mnemonic:
rt[i] := narrow(element_ref(i, lower, upper)).
- Narrow(Vector128<long>, Vector128<long>)
Narrows two Vector128<T> instances into one Vector128<T>" (将两个 Vector128<T> 实例缩窄为一个 Vector128<T> ). />. Mnemonic:
rt[i] := narrow(element_ref(i, lower, upper)).
- Narrow(Vector128<ushort>, Vector128<ushort>)
Narrows two Vector128<T> instances into one Vector128<T>" (将两个 Vector128<T> 实例缩窄为一个 Vector128<T> ). />. Mnemonic:
rt[i] := narrow(element_ref(i, lower, upper)).
- Narrow(Vector128<uint>, Vector128<uint>)
Narrows two Vector128<T> instances into one Vector128<T>" (将两个 Vector128<T> 实例缩窄为一个 Vector128<T> ). />. Mnemonic:
rt[i] := narrow(element_ref(i, lower, upper)).
- Narrow(Vector128<ulong>, Vector128<ulong>)
Narrows two Vector128<T> instances into one Vector128<T>" (将两个 Vector128<T> 实例缩窄为一个 Vector128<T> ). />. Mnemonic:
rt[i] := narrow(element_ref(i, lower, upper)).
- Negate(Vector128<double>)
Computes the negate of a vector (计算向量的相反数). Mnemonic:
rt[i] := -vector[i].
- Negate(Vector128<short>)
Computes the negate of a vector (计算向量的相反数). Mnemonic:
rt[i] := -vector[i].
- Negate(Vector128<int>)
Computes the negate of a vector (计算向量的相反数). Mnemonic:
rt[i] := -vector[i].
- Negate(Vector128<long>)
Computes the negate of a vector (计算向量的相反数). Mnemonic:
rt[i] := -vector[i].
- Negate(Vector128<sbyte>)
Computes the negate of a vector (计算向量的相反数). Mnemonic:
rt[i] := -vector[i].
- Negate(Vector128<float>)
Computes the negate of a vector (计算向量的相反数). Mnemonic:
rt[i] := -vector[i].
- OnesComplement<T>(Vector128<T>)
Computes the ones-complement of a vector (计算向量的反码). Mnemonic:
rt[i] := ~vector[i].
- ShiftLeft(Vector128<byte>, int)
Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft(Vector128<short>, int)
Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft(Vector128<int>, int)
Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft(Vector128<long>, int)
Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft(Vector128<sbyte>, int)
Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft(Vector128<ushort>, int)
Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft(Vector128<uint>, int)
Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft(Vector128<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(Vector128<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(Vector128<byte>, int, out Vector128<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(Vector128<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(Vector128<short>, int, out Vector128<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(Vector128<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(Vector128<int>, int, out Vector128<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(Vector128<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(Vector128<long>, int, out Vector128<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(Vector128<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(Vector128<sbyte>, int, out Vector128<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(Vector128<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(Vector128<ushort>, int, out Vector128<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(Vector128<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(Vector128<uint>, int, out Vector128<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(Vector128<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(Vector128<ulong>, int, out Vector128<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>(Vector128<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(Vector128<byte>, int)
Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_Const(Vector128<short>, int)
Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_Const(Vector128<int>, int)
Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_Const(Vector128<long>, int)
Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_Const(Vector128<sbyte>, int)
Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_Const(Vector128<ushort>, int)
Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_Const(Vector128<uint>, int)
Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_Const(Vector128<ulong>, int)
Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_ConstCore(Vector128<byte>, int, Vector128<byte>, Vector128<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(Vector128<short>, int, Vector128<short>, Vector128<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(Vector128<int>, int, Vector128<int>, Vector128<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(Vector128<long>, int, Vector128<long>, Vector128<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(Vector128<sbyte>, int, Vector128<sbyte>, Vector128<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(Vector128<ushort>, int, Vector128<ushort>, Vector128<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(Vector128<uint>, int, Vector128<uint>, Vector128<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(Vector128<ulong>, int, Vector128<ulong>, Vector128<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(Vector128<byte>, int, Vector128<byte>, Vector128<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(Vector128<short>, int, Vector128<short>, Vector128<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(Vector128<int>, int, Vector128<int>, Vector128<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(Vector128<long>, int, Vector128<long>, Vector128<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(Vector128<sbyte>, int, Vector128<sbyte>, Vector128<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(Vector128<ushort>, int, Vector128<ushort>, Vector128<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(Vector128<uint>, int, Vector128<uint>, Vector128<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(Vector128<ulong>, int, Vector128<ulong>, Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<short>, int, out Vector128<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(Vector128<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(Vector128<int>, int, out Vector128<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(Vector128<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(Vector128<long>, int, out Vector128<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(Vector128<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(Vector128<sbyte>, int, out Vector128<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>(Vector128<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(Vector128<short>, int)
Shifts (signed) each element of a vector right by the specified amount - Const(将向量的每个有符号元素算术右移指定量 - 常量). Mnemonic:
rt[i] := value[i] >> shiftAmount.
- ShiftRightArithmetic_Const(Vector128<int>, int)
Shifts (signed) each element of a vector right by the specified amount - Const(将向量的每个有符号元素算术右移指定量 - 常量). Mnemonic:
rt[i] := value[i] >> shiftAmount.
- ShiftRightArithmetic_Const(Vector128<long>, int)
Shifts (signed) each element of a vector right by the specified amount - Const(将向量的每个有符号元素算术右移指定量 - 常量). Mnemonic:
rt[i] := value[i] >> shiftAmount.
- ShiftRightArithmetic_Const(Vector128<sbyte>, int)
Shifts (signed) each element of a vector right by the specified amount - Const(将向量的每个有符号元素算术右移指定量 - 常量). Mnemonic:
rt[i] := value[i] >> shiftAmount.
- ShiftRightArithmetic_ConstCore(Vector128<short>, int, Vector128<short>, Vector128<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(Vector128<int>, int, Vector128<int>, Vector128<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(Vector128<long>, int, Vector128<long>, Vector128<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(Vector128<sbyte>, int, Vector128<sbyte>, Vector128<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(Vector128<short>, int, Vector128<short>, Vector128<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(Vector128<int>, int, Vector128<int>, Vector128<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(Vector128<long>, int, Vector128<long>, Vector128<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(Vector128<sbyte>, int, Vector128<sbyte>, Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<byte>, int, out Vector128<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(Vector128<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(Vector128<short>, int, out Vector128<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(Vector128<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(Vector128<int>, int, out Vector128<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(Vector128<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(Vector128<long>, int, out Vector128<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(Vector128<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(Vector128<sbyte>, int, out Vector128<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(Vector128<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(Vector128<ushort>, int, out Vector128<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(Vector128<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(Vector128<uint>, int, out Vector128<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(Vector128<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(Vector128<ulong>, int, out Vector128<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>(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<byte>, int, Vector128<byte>, Vector128<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(Vector128<short>, int, Vector128<short>, Vector128<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(Vector128<int>, int, Vector128<int>, Vector128<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(Vector128<long>, int, Vector128<long>, Vector128<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(Vector128<sbyte>, int, Vector128<sbyte>, Vector128<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(Vector128<ushort>, int, Vector128<ushort>, Vector128<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(Vector128<uint>, int, Vector128<uint>, Vector128<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(Vector128<ulong>, int, Vector128<ulong>, Vector128<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(Vector128<byte>, int, Vector128<byte>, Vector128<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(Vector128<short>, int, Vector128<short>, Vector128<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(Vector128<int>, int, Vector128<int>, Vector128<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(Vector128<long>, int, Vector128<long>, Vector128<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(Vector128<sbyte>, int, Vector128<sbyte>, Vector128<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(Vector128<ushort>, int, Vector128<ushort>, Vector128<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(Vector128<uint>, int, Vector128<uint>, Vector128<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(Vector128<ulong>, int, Vector128<ulong>, Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<byte>, Vector128<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(Vector128<double>, Vector128<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(Vector128<short>, Vector128<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(Vector128<int>, Vector128<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(Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<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(Vector128<float>, Vector128<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(Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<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(Vector128<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(Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<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(Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<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(Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<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(Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<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(Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<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(Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<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(Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<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(Vector128<ulong>, out Vector128<ulong>, out Vector128<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>(Vector128<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>(Vector128<TIdx>, out Vector128<TIdx>, out Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<byte>, (Vector128<byte> args0, Vector128<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(Vector128<double>, Vector128<long>, Vector128<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(Vector128<double>, (Vector128<long> args0, Vector128<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(Vector128<short>, Vector128<short>, Vector128<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(Vector128<short>, (Vector128<short> args0, Vector128<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(Vector128<int>, Vector128<int>, Vector128<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(Vector128<int>, (Vector128<int> args0, Vector128<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(Vector128<long>, Vector128<long>, Vector128<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(Vector128<long>, (Vector128<long> args0, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<sbyte>, (Vector128<sbyte> args0, Vector128<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(Vector128<float>, Vector128<int>, Vector128<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(Vector128<float>, (Vector128<int> args0, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<ushort>, (Vector128<ushort> args0, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<uint>, (Vector128<uint> args0, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<ulong>, (Vector128<ulong> args0, Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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.
- Subtract(Vector128<byte>, Vector128<byte>)
Subtracts two vectors to compute their difference (将两个向量相减来计算它们的差). Mnemonic:
rt[i] := left[i] - right[i].
- Subtract(Vector128<double>, Vector128<double>)
Subtracts two vectors to compute their difference (将两个向量相减来计算它们的差). Mnemonic:
rt[i] := left[i] - right[i].
- Subtract(Vector128<short>, Vector128<short>)
Subtracts two vectors to compute their difference (将两个向量相减来计算它们的差). Mnemonic:
rt[i] := left[i] - right[i].
- Subtract(Vector128<int>, Vector128<int>)
Subtracts two vectors to compute their difference (将两个向量相减来计算它们的差). Mnemonic:
rt[i] := left[i] - right[i].
- Subtract(Vector128<long>, Vector128<long>)
Subtracts two vectors to compute their difference (将两个向量相减来计算它们的差). Mnemonic:
rt[i] := left[i] - right[i].
- Subtract(Vector128<sbyte>, Vector128<sbyte>)
Subtracts two vectors to compute their difference (将两个向量相减来计算它们的差). Mnemonic:
rt[i] := left[i] - right[i].
- Subtract(Vector128<float>, Vector128<float>)
Subtracts two vectors to compute their difference (将两个向量相减来计算它们的差). Mnemonic:
rt[i] := left[i] - right[i].
- Subtract(Vector128<ushort>, Vector128<ushort>)
Subtracts two vectors to compute their difference (将两个向量相减来计算它们的差). Mnemonic:
rt[i] := left[i] - right[i].
- Subtract(Vector128<uint>, Vector128<uint>)
Subtracts two vectors to compute their difference (将两个向量相减来计算它们的差). Mnemonic:
rt[i] := left[i] - right[i].
- Subtract(Vector128<ulong>, Vector128<ulong>)
Subtracts two vectors to compute their difference (将两个向量相减来计算它们的差). Mnemonic:
rt[i] := left[i] - right[i].
- Sum(Vector128<byte>)
Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic:
rt := value[0] + value[1] + value[2] + ... + value[Count-1].
- Sum(Vector128<double>)
Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic:
rt := value[0] + value[1] + value[2] + ... + value[Count-1].
- Sum(Vector128<short>)
Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic:
rt := value[0] + value[1] + value[2] + ... + value[Count-1].
- Sum(Vector128<int>)
Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic:
rt := value[0] + value[1] + value[2] + ... + value[Count-1].
- Sum(Vector128<long>)
Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic:
rt := value[0] + value[1] + value[2] + ... + value[Count-1].
- Sum(Vector128<sbyte>)
Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic:
rt := value[0] + value[1] + value[2] + ... + value[Count-1].
- Sum(Vector128<float>)
Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic:
rt := value[0] + value[1] + value[2] + ... + value[Count-1].
- Sum(Vector128<ushort>)
Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic:
rt := value[0] + value[1] + value[2] + ... + value[Count-1].
- Sum(Vector128<uint>)
Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic:
rt := value[0] + value[1] + value[2] + ... + value[Count-1].
- Sum(Vector128<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(Vector128<byte>)
Widens a Vector128<T> into two Vector128<T> instances - Generic version (将一个 Vector128<T> 扩宽为两个 Vector128<T> 实例 - 泛型版). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(Vector128<byte>, out Vector128<ushort>, out Vector128<ushort>)
Widens a Vector128<T> into two Vector128<T> instances (将一个 Vector128<T> 扩宽为两个 Vector128<T> 实例). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(Vector128<short>)
Widens a Vector128<T> into two Vector128<T> instances - Generic version (将一个 Vector128<T> 扩宽为两个 Vector128<T> 实例 - 泛型版). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(Vector128<short>, out Vector128<int>, out Vector128<int>)
Widens a Vector128<T> into two Vector128<T> instances (将一个 Vector128<T> 扩宽为两个 Vector128<T> 实例). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(Vector128<int>)
Widens a Vector128<T> into two Vector128<T> instances - Generic version (将一个 Vector128<T> 扩宽为两个 Vector128<T> 实例 - 泛型版). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(Vector128<int>, out Vector128<long>, out Vector128<long>)
Widens a Vector128<T> into two Vector128<T> instances (将一个 Vector128<T> 扩宽为两个 Vector128<T> 实例). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(Vector128<sbyte>)
Widens a Vector128<T> into two Vector128<T> instances - Generic version (将一个 Vector128<T> 扩宽为两个 Vector128<T> 实例 - 泛型版). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(Vector128<sbyte>, out Vector128<short>, out Vector128<short>)
Widens a Vector128<T> into two Vector128<T> instances (将一个 Vector128<T> 扩宽为两个 Vector128<T> 实例). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(Vector128<float>)
Widens a Vector128<T> into two Vector128<T> instances - Generic version (将一个 Vector128<T> 扩宽为两个 Vector128<T> 实例 - 泛型版). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(Vector128<float>, out Vector128<double>, out Vector128<double>)
Widens a Vector128<T> into two Vector128<T> instances (将一个 Vector128<T> 扩宽为两个 Vector128<T> 实例). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(Vector128<ushort>)
Widens a Vector128<T> into two Vector128<T> instances - Generic version (将一个 Vector128<T> 扩宽为两个 Vector128<T> 实例 - 泛型版). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(Vector128<ushort>, out Vector128<uint>, out Vector128<uint>)
Widens a Vector128<T> into two Vector128<T> instances (将一个 Vector128<T> 扩宽为两个 Vector128<T> 实例). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(Vector128<uint>)
Widens a Vector128<T> into two Vector128<T> instances - Generic version (将一个 Vector128<T> 扩宽为两个 Vector128<T> 实例 - 泛型版). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(Vector128<uint>, out Vector128<ulong>, out Vector128<ulong>)
Widens a Vector128<T> into two Vector128<T> instances (将一个 Vector128<T> 扩宽为两个 Vector128<T> 实例). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- WidenLower(Vector128<byte>)
Widens the lower half of a Vector into a Vector (将向量的低半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenLower(Vector128<short>)
Widens the lower half of a Vector into a Vector (将向量的低半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenLower(Vector128<int>)
Widens the lower half of a Vector into a Vector (将向量的低半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenLower(Vector128<sbyte>)
Widens the lower half of a Vector into a Vector (将向量的低半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenLower(Vector128<float>)
Widens the lower half of a Vector into a Vector (将向量的低半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenLower(Vector128<ushort>)
Widens the lower half of a Vector into a Vector (将向量的低半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenLower(Vector128<uint>)
Widens the lower half of a Vector into a Vector (将向量的低半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenUpper(Vector128<byte>)
Widens the upper half of a Vector into a Vector (将向量的高半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenUpper(Vector128<short>)
Widens the upper half of a Vector into a Vector (将向量的高半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenUpper(Vector128<int>)
Widens the upper half of a Vector into a Vector (将向量的高半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenUpper(Vector128<sbyte>)
Widens the upper half of a Vector into a Vector (将向量的高半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenUpper(Vector128<float>)
Widens the upper half of a Vector into a Vector (将向量的高半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenUpper(Vector128<ushort>)
Widens the upper half of a Vector into a Vector (将向量的高半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenUpper(Vector128<uint>)
Widens the upper half of a Vector into a Vector (将向量的高半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- Widen<T, TOut>(Vector128<T>, out Vector128<TOut>, out Vector128<TOut>)
Widens a Vector128<T> into two Vector128<T> instances - Generic version (将一个 Vector128<T> 扩宽为两个 Vector128<T> 实例 - 泛型版). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Xor<T>(Vector128<T>, Vector128<T>)
Computes the exclusive-or of two vectors (计算两个向量的位异或). Mnemonic:
rt[i] := left[i] ^ right[i].
- YBitToByte(uint)
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(uint)
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(uint)
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(uint)
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(Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<double>, Vector128<double>)
Copies the sign of a value to the sign of another value (将一个值的符号复制到另一个值). Mnemonic:
rt[i] := copySign(value[i], sign[i]).
- YCopySign(Vector128<short>, Vector128<short>)
Copies the sign of a value to the sign of another value (将一个值的符号复制到另一个值). Mnemonic:
rt[i] := copySign(value[i], sign[i]).
- YCopySign(Vector128<int>, Vector128<int>)
Copies the sign of a value to the sign of another value (将一个值的符号复制到另一个值). Mnemonic:
rt[i] := copySign(value[i], sign[i]).
- YCopySign(Vector128<long>, Vector128<long>)
Copies the sign of a value to the sign of another value (将一个值的符号复制到另一个值). Mnemonic:
rt[i] := copySign(value[i], sign[i]).
- YCopySign(Vector128<sbyte>, Vector128<sbyte>)
Copies the sign of a value to the sign of another value (将一个值的符号复制到另一个值). Mnemonic:
rt[i] := copySign(value[i], sign[i]).
- YCopySign(Vector128<float>, Vector128<float>)
Copies the sign of a value to the sign of another value (将一个值的符号复制到另一个值). Mnemonic:
rt[i] := copySign(value[i], sign[i]).
- YGroup1ToGroup3(Vector128<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(Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<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(Vector128<double>, out Vector128<double>, out Vector128<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(Vector128<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(Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<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(Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<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(Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<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(Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<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(Vector128<float>, out Vector128<float>, out Vector128<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(Vector128<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(Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<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(Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<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(Vector128<ulong>, out Vector128<ulong>, out Vector128<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>(Vector128<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(Vector128<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(Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<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(Vector128<double>, out Vector128<double>, out Vector128<double>, out Vector128<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(Vector128<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(Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<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(Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<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(Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<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(Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<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(Vector128<float>, out Vector128<float>, out Vector128<float>, out Vector128<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(Vector128<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(Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<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(Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<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(Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<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(Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<double>, Vector128<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(Vector128<double>, Vector128<double>, out Vector128<double>, out Vector128<double>, out Vector128<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(Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<float>, Vector128<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(Vector128<float>, Vector128<float>, out Vector128<float>, out Vector128<float>, out Vector128<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(Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<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>(Vector128<T>, Vector128<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>(Vector128<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(Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, out Vector128<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(Vector128<double>, Vector128<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(Vector128<double>, Vector128<double>, out Vector128<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(Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, out Vector128<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(Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, out Vector128<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(Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, out Vector128<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(Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, out Vector128<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(Vector128<float>, Vector128<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(Vector128<float>, Vector128<float>, out Vector128<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(Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, out Vector128<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(Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, out Vector128<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(Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, out Vector128<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(Vector128<byte>, Vector128<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(Vector128<double>, Vector128<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(Vector128<short>, Vector128<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(Vector128<int>, Vector128<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(Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<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(Vector128<float>, Vector128<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(Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<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(Vector128<byte>, Vector128<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(Vector128<double>, Vector128<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(Vector128<short>, Vector128<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(Vector128<int>, Vector128<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(Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<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(Vector128<float>, Vector128<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(Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<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>(Vector128<T>, Vector128<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(Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, out Vector128<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(Vector128<double>, Vector128<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(Vector128<double>, Vector128<double>, out Vector128<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(Vector128<Int128>, Vector128<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(Vector128<Int128>, Vector128<Int128>, out Vector128<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(Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, out Vector128<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(Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, out Vector128<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(Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, out Vector128<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(Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, out Vector128<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(Vector128<float>, Vector128<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(Vector128<float>, Vector128<float>, out Vector128<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(Vector128<UInt128>, Vector128<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(Vector128<UInt128>, Vector128<UInt128>, out Vector128<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(Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, out Vector128<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(Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, out Vector128<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(Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, out Vector128<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(Vector128<ExInt128>, Vector128<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(Vector128<ExInt128>, Vector128<ExInt128>, out Vector128<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(Vector128<ExUInt128>, Vector128<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(Vector128<ExUInt128>, Vector128<ExUInt128>, out Vector128<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(Vector128<byte>, Vector128<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(Vector128<double>, Vector128<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(Vector128<Int128>, Vector128<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(Vector128<short>, Vector128<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(Vector128<int>, Vector128<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(Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<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(Vector128<float>, Vector128<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(Vector128<UInt128>, Vector128<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(Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<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(Vector128<ExInt128>, Vector128<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(Vector128<ExUInt128>, Vector128<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).
- YGroup2UnzipOdd(Vector128<byte>, Vector128<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(Vector128<double>, Vector128<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(Vector128<Int128>, Vector128<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(Vector128<short>, Vector128<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(Vector128<int>, Vector128<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(Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<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(Vector128<float>, Vector128<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(Vector128<UInt128>, Vector128<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(Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<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(Vector128<ExInt128>, Vector128<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(Vector128<ExUInt128>, Vector128<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).
- YGroup2Unzip_Bit128<T>(Vector128<T>, Vector128<T>, out Vector128<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>(Vector128<T>, Vector128<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(Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, out Vector128<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(Vector128<double>, Vector128<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(Vector128<double>, Vector128<double>, out Vector128<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(Vector128<Int128>, Vector128<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(Vector128<Int128>, Vector128<Int128>, out Vector128<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(Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, out Vector128<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(Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, out Vector128<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(Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, out Vector128<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(Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, out Vector128<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(Vector128<float>, Vector128<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(Vector128<float>, Vector128<float>, out Vector128<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(Vector128<UInt128>, Vector128<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(Vector128<UInt128>, Vector128<UInt128>, out Vector128<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(Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, out Vector128<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(Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, out Vector128<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(Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, out Vector128<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(Vector128<ExInt128>, Vector128<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(Vector128<ExInt128>, Vector128<ExInt128>, out Vector128<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(Vector128<ExUInt128>, Vector128<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(Vector128<ExUInt128>, Vector128<ExUInt128>, out Vector128<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(Vector128<byte>, Vector128<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(Vector128<double>, Vector128<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(Vector128<Int128>, Vector128<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(Vector128<short>, Vector128<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(Vector128<int>, Vector128<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(Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<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(Vector128<float>, Vector128<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(Vector128<UInt128>, Vector128<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(Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<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(Vector128<ExInt128>, Vector128<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(Vector128<ExUInt128>, Vector128<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.
- YGroup2ZipLow(Vector128<byte>, Vector128<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(Vector128<double>, Vector128<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(Vector128<Int128>, Vector128<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(Vector128<short>, Vector128<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(Vector128<int>, Vector128<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(Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<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(Vector128<float>, Vector128<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(Vector128<UInt128>, Vector128<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(Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<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(Vector128<ExInt128>, Vector128<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(Vector128<ExUInt128>, Vector128<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.
- YGroup2Zip_Bit128<T>(Vector128<T>, Vector128<T>, out Vector128<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>(Vector128<T>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<double>, Vector128<double>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, out Vector128<double>, out Vector128<double>, out Vector128<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(Vector128<short>, Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<int>, Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<long>, Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<float>, Vector128<float>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, out Vector128<float>, out Vector128<float>, out Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<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>(Vector128<T>, Vector128<T>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<double>, Vector128<double>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, out Vector128<double>, out Vector128<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(Vector128<short>, Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<int>, Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<long>, Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<float>, Vector128<float>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, out Vector128<float>, out Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, out Vector128<ulong>, out Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, out Vector128<double>, out Vector128<double>, out Vector128<double>, out Vector128<double>, out Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, out Vector128<float>, out Vector128<float>, out Vector128<float>, out Vector128<float>, out Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<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>(Vector128<T>, Vector128<T>, Vector128<T>, Vector128<T>, Vector128<T>, Vector128<T>, out Vector128<T>, out Vector128<T>, out Vector128<T>, out Vector128<T>, out Vector128<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>(Vector128<T>, Vector128<T>, Vector128<T>, Vector128<T>, Vector128<T>, Vector128<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>(Vector128<T>, Vector128<T>, Vector128<T>, out Vector128<T>, out Vector128<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>(Vector128<T>, Vector128<T>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<double>, Vector128<double>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, out Vector128<double>, out Vector128<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(Vector128<short>, Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<int>, Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<long>, Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<float>, Vector128<float>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, out Vector128<float>, out Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, out Vector128<ulong>, out Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, out Vector128<double>, out Vector128<double>, out Vector128<double>, out Vector128<double>, out Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, out Vector128<float>, out Vector128<float>, out Vector128<float>, out Vector128<float>, out Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<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>(Vector128<T>, Vector128<T>, Vector128<T>, Vector128<T>, Vector128<T>, Vector128<T>, out Vector128<T>, out Vector128<T>, out Vector128<T>, out Vector128<T>, out Vector128<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>(Vector128<T>, Vector128<T>, Vector128<T>, Vector128<T>, Vector128<T>, Vector128<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>(Vector128<T>, Vector128<T>, Vector128<T>, out Vector128<T>, out Vector128<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>(Vector128<T>, Vector128<T>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, out Vector128<double>, out Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, out Vector128<float>, out Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, out Vector128<ulong>, out Vector128<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>(Vector128<T>, Vector128<T>, Vector128<T>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, out Vector128<double>, out Vector128<double>, out Vector128<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(Vector128<Int128>, Vector128<Int128>, Vector128<Int128>, Vector128<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(Vector128<Int128>, Vector128<Int128>, Vector128<Int128>, Vector128<Int128>, out Vector128<Int128>, out Vector128<Int128>, out Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, out Vector128<float>, out Vector128<float>, out Vector128<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(Vector128<UInt128>, Vector128<UInt128>, Vector128<UInt128>, Vector128<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(Vector128<UInt128>, Vector128<UInt128>, Vector128<UInt128>, Vector128<UInt128>, out Vector128<UInt128>, out Vector128<UInt128>, out Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<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(Vector128<ExInt128>, Vector128<ExInt128>, Vector128<ExInt128>, Vector128<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(Vector128<ExInt128>, Vector128<ExInt128>, Vector128<ExInt128>, Vector128<ExInt128>, out Vector128<ExInt128>, out Vector128<ExInt128>, out Vector128<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(Vector128<ExUInt128>, Vector128<ExUInt128>, Vector128<ExUInt128>, Vector128<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(Vector128<ExUInt128>, Vector128<ExUInt128>, Vector128<ExUInt128>, Vector128<ExUInt128>, out Vector128<ExUInt128>, out Vector128<ExUInt128>, out Vector128<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>(Vector128<T>, Vector128<T>, Vector128<T>, Vector128<T>, out Vector128<T>, out Vector128<T>, out Vector128<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>(Vector128<T>, Vector128<T>, Vector128<T>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, out Vector128<double>, out Vector128<double>, out Vector128<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(Vector128<Int128>, Vector128<Int128>, Vector128<Int128>, Vector128<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(Vector128<Int128>, Vector128<Int128>, Vector128<Int128>, Vector128<Int128>, out Vector128<Int128>, out Vector128<Int128>, out Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, out Vector128<float>, out Vector128<float>, out Vector128<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(Vector128<UInt128>, Vector128<UInt128>, Vector128<UInt128>, Vector128<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(Vector128<UInt128>, Vector128<UInt128>, Vector128<UInt128>, Vector128<UInt128>, out Vector128<UInt128>, out Vector128<UInt128>, out Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<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(Vector128<ExInt128>, Vector128<ExInt128>, Vector128<ExInt128>, Vector128<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(Vector128<ExInt128>, Vector128<ExInt128>, Vector128<ExInt128>, Vector128<ExInt128>, out Vector128<ExInt128>, out Vector128<ExInt128>, out Vector128<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(Vector128<ExUInt128>, Vector128<ExUInt128>, Vector128<ExUInt128>, Vector128<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(Vector128<ExUInt128>, Vector128<ExUInt128>, Vector128<ExUInt128>, Vector128<ExUInt128>, out Vector128<ExUInt128>, out Vector128<ExUInt128>, out Vector128<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>(Vector128<T>, Vector128<T>, Vector128<T>, Vector128<T>, out Vector128<T>, out Vector128<T>, out Vector128<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>(Vector128<T>, Vector128<T>, Vector128<T>, Vector128<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.
- YGroup6Unzip_Bit128<T>(Vector128<T>, Vector128<T>, Vector128<T>, Vector128<T>, Vector128<T>, Vector128<T>, out Vector128<T>, out Vector128<T>, out Vector128<T>, out Vector128<T>, out Vector128<T>)
De-Interleave 6-element groups into 6 vectors. It converts the 6-element groups AoS to SoA. (将6-元素组解交织为6个向量. 它能将6元素组的 数组结构体 转为 结构体数组). It is specialized for process 128-bit element (它专门用于处理128位元素). Mnemonic:
x[i] =: element_ref(6i, data0, data1, data2, data3, data4, data5),y[i] =: element_ref(6i+1, data0, data1, data2, data3, data4, data5),z[i] =: element_ref(6i+2, data0, data1, data2, data3, data4, data5),w[i] =: element_ref(6i+3, data0, data1, data2, data3, data4, data5),u[i] =: element_ref(6i+4, data0, data1, data2, data3, data4, data5),v[i] =: element_ref(6i+5, data0, data1, data2, data3, data4, data5).
- YGroup6Zip_Bit128<T>(Vector128<T>, Vector128<T>, Vector128<T>, Vector128<T>, Vector128<T>, Vector128<T>, out Vector128<T>, out Vector128<T>, out Vector128<T>, out Vector128<T>, out Vector128<T>)
Interleave 6 vectors into 6-element groups. It converts the 6-element groups SoA to AoS (将6个向量交织为6-元素组. 它能将6元素组的 结构体数组 转为 数组结构体. It is specialized for process 128-bit element (它专门用于处理128位元素). Mnemonic:
element_ref(i, data0, data1, data2, data3, data4, data5) := (0==(i%6))?( x[i2] ):( (1==(i%6))?( y[i2] ):( (2==(i%6))?( z[i2] ):( (3==(i%6))?( w[i2] ):( (4==(i%6))?( u[i2] ):( v[i2] ) ) ) ) ),i2 := i/6.
- YIsAllTrue<T>(Vector128<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>(Vector128<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(Vector128<byte>)
Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic:
rt[i] := to_mask(isEvenInteger(value[i])).
- YIsEvenInteger(Vector128<double>)
Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic:
rt[i] := to_mask(isEvenInteger(value[i])).
- YIsEvenInteger(Vector128<short>)
Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic:
rt[i] := to_mask(isEvenInteger(value[i])).
- YIsEvenInteger(Vector128<int>)
Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic:
rt[i] := to_mask(isEvenInteger(value[i])).
- YIsEvenInteger(Vector128<long>)
Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic:
rt[i] := to_mask(isEvenInteger(value[i])).
- YIsEvenInteger(Vector128<sbyte>)
Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic:
rt[i] := to_mask(isEvenInteger(value[i])).
- YIsEvenInteger(Vector128<float>)
Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic:
rt[i] := to_mask(isEvenInteger(value[i])).
- YIsEvenInteger(Vector128<ushort>)
Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic:
rt[i] := to_mask(isEvenInteger(value[i])).
- YIsEvenInteger(Vector128<uint>)
Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic:
rt[i] := to_mask(isEvenInteger(value[i])).
- YIsEvenInteger(Vector128<ulong>)
Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic:
rt[i] := to_mask(isEvenInteger(value[i])).
- YIsFinite(Vector128<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(Vector128<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(Vector128<double>)
Determines if a element is infinite (确定元素是否为无穷大). Mnemonic:
rt[i] := to_mask(isInfinity(value[i])).
- YIsInfinity(Vector128<float>)
Determines if a element is infinite (确定元素是否为无穷大). Mnemonic:
rt[i] := to_mask(isInfinity(value[i])).
- YIsInfinityOrNaN(Vector128<double>)
Determines if a element is infinite or NaN (确定元素是否为无穷大或非数). Mnemonic:
rt[i] := to_mask(isInfinityOrNaN(value[i])).
- YIsInfinityOrNaN(Vector128<float>)
Determines if a element is infinite or NaN (确定元素是否为无穷大或非数). Mnemonic:
rt[i] := to_mask(isInfinityOrNaN(value[i])).
- YIsInteger(Vector128<double>)
Determines if a element represents an integral number (确定元素是否为整数). Mnemonic:
rt[i] := to_mask(isInteger(value[i])).
- YIsInteger(Vector128<float>)
Determines if a element represents an integral number (确定元素是否为整数). Mnemonic:
rt[i] := to_mask(isInteger(value[i])).
- YIsNaN(Vector128<double>)
Determines if a element is NaN (确定元素是否为非数). Mnemonic:
rt[i] := to_mask(isNaN(value[i])).
- YIsNaN(Vector128<float>)
Determines if a element is NaN (确定元素是否为非数). Mnemonic:
rt[i] := to_mask(isNaN(value[i])).
- YIsNegative(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<double>)
Determines if a element is negative infinity (确定元素是否为负无穷大). Mnemonic:
rt[i] := to_mask(isNegativeInfinity(value[i])).
- YIsNegativeInfinity(Vector128<float>)
Determines if a element is negative infinity (确定元素是否为负无穷大). Mnemonic:
rt[i] := to_mask(isNegativeInfinity(value[i])).
- YIsNegativeZero(Vector128<double>)
Determines if a element represents a negative zero (确定元素是否为负零). Mnemonic:
rt[i] := to_mask(isNegativeZero(value[i])).
- YIsNegativeZero(Vector128<float>)
Determines if a element represents a negative zero (确定元素是否为负零). Mnemonic:
rt[i] := to_mask(isNegativeZero(value[i])).
- YIsNormal(Vector128<double>)
Determines if a element is normal (确定元素是否为正规数). Mnemonic:
rt[i] := to_mask(isFinite(value[i])).
- YIsNormal(Vector128<float>)
Determines if a element is normal (确定元素是否为正规数). Mnemonic:
rt[i] := to_mask(isFinite(value[i])).
- YIsNotEquals(Vector128<byte>, Vector128<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(Vector128<double>, Vector128<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(Vector128<short>, Vector128<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(Vector128<int>, Vector128<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(Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<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(Vector128<float>, Vector128<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(Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<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(Vector128<double>)
Determines if a element is not NaN (确定元素是否不为非数). Mnemonic:
rt[i] := to_mask(isNotNaN(value[i])) = to_mask(!isNaN(value[i])).
- YIsNotNaN(Vector128<float>)
Determines if a element is not NaN (确定元素是否不为非数). Mnemonic:
rt[i] := to_mask(isNotNaN(value[i])) = to_mask(!isNaN(value[i])).
- YIsOddInteger(Vector128<byte>)
Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic:
rt[i] := to_mask(isOddInteger(value[i])).
- YIsOddInteger(Vector128<double>)
Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic:
rt[i] := to_mask(isOddInteger(value[i])).
- YIsOddInteger(Vector128<short>)
Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic:
rt[i] := to_mask(isOddInteger(value[i])).
- YIsOddInteger(Vector128<int>)
Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic:
rt[i] := to_mask(isOddInteger(value[i])).
- YIsOddInteger(Vector128<long>)
Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic:
rt[i] := to_mask(isOddInteger(value[i])).
- YIsOddInteger(Vector128<sbyte>)
Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic:
rt[i] := to_mask(isOddInteger(value[i])).
- YIsOddInteger(Vector128<float>)
Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic:
rt[i] := to_mask(isOddInteger(value[i])).
- YIsOddInteger(Vector128<ushort>)
Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic:
rt[i] := to_mask(isOddInteger(value[i])).
- YIsOddInteger(Vector128<uint>)
Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic:
rt[i] := to_mask(isOddInteger(value[i])).
- YIsOddInteger(Vector128<ulong>)
Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic:
rt[i] := to_mask(isOddInteger(value[i])).
- YIsPositive(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<double>)
Determines if a element is positive infinity (确定元素是否为正无穷大). Mnemonic:
rt[i] := to_mask(isNegativeInfinity(value[i])).
- YIsPositiveInfinity(Vector128<float>)
Determines if a element is positive infinity (确定元素是否为正无穷大). Mnemonic:
rt[i] := to_mask(isNegativeInfinity(value[i])).
- YIsSubnormal(Vector128<double>)
Determines if a element is subnormal (确定元素是否为次正规数). Mnemonic:
rt[i] := to_mask(IsSubnormal(value[i])).
- YIsSubnormal(Vector128<float>)
Determines if a element is subnormal (确定元素是否为次正规数). Mnemonic:
rt[i] := to_mask(IsSubnormal(value[i])).
- YIsZero(Vector128<byte>)
Determines if a element is zero (确定元素是否为零). Mnemonic:
rt[i] := to_mask(0==value[i]).
- YIsZero(Vector128<double>)
Determines if a element is zero (确定元素是否为零). Mnemonic:
rt[i] := to_mask(0==value[i]).
- YIsZero(Vector128<short>)
Determines if a element is zero (确定元素是否为零). Mnemonic:
rt[i] := to_mask(0==value[i]).
- YIsZero(Vector128<int>)
Determines if a element is zero (确定元素是否为零). Mnemonic:
rt[i] := to_mask(0==value[i]).
- YIsZero(Vector128<long>)
Determines if a element is zero (确定元素是否为零). Mnemonic:
rt[i] := to_mask(0==value[i]).
- YIsZero(Vector128<sbyte>)
Determines if a element is zero (确定元素是否为零). Mnemonic:
rt[i] := to_mask(0==value[i]).
- YIsZero(Vector128<float>)
Determines if a element is zero (确定元素是否为零). Mnemonic:
rt[i] := to_mask(0==value[i]).
- YIsZero(Vector128<ushort>)
Determines if a element is zero (确定元素是否为零). Mnemonic:
rt[i] := to_mask(0==value[i]).
- YIsZero(Vector128<uint>)
Determines if a element is zero (确定元素是否为零). Mnemonic:
rt[i] := to_mask(0==value[i]).
- YIsZero(Vector128<ulong>)
Determines if a element is zero (确定元素是否为零). Mnemonic:
rt[i] := to_mask(0==value[i]).
- YIsZeroOrSubnormal(Vector128<double>)
Determines if a element is zero or subnormal (确定元素是否为零或次正规数). Mnemonic:
rt[i] := to_mask(isZeroOrSubnormal(value[i])).
- YIsZeroOrSubnormal(Vector128<float>)
Determines if a element is zero or subnormal (确定元素是否为零或次正规数). Mnemonic:
rt[i] := to_mask(isZeroOrSubnormal(value[i])).
- YMaxNumber(Vector128<double>, Vector128<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
NaNinputs to not be propagated back to the caller and for-0.0to 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(Vector128<float>, Vector128<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
NaNinputs to not be propagated back to the caller and for-0.0to 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(Vector128<double>, Vector128<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
NaNinputs to not be propagated back to the caller and for-0.0to 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(Vector128<float>, Vector128<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
NaNinputs to not be propagated back to the caller and for-0.0to 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(Vector128<short>, Vector128<short>)
Saturate narrows two Vector128<T> instances into one Vector128<T>" (将两个 Vector128<T> 实例饱和缩窄为一个 Vector128<T> ). />. Mnemonic:
rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), TOut.MinValue, TOut.MaxValue)).
- YNarrowSaturate(Vector128<int>, Vector128<int>)
Saturate narrows two Vector128<T> instances into one Vector128<T>" (将两个 Vector128<T> 实例饱和缩窄为一个 Vector128<T> ). />. Mnemonic:
rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), TOut.MinValue, TOut.MaxValue)).
- YNarrowSaturate(Vector128<long>, Vector128<long>)
Saturate narrows two Vector128<T> instances into one Vector128<T>" (将两个 Vector128<T> 实例饱和缩窄为一个 Vector128<T> ). />. Mnemonic:
rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), TOut.MinValue, TOut.MaxValue)).
- YNarrowSaturate(Vector128<ushort>, Vector128<ushort>)
Saturate narrows two Vector128<T> instances into one Vector128<T>" (将两个 Vector128<T> 实例饱和缩窄为一个 Vector128<T> ). />. Mnemonic:
rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), TOut.MinValue, TOut.MaxValue)).
- YNarrowSaturate(Vector128<uint>, Vector128<uint>)
Saturate narrows two Vector128<T> instances into one Vector128<T>" (将两个 Vector128<T> 实例饱和缩窄为一个 Vector128<T> ). />. Mnemonic:
rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), TOut.MinValue, TOut.MaxValue)).
- YNarrowSaturate(Vector128<ulong>, Vector128<ulong>)
Saturate narrows two Vector128<T> instances into one Vector128<T>" (将两个 Vector128<T> 实例饱和缩窄为一个 Vector128<T> ). />. Mnemonic:
rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), TOut.MinValue, TOut.MaxValue)).
- YNarrowSaturateUnsigned(Vector128<short>, Vector128<short>)
Saturate narrows two signed Vector128<T> instances into one unsigned Vector128<T>" (将两个有符号 Vector128<T> 实例饱和缩窄为一个无符号 Vector128<T> ). />. Mnemonic:
rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), 0, TOut.MaxValue)).
- YNarrowSaturateUnsigned(Vector128<int>, Vector128<int>)
Saturate narrows two signed Vector128<T> instances into one unsigned Vector128<T>" (将两个有符号 Vector128<T> 实例饱和缩窄为一个无符号 Vector128<T> ). />. Mnemonic:
rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), 0, TOut.MaxValue)).
- YNarrowSaturateUnsigned(Vector128<long>, Vector128<long>)
Saturate narrows two signed Vector128<T> instances into one unsigned Vector128<T>" (将两个有符号 Vector128<T> 实例饱和缩窄为一个无符号 Vector128<T> ). />. Mnemonic:
rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), 0, TOut.MaxValue)).
- YOrNot<T>(Vector128<T>, Vector128<T>)
Computes the bitwise-or of a given vector or the ones complement of another vector (计算一个给定的向量和另一个向量反码的位或). Mnemonic:
rt[i] := left[i] | ~right[i].
- YRoundToEven(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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)].
- YShuffleG4X2(Vector128<byte>, Vector128<byte>, ShuffleControlG4)
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(Vector128<byte>, Vector128<byte>, ShuffleControlG4, out Vector128<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(Vector128<double>, Vector128<double>, ShuffleControlG4)
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(Vector128<double>, Vector128<double>, ShuffleControlG4, out Vector128<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(Vector128<short>, Vector128<short>, ShuffleControlG4)
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(Vector128<short>, Vector128<short>, ShuffleControlG4, out Vector128<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(Vector128<int>, Vector128<int>, ShuffleControlG4)
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(Vector128<int>, Vector128<int>, ShuffleControlG4, out Vector128<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(Vector128<long>, Vector128<long>, ShuffleControlG4)
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(Vector128<long>, Vector128<long>, ShuffleControlG4, out Vector128<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(Vector128<sbyte>, Vector128<sbyte>, ShuffleControlG4)
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(Vector128<sbyte>, Vector128<sbyte>, ShuffleControlG4, out Vector128<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(Vector128<float>, Vector128<float>, ShuffleControlG4)
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(Vector128<float>, Vector128<float>, ShuffleControlG4, out Vector128<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(Vector128<ushort>, Vector128<ushort>, ShuffleControlG4)
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(Vector128<ushort>, Vector128<ushort>, ShuffleControlG4, out Vector128<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(Vector128<uint>, Vector128<uint>, ShuffleControlG4)
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(Vector128<uint>, Vector128<uint>, ShuffleControlG4, out Vector128<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(Vector128<ulong>, Vector128<ulong>, ShuffleControlG4)
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(Vector128<ulong>, Vector128<ulong>, ShuffleControlG4, out Vector128<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(Vector128<byte>, Vector128<byte>, ShuffleControlG4)
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(Vector128<byte>, Vector128<byte>, ShuffleControlG4, out Vector128<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(Vector128<double>, Vector128<double>, ShuffleControlG4)
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(Vector128<double>, Vector128<double>, ShuffleControlG4, out Vector128<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(Vector128<short>, Vector128<short>, ShuffleControlG4)
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(Vector128<short>, Vector128<short>, ShuffleControlG4, out Vector128<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(Vector128<int>, Vector128<int>, ShuffleControlG4)
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(Vector128<int>, Vector128<int>, ShuffleControlG4, out Vector128<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(Vector128<long>, Vector128<long>, ShuffleControlG4)
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(Vector128<long>, Vector128<long>, ShuffleControlG4, out Vector128<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(Vector128<sbyte>, Vector128<sbyte>, ShuffleControlG4)
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(Vector128<sbyte>, Vector128<sbyte>, ShuffleControlG4, out Vector128<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(Vector128<float>, Vector128<float>, ShuffleControlG4)
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(Vector128<float>, Vector128<float>, ShuffleControlG4, out Vector128<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(Vector128<ushort>, Vector128<ushort>, ShuffleControlG4)
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(Vector128<ushort>, Vector128<ushort>, ShuffleControlG4, out Vector128<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(Vector128<uint>, Vector128<uint>, ShuffleControlG4)
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(Vector128<uint>, Vector128<uint>, ShuffleControlG4, out Vector128<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(Vector128<ulong>, Vector128<ulong>, ShuffleControlG4)
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(Vector128<ulong>, Vector128<ulong>, ShuffleControlG4, out Vector128<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>(Vector128<T>, Vector128<T>, ShuffleControlG4)
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<T>(Vector128<T>, Vector128<T>, ShuffleControlG4)
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).
- YShuffleG4_Const(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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(Vector128<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)].
- YShuffleInsert(Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<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(Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<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(Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<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(Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<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(Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<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(Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<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(Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<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(Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<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(Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<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>(Vector128<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>(Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, (Vector128<byte> args0, Vector128<byte> args1, Vector128<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(Vector128<double>, Vector128<double>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<double>, Vector128<double>, (Vector128<long> args0, Vector128<long> args1, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, (Vector128<short> args0, Vector128<short> args1, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, (Vector128<int> args0, Vector128<int> args1, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, (Vector128<long> args0, Vector128<long> args1, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, (Vector128<sbyte> args0, Vector128<sbyte> args1, Vector128<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(Vector128<float>, Vector128<float>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<float>, Vector128<float>, (Vector128<int> args0, Vector128<int> args1, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, (Vector128<ushort> args0, Vector128<ushort> args1, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, (Vector128<uint> args0, Vector128<uint> args1, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, (Vector128<ulong> args0, Vector128<ulong> args1, Vector128<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(Vector128<byte>, Vector128<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(Vector128<double>, Vector128<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(Vector128<short>, Vector128<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(Vector128<int>, Vector128<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(Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<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(Vector128<float>, Vector128<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(Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<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(Vector128<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(Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<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(Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<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(Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<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(Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<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(Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<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(Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<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(Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<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(Vector128<ulong>, out Vector128<ulong>, out Vector128<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>(Vector128<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>(Vector128<TIdx>, out Vector128<TIdx>, out Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<byte>, (Vector128<byte> args0, Vector128<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(Vector128<double>, Vector128<long>, Vector128<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(Vector128<double>, (Vector128<long> args0, Vector128<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(Vector128<short>, Vector128<short>, Vector128<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(Vector128<short>, (Vector128<short> args0, Vector128<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(Vector128<int>, Vector128<int>, Vector128<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(Vector128<int>, (Vector128<int> args0, Vector128<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(Vector128<long>, Vector128<long>, Vector128<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(Vector128<long>, (Vector128<long> args0, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<sbyte>, (Vector128<sbyte> args0, Vector128<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(Vector128<float>, Vector128<int>, Vector128<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(Vector128<float>, (Vector128<int> args0, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<ushort>, (Vector128<ushort> args0, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<uint>, (Vector128<uint> args0, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<ulong>, (Vector128<ulong> args0, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<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(Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<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(Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<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(Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<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(Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<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(Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<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(Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<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(Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<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(Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<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>(Vector128<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>(Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, (Vector128<byte> args0, Vector128<byte> args1, Vector128<byte> args2, Vector128<byte> args3, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, (Vector128<long> args0, Vector128<long> args1, Vector128<long> args2, Vector128<long> args3, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, (Vector128<short> args0, Vector128<short> args1, Vector128<short> args2, Vector128<short> args3, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, (Vector128<int> args0, Vector128<int> args1, Vector128<int> args2, Vector128<int> args3, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, (Vector128<long> args0, Vector128<long> args1, Vector128<long> args2, Vector128<long> args3, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, (Vector128<sbyte> args0, Vector128<sbyte> args1, Vector128<sbyte> args2, Vector128<sbyte> args3, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, (Vector128<int> args0, Vector128<int> args1, Vector128<int> args2, Vector128<int> args3, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, (Vector128<ushort> args0, Vector128<ushort> args1, Vector128<ushort> args2, Vector128<ushort> args3, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, (Vector128<uint> args0, Vector128<uint> args1, Vector128<uint> args2, Vector128<uint> args3, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, (Vector128<ulong> args0, Vector128<ulong> args1, Vector128<ulong> args2, Vector128<ulong> args3, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<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(Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<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(Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<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(Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<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(Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<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(Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<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(Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<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(Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<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(Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<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>(Vector128<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>(Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, (Vector128<byte> args0, Vector128<byte> args1, Vector128<byte> args2, Vector128<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(Vector128<double>, Vector128<double>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<double>, Vector128<double>, (Vector128<long> args0, Vector128<long> args1, Vector128<long> args2, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, (Vector128<short> args0, Vector128<short> args1, Vector128<short> args2, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, (Vector128<int> args0, Vector128<int> args1, Vector128<int> args2, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, (Vector128<long> args0, Vector128<long> args1, Vector128<long> args2, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, (Vector128<sbyte> args0, Vector128<sbyte> args1, Vector128<sbyte> args2, Vector128<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(Vector128<float>, Vector128<float>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<float>, Vector128<float>, (Vector128<int> args0, Vector128<int> args1, Vector128<int> args2, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, (Vector128<ushort> args0, Vector128<ushort> args1, Vector128<ushort> args2, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, (Vector128<uint> args0, Vector128<uint> args1, Vector128<uint> args2, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, (Vector128<ulong> args0, Vector128<ulong> args1, Vector128<ulong> args2, Vector128<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(Vector128<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(Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<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(Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<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(Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<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(Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<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(Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<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(Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<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(Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<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(Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<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>(Vector128<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>(Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, (Vector128<byte> args0, Vector128<byte> args1, Vector128<byte> args2, Vector128<byte> args3, Vector128<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(Vector128<double>, Vector128<double>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<double>, Vector128<double>, (Vector128<long> args0, Vector128<long> args1, Vector128<long> args2, Vector128<long> args3, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, (Vector128<short> args0, Vector128<short> args1, Vector128<short> args2, Vector128<short> args3, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, (Vector128<int> args0, Vector128<int> args1, Vector128<int> args2, Vector128<int> args3, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, (Vector128<long> args0, Vector128<long> args1, Vector128<long> args2, Vector128<long> args3, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, (Vector128<sbyte> args0, Vector128<sbyte> args1, Vector128<sbyte> args2, Vector128<sbyte> args3, Vector128<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(Vector128<float>, Vector128<float>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<float>, Vector128<float>, (Vector128<int> args0, Vector128<int> args1, Vector128<int> args2, Vector128<int> args3, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, (Vector128<ushort> args0, Vector128<ushort> args1, Vector128<ushort> args2, Vector128<ushort> args3, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, (Vector128<uint> args0, Vector128<uint> args1, Vector128<uint> args2, Vector128<uint> args3, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, (Vector128<ulong> args0, Vector128<ulong> args1, Vector128<ulong> args2, Vector128<ulong> args3, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<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(Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<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(Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<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(Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<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(Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<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(Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<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(Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<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(Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<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(Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<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>(Vector128<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>(Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, (Vector128<byte> args0, Vector128<byte> args1, Vector128<byte> args2, Vector128<byte> args3, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, (Vector128<long> args0, Vector128<long> args1, Vector128<long> args2, Vector128<long> args3, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, (Vector128<short> args0, Vector128<short> args1, Vector128<short> args2, Vector128<short> args3, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, (Vector128<int> args0, Vector128<int> args1, Vector128<int> args2, Vector128<int> args3, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, (Vector128<long> args0, Vector128<long> args1, Vector128<long> args2, Vector128<long> args3, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, (Vector128<sbyte> args0, Vector128<sbyte> args1, Vector128<sbyte> args2, Vector128<sbyte> args3, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, (Vector128<int> args0, Vector128<int> args1, Vector128<int> args2, Vector128<int> args3, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, (Vector128<ushort> args0, Vector128<ushort> args1, Vector128<ushort> args2, Vector128<ushort> args3, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, (Vector128<uint> args0, Vector128<uint> args1, Vector128<uint> args2, Vector128<uint> args3, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, (Vector128<ulong> args0, Vector128<ulong> args1, Vector128<ulong> args2, Vector128<ulong> args3, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<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(Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<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(Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<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(Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<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(Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<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(Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<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(Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<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(Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<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(Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<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>(Vector128<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>(Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, (Vector128<byte> args0, Vector128<byte> args1, Vector128<byte> args2, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, (Vector128<long> args0, Vector128<long> args1, Vector128<long> args2, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, (Vector128<short> args0, Vector128<short> args1, Vector128<short> args2, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, (Vector128<int> args0, Vector128<int> args1, Vector128<int> args2, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, (Vector128<long> args0, Vector128<long> args1, Vector128<long> args2, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, (Vector128<sbyte> args0, Vector128<sbyte> args1, Vector128<sbyte> args2, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, (Vector128<int> args0, Vector128<int> args1, Vector128<int> args2, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, (Vector128<ushort> args0, Vector128<ushort> args1, Vector128<ushort> args2, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, (Vector128<uint> args0, Vector128<uint> args1, Vector128<uint> args2, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, (Vector128<ulong> args0, Vector128<ulong> args1, Vector128<ulong> args2, Vector128<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(Vector128<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(Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<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(Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<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(Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<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(Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<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(Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<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(Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<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(Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<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(Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<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>(Vector128<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>(Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, (Vector128<byte> args0, Vector128<byte> args1, Vector128<byte> args2, Vector128<byte> args3, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, (Vector128<long> args0, Vector128<long> args1, Vector128<long> args2, Vector128<long> args3, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, (Vector128<short> args0, Vector128<short> args1, Vector128<short> args2, Vector128<short> args3, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, (Vector128<int> args0, Vector128<int> args1, Vector128<int> args2, Vector128<int> args3, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, (Vector128<long> args0, Vector128<long> args1, Vector128<long> args2, Vector128<long> args3, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, (Vector128<sbyte> args0, Vector128<sbyte> args1, Vector128<sbyte> args2, Vector128<sbyte> args3, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, (Vector128<int> args0, Vector128<int> args1, Vector128<int> args2, Vector128<int> args3, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, (Vector128<ushort> args0, Vector128<ushort> args1, Vector128<ushort> args2, Vector128<ushort> args3, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, (Vector128<uint> args0, Vector128<uint> args1, Vector128<uint> args2, Vector128<uint> args3, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, (Vector128<ulong> args0, Vector128<ulong> args1, Vector128<ulong> args2, Vector128<ulong> args3, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<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(Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<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(Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<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(Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<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(Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<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(Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<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(Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<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(Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<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(Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<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>(Vector128<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>(Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, (Vector128<byte> args0, Vector128<byte> args1, Vector128<byte> args2, Vector128<byte> args3, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, (Vector128<long> args0, Vector128<long> args1, Vector128<long> args2, Vector128<long> args3, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, (Vector128<short> args0, Vector128<short> args1, Vector128<short> args2, Vector128<short> args3, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, (Vector128<int> args0, Vector128<int> args1, Vector128<int> args2, Vector128<int> args3, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, (Vector128<long> args0, Vector128<long> args1, Vector128<long> args2, Vector128<long> args3, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, (Vector128<sbyte> args0, Vector128<sbyte> args1, Vector128<sbyte> args2, Vector128<sbyte> args3, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, (Vector128<int> args0, Vector128<int> args1, Vector128<int> args2, Vector128<int> args3, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, (Vector128<ushort> args0, Vector128<ushort> args1, Vector128<ushort> args2, Vector128<ushort> args3, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, (Vector128<uint> args0, Vector128<uint> args1, Vector128<uint> args2, Vector128<uint> args3, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, (Vector128<ulong> args0, Vector128<ulong> args1, Vector128<ulong> args2, Vector128<ulong> args3, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<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(Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<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(Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<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(Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<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(Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<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(Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<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(Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<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(Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<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(Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<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>(Vector128<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>(Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, (Vector128<byte> args0, Vector128<byte> args1, Vector128<byte> args2, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, (Vector128<long> args0, Vector128<long> args1, Vector128<long> args2, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, (Vector128<short> args0, Vector128<short> args1, Vector128<short> args2, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, (Vector128<int> args0, Vector128<int> args1, Vector128<int> args2, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, (Vector128<long> args0, Vector128<long> args1, Vector128<long> args2, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, (Vector128<sbyte> args0, Vector128<sbyte> args1, Vector128<sbyte> args2, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, (Vector128<int> args0, Vector128<int> args1, Vector128<int> args2, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, (Vector128<ushort> args0, Vector128<ushort> args1, Vector128<ushort> args2, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, (Vector128<uint> args0, Vector128<uint> args1, Vector128<uint> args2, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, (Vector128<ulong> args0, Vector128<ulong> args1, Vector128<ulong> args2, Vector128<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(Vector128<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(Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<byte>, out Vector128<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(Vector128<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(Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<short>, out Vector128<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(Vector128<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(Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<int>, out Vector128<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(Vector128<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(Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<long>, out Vector128<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(Vector128<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(Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<sbyte>, out Vector128<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(Vector128<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(Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<ushort>, out Vector128<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(Vector128<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(Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<uint>, out Vector128<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(Vector128<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(Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<ulong>, out Vector128<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>(Vector128<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>(Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<TIdx>, out Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<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(Vector128<byte>, Vector128<byte>, Vector128<byte>, Vector128<byte>, (Vector128<byte> args0, Vector128<byte> args1, Vector128<byte> args2, Vector128<byte> args3, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<double>, Vector128<double>, Vector128<double>, Vector128<double>, (Vector128<long> args0, Vector128<long> args1, Vector128<long> args2, Vector128<long> args3, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, Vector128<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(Vector128<short>, Vector128<short>, Vector128<short>, Vector128<short>, (Vector128<short> args0, Vector128<short> args1, Vector128<short> args2, Vector128<short> args3, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, (Vector128<int> args0, Vector128<int> args1, Vector128<int> args2, Vector128<int> args3, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, Vector128<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(Vector128<long>, Vector128<long>, Vector128<long>, Vector128<long>, (Vector128<long> args0, Vector128<long> args1, Vector128<long> args2, Vector128<long> args3, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<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(Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, Vector128<sbyte>, (Vector128<sbyte> args0, Vector128<sbyte> args1, Vector128<sbyte> args2, Vector128<sbyte> args3, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<int>, Vector128<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(Vector128<float>, Vector128<float>, Vector128<float>, Vector128<float>, (Vector128<int> args0, Vector128<int> args1, Vector128<int> args2, Vector128<int> args3, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<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(Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, Vector128<ushort>, (Vector128<ushort> args0, Vector128<ushort> args1, Vector128<ushort> args2, Vector128<ushort> args3, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<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(Vector128<uint>, Vector128<uint>, Vector128<uint>, Vector128<uint>, (Vector128<uint> args0, Vector128<uint> args1, Vector128<uint> args2, Vector128<uint> args3, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<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(Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, Vector128<ulong>, (Vector128<ulong> args0, Vector128<ulong> args1, Vector128<ulong> args2, Vector128<ulong> args3, Vector128<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(Vector128<double>)
Determine the sign of each element (判断各个元素的符号). Mnemonic:
rt[i] := sign(value[i]).
- YSign(Vector128<short>)
Determine the sign of each element (判断各个元素的符号). Mnemonic:
rt[i] := sign(value[i]).
- YSign(Vector128<int>)
Determine the sign of each element (判断各个元素的符号). Mnemonic:
rt[i] := sign(value[i]).
- YSign(Vector128<long>)
Determine the sign of each element (判断各个元素的符号). Mnemonic:
rt[i] := sign(value[i]).
- YSign(Vector128<sbyte>)
Determine the sign of each element (判断各个元素的符号). Mnemonic:
rt[i] := sign(value[i]).
- YSign(Vector128<float>)
Determine the sign of each element (判断各个元素的符号). Mnemonic:
rt[i] := sign(value[i]).
- YSignFloat(Vector128<double>)
Determine the sign of each element and returns a floating point number (判断各个元素的符号并返回浮点数). Mnemonic:
rt[i] := signFloat(value[i]).
- YSignFloat(Vector128<float>)
Determine the sign of each element and returns a floating point number (判断各个元素的符号并返回浮点数). Mnemonic:
rt[i] := signFloat(value[i]).