Class VectorTraitsAbstract
- Namespace
- Zyl.VectorTraits.Impl.AVector
- Assembly
- VectorTraits.dll
Vector<T> traits - abstract.
public abstract class VectorTraitsAbstract : IVectorTraits, IBaseTraits- Inheritance
-
VectorTraitsAbstract
- Implements
- Derived
- Inherited Members
- Extension Methods
-
IVectorTraits_Extensions.YGroup3ToGroup4(IVectorTraits, Vector<short>, Vector<short>, Vector<short>)IVectorTraits_Extensions.YGroup3ToGroup4(IVectorTraits, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)IVectorTraits_Extensions.YGroup3ToGroup4(IVectorTraits, Vector<float>, Vector<float>, Vector<float>)IVectorTraits_Extensions.YGroup3ToGroup4(IVectorTraits, Vector<ulong>, Vector<ulong>, Vector<ulong>)IVectorTraits_Extensions.YGroup3Unzip(IVectorTraits, Vector<double>, Vector<double>, Vector<double>)IVectorTraits_Extensions.YGroup3Unzip(IVectorTraits, Vector<ushort>, Vector<ushort>, Vector<ushort>)IVectorTraits_Extensions.YShuffleG4X2(IVectorTraits, Vector<short>, Vector<short>, ShuffleControlG4)IVectorTraits_Extensions.YShuffleG4X2(IVectorTraits, Vector<sbyte>, Vector<sbyte>, ShuffleControlG4)IVectorTraits_Extensions.YShuffleG4X2(IVectorTraits, Vector<float>, Vector<float>, ShuffleControlG4)
Properties
- Add_AcceleratedTypes
Types with hardware acceleration when running
Add(运行Add时具有硬件加速的类型).
- ByteCount
Get byte count (取得字节数量).
- Ceiling_AcceleratedTypes
Types with hardware acceleration when running
Ceiling(运行Ceiling时具有硬件加速的类型).
- ConvertToDouble_AcceleratedTypes
Types with hardware acceleration when running
ConvertToDouble(运行ConvertToDouble时具有硬件加速的类型).
- ConvertToInt32_AcceleratedTypes
Types with hardware acceleration when running
ConvertToInt32(运行ConvertToInt32时具有硬件加速的类型).
- ConvertToInt64_AcceleratedTypes
Types with hardware acceleration when running
ConvertToInt64(运行ConvertToInt64时具有硬件加速的类型).
- ConvertToSingle_AcceleratedTypes
Types with hardware acceleration when running
ConvertToSingle(运行ConvertToSingle时具有硬件加速的类型).
- ConvertToUInt32_AcceleratedTypes
Types with hardware acceleration when running
ConvertToUInt32(运行ConvertToUInt32时具有硬件加速的类型).
- ConvertToUInt64_AcceleratedTypes
Types with hardware acceleration when running
ConvertToUInt64(运行ConvertToUInt64时具有硬件加速的类型).
- Dot_AcceleratedTypes
Types with hardware acceleration when running
Dot(运行Dot时具有硬件加速的类型).
- ExtractMostSignificantBits_AcceleratedTypes
Types with hardware acceleration when running
ExtractMostSignificantBits(运行ExtractMostSignificantBits时具有硬件加速的类型).
- Floor_AcceleratedTypes
Types with hardware acceleration when running
Floor(运行Floor时具有硬件加速的类型).
- IsHardwareAccelerated
Whether to exist hardware accelerated (是否存在硬件加速).
- IsSupported
Whether to support the run (是否支持运行).
- Multiply_AcceleratedTypes
Types with hardware acceleration when running
Multiply(运行Multiply时具有硬件加速的类型).
- Multiply_FullAcceleratedTypes
Types with full hardware acceleration when running
Multiply(运行Multiply时具有完全硬件加速的类型).
- Narrow_AcceleratedTypes
Types with hardware acceleration when running
Narrow(运行Narrow时具有硬件加速的类型).
- ShiftLeft_AcceleratedTypes
Types with hardware acceleration when running
ShiftLeft(运行ShiftLeft时具有硬件加速的类型).
- ShiftRightArithmetic_AcceleratedTypes
Types with hardware acceleration when running
ShiftRightArithmetic(运行ShiftRightArithmetic时具有硬件加速的类型).
- ShiftRightLogical_AcceleratedTypes
Types with hardware acceleration when running
ShiftRightLogical(运行ShiftRightLogical时具有硬件加速的类型).
- Shuffle_AcceleratedTypes
Types with hardware acceleration when running
Shuffle(运行Shuffle时具有硬件加速的类型).
- Sqrt_AcceleratedTypes
Types with hardware acceleration when running
Sqrt(运行Sqrt时具有硬件加速的类型).
- Sum_AcceleratedTypes
Types with hardware acceleration when running
Sum(运行Sum时具有硬件加速的类型).
- UsedInstructionSets
Used instruction sets. The separator is a comma char ',' (使用的指令集. 分隔符是逗号 ',').
- WidenLower_AcceleratedTypes
Types with hardware acceleration when running
WidenLower(运行WidenLower时具有硬件加速的类型).
- WidenUpper_AcceleratedTypes
Types with hardware acceleration when running
WidenUpper(运行WidenUpper时具有硬件加速的类型).
- Widen_AcceleratedTypes
Types with hardware acceleration when running
Widen(运行Widen时具有硬件加速的类型).
- YBitToByte_IsAccelerated
Is it has hardware accelerated when running
YBitToByte(运行YBitToByte时是否具有硬件加速).
- YBitToInt16_IsAccelerated
Is it has hardware accelerated when running
YBitToInt16(运行YBitToInt16时是否具有硬件加速).
- YBitToInt32_IsAccelerated
Is it has hardware accelerated when running
YBitToInt32(运行YBitToInt32时是否具有硬件加速).
- YBitToInt64_IsAccelerated
Is it has hardware accelerated when running
YBitToInt64(运行YBitToInt64时是否具有硬件加速).
- YClamp_AcceleratedTypes
Types with hardware acceleration when running
YClamp(运行YClamp时具有硬件加速的类型).
- YCopySign_AcceleratedTypes
Types with hardware acceleration when running
YCopySign(运行YCopySign时具有硬件加速的类型).
- YGroup1ToGroup3_AcceleratedTypes
Types with hardware acceleration when running
YGroup1ToGroup3(运行YGroup1ToGroup3时具有硬件加速的类型).
- YGroup1ToGroup4WithW_AcceleratedTypes
Types with hardware acceleration when running
YGroup1ToGroup4WithW(运行YGroup1ToGroup4WithW时具有硬件加速的类型).
- YGroup1ToGroup4_AcceleratedTypes
Types with hardware acceleration when running
YGroup1ToGroup4(运行YGroup1ToGroup4时具有硬件加速的类型).
- YGroup2TransposeEven_AcceleratedTypes
Types with hardware acceleration when running
YGroup2TransposeEven(运行YGroup2TransposeEven时具有硬件加速的类型).
- YGroup2TransposeOdd_AcceleratedTypes
Types with hardware acceleration when running
YGroup2TransposeOdd(运行YGroup2TransposeOdd时具有硬件加速的类型).
- YGroup2Transpose_AcceleratedTypes
Types with hardware acceleration when running
YGroup2Transpose(运行YGroup2Transpose时具有硬件加速的类型).
- YGroup2UnzipEven_AcceleratedTypes
Types with hardware acceleration when running
YGroup2UnzipEven(运行YGroup2UnzipEven时具有硬件加速的类型).
- YGroup2UnzipOdd_AcceleratedTypes
Types with hardware acceleration when running
YGroup2UnzipOdd(运行YGroup2UnzipOdd时具有硬件加速的类型).
- YGroup2Unzip_AcceleratedTypes
Types with hardware acceleration when running
YGroup2Unzip(运行YGroup2Unzip时具有硬件加速的类型).
- YGroup2ZipHigh_AcceleratedTypes
Types with hardware acceleration when running
YGroup2ZipHigh(运行YGroup2ZipHigh时具有硬件加速的类型).
- YGroup2ZipLow_AcceleratedTypes
Types with hardware acceleration when running
YGroup2ZipLow(运行YGroup2ZipLow时具有硬件加速的类型).
- YGroup2Zip_AcceleratedTypes
Types with hardware acceleration when running
YGroup2Zip(运行YGroup2Zip时具有硬件加速的类型).
- YGroup3ToGroup4_AcceleratedTypes
Types with hardware acceleration when running
YGroup3ToGroup4(运行YGroup3ToGroup4时具有硬件加速的类型).
- YGroup3UnzipX2_AcceleratedTypes
Types with hardware acceleration when running
YGroup3UnzipX2(运行YGroup3UnzipX2时具有硬件加速的类型).
- YGroup3Unzip_AcceleratedTypes
Types with hardware acceleration when running
YGroup3Unzip(运行YGroup3Unzip时具有硬件加速的类型).
- YGroup3ZipX2_AcceleratedTypes
Types with hardware acceleration when running
YGroup3ZipX2(运行YGroup3ZipX2时具有硬件加速的类型).
- YGroup3Zip_AcceleratedTypes
Types with hardware acceleration when running
YGroup3Zip(运行YGroup3Zip时具有硬件加速的类型).
- YGroup4ToGroup3_AcceleratedTypes
Types with hardware acceleration when running
YGroup4ToGroup3(运行YGroup4ToGroup3时具有硬件加速的类型).
- YGroup4Unzip_AcceleratedTypes
Types with hardware acceleration when running
YGroup4Unzip(运行YGroup4Unzip时具有硬件加速的类型).
- YGroup4Zip_AcceleratedTypes
Types with hardware acceleration when running
YGroup4Zip(运行YGroup4Zip时具有硬件加速的类型).
- YIsAllTrue_AcceleratedTypes
Types with hardware acceleration when running
YIsAllTrue(运行YIsAllTrue时具有硬件加速的类型).
- YIsAnyTrue_AcceleratedTypes
Types with hardware acceleration when running
YIsAnyTrue(运行YIsAnyTrue时具有硬件加速的类型).
- YIsEvenInteger_AcceleratedTypes
Types with hardware acceleration when running
YIsEvenInteger(运行YIsEvenInteger时具有硬件加速的类型).
- YIsFinite_AcceleratedTypes
Types with hardware acceleration when running
YIsFinite(运行YIsFinite时具有硬件加速的类型).
- YIsInfinityOrNaN_AcceleratedTypes
Types with hardware acceleration when running
YIsInfinityOrNaN(运行YIsInfinityOrNaN时具有硬件加速的类型).
- YIsInfinity_AcceleratedTypes
Types with hardware acceleration when running
YIsInfinity(运行YIsInfinity时具有硬件加速的类型).
- YIsInteger_AcceleratedTypes
Types with hardware acceleration when running
YIsInteger(运行YIsInteger时具有硬件加速的类型).
- YIsNaN_AcceleratedTypes
Types with hardware acceleration when running
YIsNaN(运行YIsNaN时具有硬件加速的类型).
- YIsNegativeInfinity_AcceleratedTypes
Types with hardware acceleration when running
YIsNegativeInfinity(运行YIsNegativeInfinity时具有硬件加速的类型).
- YIsNegativeZero_AcceleratedTypes
Types with hardware acceleration when running
YIsNegativeZero(运行YIsNegativeZero时具有硬件加速的类型).
- YIsNegative_AcceleratedTypes
Types with hardware acceleration when running
YIsNegative(运行YIsNegative时具有硬件加速的类型).
- YIsNormal_AcceleratedTypes
Types with hardware acceleration when running
YIsNormal(运行YIsNormal时具有硬件加速的类型).
- YIsNotEquals_AcceleratedTypes
Types with hardware acceleration when running
YIsNotEquals(运行YIsNotEquals时具有硬件加速的类型).
- YIsNotNaN_AcceleratedTypes
Types with hardware acceleration when running
YIsNotNaN(运行YIsNotNaN时具有硬件加速的类型).
- YIsOddInteger_AcceleratedTypes
Types with hardware acceleration when running
YIsOddInteger(运行YIsOddInteger时具有硬件加速的类型).
- YIsPositiveInfinity_AcceleratedTypes
Types with hardware acceleration when running
YIsPositiveInfinity(运行YIsPositiveInfinity时具有硬件加速的类型).
- YIsPositive_AcceleratedTypes
Types with hardware acceleration when running
YIsPositive(运行YIsPositive时具有硬件加速的类型).
- YIsSubnormal_AcceleratedTypes
Types with hardware acceleration when running
YIsSubnormal(运行YIsSubnormal时具有硬件加速的类型).
- YIsZeroOrSubnormal_AcceleratedTypes
Types with hardware acceleration when running
YIsZeroOrSubnormal(运行YIsZeroOrSubnormal时具有硬件加速的类型).
- YIsZero_AcceleratedTypes
Types with hardware acceleration when running
YIsZero(运行YIsZero时具有硬件加速的类型).
- YMaxNumber_AcceleratedTypes
Types with hardware acceleration when running
YMaxNumber(运行YMaxNumber时具有硬件加速的类型).
- YMinNumber_AcceleratedTypes
Types with hardware acceleration when running
YMinNumber(运行YMinNumber时具有硬件加速的类型).
- YNarrowSaturateUnsigned_AcceleratedTypes
Types with hardware acceleration when running
YNarrowSaturateUnsigned(运行YNarrowSaturateUnsigned时具有硬件加速的类型).
- YNarrowSaturateUnsigned_FullAcceleratedTypes
Types with full hardware acceleration when running
YNarrowSaturateUnsigned(运行YNarrowSaturateUnsigned时具有完全硬件加速的类型).
- YNarrowSaturate_AcceleratedTypes
Types with hardware acceleration when running
YNarrowSaturate(运行YNarrowSaturate时具有硬件加速的类型).
- YNarrowSaturate_FullAcceleratedTypes
Types with full hardware acceleration when running
YNarrowSaturate(运行YNarrowSaturate时具有完全硬件加速的类型).
- YOrNot_AcceleratedTypes
Types with hardware acceleration when running
YOrNot(运行YOrNot时具有硬件加速的类型).
- YRoundToEven_AcceleratedTypes
Types with hardware acceleration when running
YRoundToEven(运行YRoundToEven时具有硬件加速的类型).
- YRoundToZero_AcceleratedTypes
Types with hardware acceleration when running
YRoundToZero(运行YRoundToZero时具有硬件加速的类型).
- YShuffleG2_AcceleratedTypes
Types with hardware acceleration when running
YShuffleG2(运行YShuffleG2时具有硬件加速的类型).
- YShuffleG4X2_AcceleratedTypes
Types with hardware acceleration when running
YShuffleG4X2(运行YShuffleG4X2时具有硬件加速的类型).
- YShuffleG4_AcceleratedTypes
Types with hardware acceleration when running
YShuffleG4(运行YShuffleG4时具有硬件加速的类型).
- YShuffleInsert_AcceleratedTypes
Types with hardware acceleration when running
YShuffleInsert(运行YShuffleInsert时具有硬件加速的类型).
- YShuffleKernel_AcceleratedTypes
Types with hardware acceleration when running
YShuffleKernel(运行Shuffle时具有硬件加速的类型).
- YShuffleX2Insert_AcceleratedTypes
Types with hardware acceleration when running
YShuffleX2Insert(运行YShuffleX2Insert时具有硬件加速的类型).
- YShuffleX2Kernel_AcceleratedTypes
Types with hardware acceleration when running
YShuffleX2Kernel(运行YShuffleX2Kernel时具有硬件加速的类型).
- YShuffleX2_AcceleratedTypes
Types with hardware acceleration when running
YShuffleX2(运行YShuffleX2时具有硬件加速的类型).
- YShuffleX3Insert_AcceleratedTypes
Types with hardware acceleration when running
YShuffleX3Insert(运行YShuffleX3Insert时具有硬件加速的类型).
- YShuffleX3Kernel_AcceleratedTypes
Types with hardware acceleration when running
YShuffleX3Kernel(运行YShuffleX3Kernel时具有硬件加速的类型).
- YShuffleX3_AcceleratedTypes
Types with hardware acceleration when running
YShuffleX3(运行YShuffleX3时具有硬件加速的类型).
- YShuffleX4Insert_AcceleratedTypes
Types with hardware acceleration when running
YShuffleX4Insert(运行YShuffleX4Insert时具有硬件加速的类型).
- YShuffleX4Kernel_AcceleratedTypes
Types with hardware acceleration when running
YShuffleX4Kernel(运行YShuffleX4Kernel时具有硬件加速的类型).
- YShuffleX4_AcceleratedTypes
Types with hardware acceleration when running
YShuffleX4(运行YShuffleX4时具有硬件加速的类型).
- YSignFloat_AcceleratedTypes
Types with hardware acceleration when running
YSignFloat(运行YSignFloat时具有硬件加速的类型).
- YSign_AcceleratedTypes
Types with hardware acceleration when running
YSign(运行YSign时具有硬件加速的类型).
Methods
- Add(Vector<byte>, Vector<byte>)
Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic:
rt[i] := left[i] + right[i].
- Add(Vector<double>, Vector<double>)
Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic:
rt[i] := left[i] + right[i].
- Add(Vector<short>, Vector<short>)
Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic:
rt[i] := left[i] + right[i].
- Add(Vector<int>, Vector<int>)
Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic:
rt[i] := left[i] + right[i].
- Add(Vector<long>, Vector<long>)
Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic:
rt[i] := left[i] + right[i].
- Add(Vector<sbyte>, Vector<sbyte>)
Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic:
rt[i] := left[i] + right[i].
- Add(Vector<float>, Vector<float>)
Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic:
rt[i] := left[i] + right[i].
- Add(Vector<ushort>, Vector<ushort>)
Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic:
rt[i] := left[i] + right[i].
- Add(Vector<uint>, Vector<uint>)
Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic:
rt[i] := left[i] + right[i].
- Add(Vector<ulong>, Vector<ulong>)
Adds two vectors to compute their sum (将两个向量相加来计算它们的和). Mnemonic:
rt[i] := left[i] + right[i].
- Ceiling(Vector<double>)
Computes the ceiling of each element in a vector (计算向量中每个元素的向上取整). It is also known as round to positive infinity (它也被称作向正无穷舍入). See more: ToPositiveInfinity. Mnemonic:
rt[i] := ceiling(value[i]).
- Ceiling(Vector<float>)
Computes the ceiling of each element in a vector (计算向量中每个元素的向上取整). It is also known as round to positive infinity (它也被称作向正无穷舍入). See more: ToPositiveInfinity. Mnemonic:
rt[i] := ceiling(value[i]).
- ConvertToDouble(Vector<long>)
Convert to a vector whose elements are of type Double (转换为元素类型是Double的向量).. Mnemonic:
rt[i] := (Double)(value[i]).
- ConvertToDouble(Vector<ulong>)
Convert to a vector whose elements are of type Double (转换为元素类型是Double的向量).. Mnemonic:
rt[i] := (Double)(value[i]).
- ConvertToDouble_Range52(Vector<long>)
Convert to a vector whose elements are of type Double (转换为元素类型是Double的向量). Works for inputs in the range: [-2^51, 2^51). Mnemonic:
rt[i] := (Double)(value[i]).
- ConvertToDouble_Range52(Vector<ulong>)
Convert to a vector whose elements are of type Double (转换为元素类型是Double的向量). Works for inputs in the range: [0, 2^52). Mnemonic:
rt[i] := (Double)(value[i]).
- ConvertToInt32(Vector<float>)
Convert to a vector whose elements are of type Int32 (转换为元素类型是Int32的向量).. Mnemonic:
rt[i] := (Int32)(value[i]).
- ConvertToInt64(Vector<double>)
Convert to a vector whose elements are of type Int64, rounding mode is truncate(round to zero) (转换为元素类型是Int64的向量, 舍入模式为截断(舍入到零)). Mnemonic:
rt[i] := (Int64)(value[i]).
- ConvertToInt64_Range52(Vector<double>)
Convert to a vector whose elements are of type Int64, rounding mode is truncate(round to zero) (转换为元素类型是Int64的向量, 舍入模式为截断(舍入到零)). Works for inputs in the range: [-2^51, 2^51). Mnemonic:
rt[i] := (Int64)(value[i]).
- ConvertToInt64_Range52RoundToEven(Vector<double>)
Convert to a vector whose elements are of type Int64, rounding mode is round to even(round to nearest integer) (转换为元素类型是Int64的向量, 舍入模式为舍入到偶数(舍入到最近整数)). Works for inputs in the range: [-2^51, 2^51). Mnemonic:
rt[i] := (Int64)(round_to_even(value[i])).
- ConvertToSingle(Vector<int>)
Convert to a vector whose elements are of type Single (转换为元素类型是Single的向量).. Mnemonic:
rt[i] := (Single)(value[i]).
- ConvertToSingle(Vector<uint>)
Convert to a vector whose elements are of type Single (转换为元素类型是Single的向量).. Mnemonic:
rt[i] := (Single)(value[i]).
- ConvertToUInt32(Vector<float>)
Convert to a vector whose elements are of type UInt32 (转换为元素类型是UInt32的向量).. Mnemonic:
rt[i] := (UInt32)(value[i]).
- ConvertToUInt64(Vector<double>)
Convert to a vector whose elements are of type UInt64, rounding mode is truncate(round to zero) (转换为元素类型是UInt64的向量, 舍入模式为截断(舍入到零)). Mnemonic:
rt[i] := (UInt64)(value[i]).
- ConvertToUInt64_Range52(Vector<double>)
Convert to a vector whose elements are of type UInt64, rounding mode is truncate(round to zero) (转换为元素类型是UInt64的向量, 舍入模式为截断(舍入到零)). Works for inputs in the range: [0, 2^52). Mnemonic:
rt[i] := (UInt64)(value[i]).
- ConvertToUInt64_Range52RoundToEven(Vector<double>)
Convert to a vector whose elements are of type UInt64, rounding mode is round to even(round to nearest integer) (转换为元素类型是UInt64的向量, 舍入模式为舍入到偶数(舍入到最近整数)). Works for inputs in the range: [0, 2^52). Mnemonic:
rt[i] := (UInt64)(round_to_even(value[i])).
- Dot(Vector<byte>, Vector<byte>)
Computes the dot product of two vectors (计算两个向量的点积). Mnemonic:
rt := left[0]*right[0] + left[1]*right[1] + left[2]*right[2] + ... + left[Count-1]*right[Count-1].
- Dot(Vector<double>, Vector<double>)
Computes the dot product of two vectors (计算两个向量的点积). Mnemonic:
rt := left[0]*right[0] + left[1]*right[1] + left[2]*right[2] + ... + left[Count-1]*right[Count-1].
- Dot(Vector<short>, Vector<short>)
Computes the dot product of two vectors (计算两个向量的点积). Mnemonic:
rt := left[0]*right[0] + left[1]*right[1] + left[2]*right[2] + ... + left[Count-1]*right[Count-1].
- Dot(Vector<int>, Vector<int>)
Computes the dot product of two vectors (计算两个向量的点积). Mnemonic:
rt := left[0]*right[0] + left[1]*right[1] + left[2]*right[2] + ... + left[Count-1]*right[Count-1].
- Dot(Vector<long>, Vector<long>)
Computes the dot product of two vectors (计算两个向量的点积). Mnemonic:
rt := left[0]*right[0] + left[1]*right[1] + left[2]*right[2] + ... + left[Count-1]*right[Count-1].
- Dot(Vector<sbyte>, Vector<sbyte>)
Computes the dot product of two vectors (计算两个向量的点积). Mnemonic:
rt := left[0]*right[0] + left[1]*right[1] + left[2]*right[2] + ... + left[Count-1]*right[Count-1].
- Dot(Vector<float>, Vector<float>)
Computes the dot product of two vectors (计算两个向量的点积). Mnemonic:
rt := left[0]*right[0] + left[1]*right[1] + left[2]*right[2] + ... + left[Count-1]*right[Count-1].
- Dot(Vector<ushort>, Vector<ushort>)
Computes the dot product of two vectors (计算两个向量的点积). Mnemonic:
rt := left[0]*right[0] + left[1]*right[1] + left[2]*right[2] + ... + left[Count-1]*right[Count-1].
- Dot(Vector<uint>, Vector<uint>)
Computes the dot product of two vectors (计算两个向量的点积). Mnemonic:
rt := left[0]*right[0] + left[1]*right[1] + left[2]*right[2] + ... + left[Count-1]*right[Count-1].
- Dot(Vector<ulong>, Vector<ulong>)
Computes the dot product of two vectors (计算两个向量的点积). Mnemonic:
rt := left[0]*right[0] + left[1]*right[1] + left[2]*right[2] + ... + left[Count-1]*right[Count-1].
- ExtractMostSignificantBits(Vector<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(Vector<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(Vector<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(Vector<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(Vector<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(Vector<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(Vector<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(Vector<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(Vector<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(Vector<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(Vector<double>)
Computes the floor of each element in a vector (计算向量中每个元素的向下取整). It is also known as round to negative infinity (它也被称作向负无穷舍入). See more: ToNegativeInfinity. Mnemonic:
rt[i] := floor(value[i]).
- Floor(Vector<float>)
Computes the floor of each element in a vector (计算向量中每个元素的向下取整). It is also known as round to negative infinity (它也被称作向负无穷舍入). See more: ToNegativeInfinity. Mnemonic:
rt[i] := floor(value[i]).
- GetBaseInstance()
Get base instance.
- GetBestInstance()
Get best instance.
- GetIsSupported(bool)
Gets it is support the run (取得它是否支持运行).
- GetUnsupportedMessage(bool)
Get unsupported messages (取得不支持时的消息).
- Multiply(Vector<byte>, Vector<byte>)
Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic:
rt[i] := left[i] * right[i].
- Multiply(Vector<double>, Vector<double>)
Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic:
rt[i] := left[i] * right[i].
- Multiply(Vector<short>, Vector<short>)
Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic:
rt[i] := left[i] * right[i].
- Multiply(Vector<int>, Vector<int>)
Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic:
rt[i] := left[i] * right[i].
- Multiply(Vector<long>, Vector<long>)
Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic:
rt[i] := left[i] * right[i].
- Multiply(Vector<sbyte>, Vector<sbyte>)
Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic:
rt[i] := left[i] * right[i].
- Multiply(Vector<float>, Vector<float>)
Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic:
rt[i] := left[i] * right[i].
- Multiply(Vector<ushort>, Vector<ushort>)
Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic:
rt[i] := left[i] * right[i].
- Multiply(Vector<uint>, Vector<uint>)
Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic:
rt[i] := left[i] * right[i].
- Multiply(Vector<ulong>, Vector<ulong>)
Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic:
rt[i] := left[i] * right[i].
- Narrow(Vector<double>, Vector<double>)
Narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例缩窄为一个 Vector<T> ). />. Mnemonic:
rt[i] := narrow(element_ref(i, lower, upper)).
- Narrow(Vector<short>, Vector<short>)
Narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例缩窄为一个 Vector<T> ). />. Mnemonic:
rt[i] := narrow(element_ref(i, lower, upper)).
- Narrow(Vector<int>, Vector<int>)
Narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例缩窄为一个 Vector<T> ). />. Mnemonic:
rt[i] := narrow(element_ref(i, lower, upper)).
- Narrow(Vector<long>, Vector<long>)
Narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例缩窄为一个 Vector<T> ). />. Mnemonic:
rt[i] := narrow(element_ref(i, lower, upper)).
- Narrow(Vector<ushort>, Vector<ushort>)
Narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例缩窄为一个 Vector<T> ). />. Mnemonic:
rt[i] := narrow(element_ref(i, lower, upper)).
- Narrow(Vector<uint>, Vector<uint>)
Narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例缩窄为一个 Vector<T> ). />. Mnemonic:
rt[i] := narrow(element_ref(i, lower, upper)).
- Narrow(Vector<ulong>, Vector<ulong>)
Narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例缩窄为一个 Vector<T> ). />. Mnemonic:
rt[i] := narrow(element_ref(i, lower, upper)).
- ShiftLeft(Vector<byte>, int)
Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft(Vector<short>, int)
Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft(Vector<int>, int)
Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft(Vector<long>, int)
Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft(Vector<sbyte>, int)
Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft(Vector<ushort>, int)
Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft(Vector<uint>, int)
Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft(Vector<ulong>, int)
Shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Args(Vector<byte>, int, out Vector<byte>)
Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Args(Vector<short>, int, out Vector<short>)
Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Args(Vector<int>, int, out Vector<int>)
Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Args(Vector<long>, int, out Vector<long>)
Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Args(Vector<sbyte>, int, out Vector<sbyte>)
Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Args(Vector<ushort>, int, out Vector<ushort>)
Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Args(Vector<uint>, int, out Vector<uint>)
Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Args(Vector<ulong>, int, out Vector<ulong>)
Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Const(Vector<byte>, int)
Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_Const(Vector<short>, int)
Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_Const(Vector<int>, int)
Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_Const(Vector<long>, int)
Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_Const(Vector<sbyte>, int)
Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_Const(Vector<ushort>, int)
Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_Const(Vector<uint>, int)
Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_Const(Vector<ulong>, int)
Shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量 - 常量). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_ConstCore(Vector<byte>, int, Vector<byte>, Vector<byte>)
Core calculation for shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量的核心计算 - 常量). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_ConstCore(Vector<short>, int, Vector<short>, Vector<short>)
Core calculation for shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量的核心计算 - 常量). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_ConstCore(Vector<int>, int, Vector<int>, Vector<int>)
Core calculation for shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量的核心计算 - 常量). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_ConstCore(Vector<long>, int, Vector<long>, Vector<long>)
Core calculation for shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量的核心计算 - 常量). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_ConstCore(Vector<sbyte>, int, Vector<sbyte>, Vector<sbyte>)
Core calculation for shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量的核心计算 - 常量). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_ConstCore(Vector<ushort>, int, Vector<ushort>, Vector<ushort>)
Core calculation for shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量的核心计算 - 常量). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_ConstCore(Vector<uint>, int, Vector<uint>, Vector<uint>)
Core calculation for shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量的核心计算 - 常量). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_ConstCore(Vector<ulong>, int, Vector<ulong>, Vector<ulong>)
Core calculation for shifts each element of a vector left by the specified amount - Const (将向量的每个元素左移指定量的核心计算 - 常量). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic:
rt[i] := value[i] << shiftAmount.
- ShiftLeft_Core(Vector<byte>, int, Vector<byte>, Vector<byte>)
Core calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的核心计算). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Core(Vector<short>, int, Vector<short>, Vector<short>)
Core calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的核心计算). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Core(Vector<short>, Vector<short>, Vector<short>)
Core calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的核心计算). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Core(Vector<int>, int, Vector<int>, Vector<int>)
Core calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的核心计算). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Core(Vector<long>, int, Vector<long>, Vector<long>)
Core calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的核心计算). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Core(Vector<sbyte>, int, Vector<sbyte>, Vector<sbyte>)
Core calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的核心计算). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Core(Vector<ushort>, int, Vector<ushort>, Vector<ushort>)
Core calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的核心计算). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Core(Vector<uint>, int, Vector<uint>, Vector<uint>)
Core calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的核心计算). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Core(Vector<ulong>, int, Vector<ulong>, Vector<ulong>)
Core calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的核心计算). Its arguments are derived from ShiftLeft_Args (其参数来源于 ShiftLeft_Args). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Fast(Vector<byte>, int)
Shifts each element of a vector left by the specified amount - Fast (将向量的每个元素左移指定量 - 快速). No check
shiftAmount, please use LimitShiftAmount<T>(int) first. Mnemonic:rt[i] := value[i] << shiftAmount.
- ShiftLeft_Fast(Vector<short>, int)
Shifts each element of a vector left by the specified amount - Fast (将向量的每个元素左移指定量 - 快速). No check
shiftAmount, please use LimitShiftAmount<T>(int) first. Mnemonic:rt[i] := value[i] << shiftAmount.
- ShiftLeft_Fast(Vector<int>, int)
Shifts each element of a vector left by the specified amount - Fast (将向量的每个元素左移指定量 - 快速). No check
shiftAmount, please use LimitShiftAmount<T>(int) first. Mnemonic:rt[i] := value[i] << shiftAmount.
- ShiftLeft_Fast(Vector<long>, int)
Shifts each element of a vector left by the specified amount - Fast (将向量的每个元素左移指定量 - 快速). No check
shiftAmount, please use LimitShiftAmount<T>(int) first. Mnemonic:rt[i] := value[i] << shiftAmount.
- ShiftLeft_Fast(Vector<sbyte>, int)
Shifts each element of a vector left by the specified amount - Fast (将向量的每个元素左移指定量 - 快速). No check
shiftAmount, please use LimitShiftAmount<T>(int) first. Mnemonic:rt[i] := value[i] << shiftAmount.
- ShiftLeft_Fast(Vector<ushort>, int)
Shifts each element of a vector left by the specified amount - Fast (将向量的每个元素左移指定量 - 快速). No check
shiftAmount, please use LimitShiftAmount<T>(int) first. Mnemonic:rt[i] := value[i] << shiftAmount.
- ShiftLeft_Fast(Vector<uint>, int)
Shifts each element of a vector left by the specified amount - Fast (将向量的每个元素左移指定量 - 快速). No check
shiftAmount, please use LimitShiftAmount<T>(int) first. Mnemonic:rt[i] := value[i] << shiftAmount.
- ShiftLeft_Fast(Vector<ulong>, int)
Shifts each element of a vector left by the specified amount - Fast (将向量的每个元素左移指定量 - 快速). No check
shiftAmount, please use LimitShiftAmount<T>(int) first. Mnemonic:rt[i] := value[i] << shiftAmount.
- ShiftRightArithmetic(Vector<short>, int)
Shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量). Mnemonic:
rt[i] := value[i] >> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightArithmetic(Vector<int>, int)
Shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量). Mnemonic:
rt[i] := value[i] >> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightArithmetic(Vector<long>, int)
Shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量). Mnemonic:
rt[i] := value[i] >> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightArithmetic(Vector<sbyte>, int)
Shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量). Mnemonic:
rt[i] := value[i] >> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightArithmetic_Args(Vector<short>, int, out Vector<short>)
Arguments calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的参数计算). Provide arguments for ShiftRightArithmetic_Core (为 ShiftRightArithmetic_Core 提供参数). Mnemonic:
rt[i] := value[i] >> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightArithmetic_Args(Vector<int>, int, out Vector<int>)
Arguments calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的参数计算). Provide arguments for ShiftRightArithmetic_Core (为 ShiftRightArithmetic_Core 提供参数). Mnemonic:
rt[i] := value[i] >> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightArithmetic_Args(Vector<long>, int, out Vector<long>)
Arguments calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的参数计算). Provide arguments for ShiftRightArithmetic_Core (为 ShiftRightArithmetic_Core 提供参数). Mnemonic:
rt[i] := value[i] >> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightArithmetic_Args(Vector<sbyte>, int, out Vector<sbyte>)
Arguments calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的参数计算). Provide arguments for ShiftRightArithmetic_Core (为 ShiftRightArithmetic_Core 提供参数). Mnemonic:
rt[i] := value[i] >> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightArithmetic_Const(Vector<short>, int)
Shifts (signed) each element of a vector right by the specified amount - Const(将向量的每个有符号元素算术右移指定量 - 常量). Mnemonic:
rt[i] := value[i] >> shiftAmount.
- ShiftRightArithmetic_Const(Vector<int>, int)
Shifts (signed) each element of a vector right by the specified amount - Const(将向量的每个有符号元素算术右移指定量 - 常量). Mnemonic:
rt[i] := value[i] >> shiftAmount.
- ShiftRightArithmetic_Const(Vector<long>, int)
Shifts (signed) each element of a vector right by the specified amount - Const(将向量的每个有符号元素算术右移指定量 - 常量). Mnemonic:
rt[i] := value[i] >> shiftAmount.
- ShiftRightArithmetic_Const(Vector<sbyte>, int)
Shifts (signed) each element of a vector right by the specified amount - Const(将向量的每个有符号元素算术右移指定量 - 常量). Mnemonic:
rt[i] := value[i] >> shiftAmount.
- ShiftRightArithmetic_ConstCore(Vector<short>, int, Vector<short>, Vector<short>)
Core calculation for shifts (signed) each element of a vector right by the specified amount - Const (将向量的每个有符号元素算术右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightArithmetic_Args (其参数来源于 ShiftRightArithmetic_Args). Mnemonic:
rt[i] := value[i] >> shiftAmount.
- ShiftRightArithmetic_ConstCore(Vector<int>, int, Vector<int>, Vector<int>)
Core calculation for shifts (signed) each element of a vector right by the specified amount - Const (将向量的每个有符号元素算术右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightArithmetic_Args (其参数来源于 ShiftRightArithmetic_Args). Mnemonic:
rt[i] := value[i] >> shiftAmount.
- ShiftRightArithmetic_ConstCore(Vector<long>, int, Vector<long>, Vector<long>)
Core calculation for shifts (signed) each element of a vector right by the specified amount - Const (将向量的每个有符号元素算术右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightArithmetic_Args (其参数来源于 ShiftRightArithmetic_Args). Mnemonic:
rt[i] := value[i] >> shiftAmount.
- ShiftRightArithmetic_ConstCore(Vector<sbyte>, int, Vector<sbyte>, Vector<sbyte>)
Core calculation for shifts (signed) each element of a vector right by the specified amount - Const (将向量的每个有符号元素算术右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightArithmetic_Args (其参数来源于 ShiftRightArithmetic_Args). Mnemonic:
rt[i] := value[i] >> shiftAmount.
- ShiftRightArithmetic_Core(Vector<short>, int, Vector<short>, Vector<short>)
Core calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的核心计算). Its arguments are derived from ShiftRightArithmetic_Args (其参数来源于 ShiftRightArithmetic_Args). Mnemonic:
rt[i] := value[i] >> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightArithmetic_Core(Vector<int>, int, Vector<int>, Vector<int>)
Core calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的核心计算). Its arguments are derived from ShiftRightArithmetic_Args (其参数来源于 ShiftRightArithmetic_Args). Mnemonic:
rt[i] := value[i] >> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightArithmetic_Core(Vector<long>, int, Vector<long>, Vector<long>)
Core calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的核心计算). Its arguments are derived from ShiftRightArithmetic_Args (其参数来源于 ShiftRightArithmetic_Args). Mnemonic:
rt[i] := value[i] >> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightArithmetic_Core(Vector<sbyte>, int, Vector<sbyte>, Vector<sbyte>)
Core calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的核心计算). Its arguments are derived from ShiftRightArithmetic_Args (其参数来源于 ShiftRightArithmetic_Args). Mnemonic:
rt[i] := value[i] >> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightArithmetic_Fast(Vector<short>, int)
Shifts (signed) each element of a vector right by the specified amount - Fast(将向量的每个有符号元素算术右移指定量 - 快速). No check
shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic:rt[i] := value[i] >> shiftAmount.
- ShiftRightArithmetic_Fast(Vector<int>, int)
Shifts (signed) each element of a vector right by the specified amount - Fast(将向量的每个有符号元素算术右移指定量 - 快速). No check
shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic:rt[i] := value[i] >> shiftAmount.
- ShiftRightArithmetic_Fast(Vector<long>, int)
Shifts (signed) each element of a vector right by the specified amount - Fast(将向量的每个有符号元素算术右移指定量 - 快速). No check
shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic:rt[i] := value[i] >> shiftAmount.
- ShiftRightArithmetic_Fast(Vector<sbyte>, int)
Shifts (signed) each element of a vector right by the specified amount - Fast(将向量的每个有符号元素算术右移指定量 - 快速). No check
shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic:rt[i] := value[i] >> shiftAmount.
- ShiftRightLogical(Vector<byte>, int)
Shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical(Vector<short>, int)
Shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical(Vector<int>, int)
Shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical(Vector<long>, int)
Shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical(Vector<sbyte>, int)
Shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical(Vector<ushort>, int)
Shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical(Vector<uint>, int)
Shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical(Vector<ulong>, int)
Shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Args(Vector<byte>, int, out Vector<byte>)
Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Args(Vector<short>, int, out Vector<short>)
Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Args(Vector<int>, int, out Vector<int>)
Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Args(Vector<long>, int, out Vector<long>)
Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Args(Vector<sbyte>, int, out Vector<sbyte>)
Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Args(Vector<ushort>, int, out Vector<ushort>)
Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Args(Vector<uint>, int, out Vector<uint>)
Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Args(Vector<ulong>, int, out Vector<ulong>)
Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Const(Vector<byte>, int)
Shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量 - 常量). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Const(Vector<short>, int)
Shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量 - 常量). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Const(Vector<int>, int)
Shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量 - 常量). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Const(Vector<long>, int)
Shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量 - 常量). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Const(Vector<sbyte>, int)
Shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量 - 常量). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Const(Vector<ushort>, int)
Shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量 - 常量). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Const(Vector<uint>, int)
Shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量 - 常量). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Const(Vector<ulong>, int)
Shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量 - 常量). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_ConstCore(Vector<byte>, int, Vector<byte>, Vector<byte>)
Core calculation for shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic:
rt[i] := value[i] >>> shiftAmount.
- ShiftRightLogical_ConstCore(Vector<short>, int, Vector<short>, Vector<short>)
Core calculation for shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic:
rt[i] := value[i] >>> shiftAmount.
- ShiftRightLogical_ConstCore(Vector<int>, int, Vector<int>, Vector<int>)
Core calculation for shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic:
rt[i] := value[i] >>> shiftAmount.
- ShiftRightLogical_ConstCore(Vector<long>, int, Vector<long>, Vector<long>)
Core calculation for shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic:
rt[i] := value[i] >>> shiftAmount.
- ShiftRightLogical_ConstCore(Vector<sbyte>, int, Vector<sbyte>, Vector<sbyte>)
Core calculation for shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic:
rt[i] := value[i] >>> shiftAmount.
- ShiftRightLogical_ConstCore(Vector<ushort>, int, Vector<ushort>, Vector<ushort>)
Core calculation for shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic:
rt[i] := value[i] >>> shiftAmount.
- ShiftRightLogical_ConstCore(Vector<uint>, int, Vector<uint>, Vector<uint>)
Core calculation for shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic:
rt[i] := value[i] >>> shiftAmount.
- ShiftRightLogical_ConstCore(Vector<ulong>, int, Vector<ulong>, Vector<ulong>)
Core calculation for shifts (unsigned) each element of a vector right by the specified amount - Const (将向量的每个无符号元素逻辑右移指定量的核心计算 - 常量). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic:
rt[i] := value[i] >>> shiftAmount.
- ShiftRightLogical_Core(Vector<byte>, int, Vector<byte>, Vector<byte>)
Core calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的核心计算). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Core(Vector<short>, int, Vector<short>, Vector<short>)
Core calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的核心计算). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Core(Vector<int>, int, Vector<int>, Vector<int>)
Core calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的核心计算). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Core(Vector<long>, int, Vector<long>, Vector<long>)
Core calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的核心计算). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Core(Vector<sbyte>, int, Vector<sbyte>, Vector<sbyte>)
Core calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的核心计算). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Core(Vector<ushort>, int, Vector<ushort>, Vector<ushort>)
Core calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的核心计算). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Core(Vector<uint>, int, Vector<uint>, Vector<uint>)
Core calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的核心计算). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Core(Vector<ulong>, int, Vector<ulong>, Vector<ulong>)
Core calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的核心计算). Its arguments are derived from ShiftRightLogical_Args (其参数来源于 ShiftRightLogical_Args). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Fast(Vector<byte>, int)
Shifts (unsigned) each element of a vector right by the specified amount. - Fast(将向量的每个无符号元素逻辑右移指定量 - 快速). No check
shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic:rt[i] := value[i] >>> shiftAmount.
- ShiftRightLogical_Fast(Vector<short>, int)
Shifts (unsigned) each element of a vector right by the specified amount. - Fast(将向量的每个无符号元素逻辑右移指定量 - 快速). No check
shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic:rt[i] := value[i] >>> shiftAmount.
- ShiftRightLogical_Fast(Vector<int>, int)
Shifts (unsigned) each element of a vector right by the specified amount. - Fast(将向量的每个无符号元素逻辑右移指定量 - 快速). No check
shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic:rt[i] := value[i] >>> shiftAmount.
- ShiftRightLogical_Fast(Vector<long>, int)
Shifts (unsigned) each element of a vector right by the specified amount. - Fast(将向量的每个无符号元素逻辑右移指定量 - 快速). No check
shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic:rt[i] := value[i] >>> shiftAmount.
- ShiftRightLogical_Fast(Vector<sbyte>, int)
Shifts (unsigned) each element of a vector right by the specified amount. - Fast(将向量的每个无符号元素逻辑右移指定量 - 快速). No check
shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic:rt[i] := value[i] >>> shiftAmount.
- ShiftRightLogical_Fast(Vector<ushort>, int)
Shifts (unsigned) each element of a vector right by the specified amount. - Fast(将向量的每个无符号元素逻辑右移指定量 - 快速). No check
shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic:rt[i] := value[i] >>> shiftAmount.
- ShiftRightLogical_Fast(Vector<uint>, int)
Shifts (unsigned) each element of a vector right by the specified amount. - Fast(将向量的每个无符号元素逻辑右移指定量 - 快速). No check
shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic:rt[i] := value[i] >>> shiftAmount.
- ShiftRightLogical_Fast(Vector<ulong>, int)
Shifts (unsigned) each element of a vector right by the specified amount. - Fast(将向量的每个无符号元素逻辑右移指定量 - 快速). No check
shiftAmount, please use LimitShiftAmount<T>(int) first, and shiftAmount must not be 0 . Mnemonic:rt[i] := value[i] >>> shiftAmount.
- Shuffle(Vector<byte>, Vector<byte>)
Shuffle and clear (换位并清零). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle(Vector<double>, Vector<long>)
Shuffle and clear (换位并清零). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle(Vector<short>, Vector<short>)
Shuffle and clear (换位并清零). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle(Vector<int>, Vector<int>)
Shuffle and clear (换位并清零). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle(Vector<long>, Vector<long>)
Shuffle and clear (换位并清零). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle(Vector<sbyte>, Vector<sbyte>)
Shuffle and clear (换位并清零). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle(Vector<float>, Vector<int>)
Shuffle and clear (换位并清零). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle(Vector<ushort>, Vector<ushort>)
Shuffle and clear (换位并清零). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle(Vector<uint>, Vector<uint>)
Shuffle and clear (换位并清零). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle(Vector<ulong>, Vector<ulong>)
Shuffle and clear (换位并清零). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Args(Vector<byte>, out Vector<byte>, out Vector<byte>)
Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Args(Vector<short>, out Vector<short>, out Vector<short>)
Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Args(Vector<int>, out Vector<int>, out Vector<int>)
Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Args(Vector<long>, out Vector<long>, out Vector<long>)
Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Args(Vector<uint>, out Vector<uint>, out Vector<uint>)
Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Core(Vector<byte>, Vector<byte>, Vector<byte>)
Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Core(Vector<double>, Vector<long>, Vector<long>)
Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Core(Vector<short>, Vector<short>, Vector<short>)
Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Core(Vector<int>, Vector<int>, Vector<int>)
Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Core(Vector<long>, Vector<long>, Vector<long>)
Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Core(Vector<float>, Vector<int>, Vector<int>)
Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>)
Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Core(Vector<uint>, Vector<uint>, Vector<uint>)
Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>)
Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Sqrt(Vector<byte>)
Computes the square root of a vector on a per-element basis (计算向量中每个元素的平方根). Mnemonic:
rt[i] := sqrt(vector[i]) = pow(vector[i], 1.0/2). When x is less than 0, floating-point types return NaN, integer types return 0.
- Sqrt(Vector<double>)
Computes the square root of a vector on a per-element basis (计算向量中每个元素的平方根). Mnemonic:
rt[i] := sqrt(vector[i]) = pow(vector[i], 1.0/2). When x is less than 0, floating-point types return NaN, integer types return 0.
- Sqrt(Vector<short>)
Computes the square root of a vector on a per-element basis (计算向量中每个元素的平方根). Mnemonic:
rt[i] := sqrt(vector[i]) = pow(vector[i], 1.0/2). When x is less than 0, floating-point types return NaN, integer types return 0.
- Sqrt(Vector<int>)
Computes the square root of a vector on a per-element basis (计算向量中每个元素的平方根). Mnemonic:
rt[i] := sqrt(vector[i]) = pow(vector[i], 1.0/2). When x is less than 0, floating-point types return NaN, integer types return 0.
- Sqrt(Vector<long>)
Computes the square root of a vector on a per-element basis (计算向量中每个元素的平方根). Mnemonic:
rt[i] := sqrt(vector[i]) = pow(vector[i], 1.0/2). When x is less than 0, floating-point types return NaN, integer types return 0.
- Sqrt(Vector<sbyte>)
Computes the square root of a vector on a per-element basis (计算向量中每个元素的平方根). Mnemonic:
rt[i] := sqrt(vector[i]) = pow(vector[i], 1.0/2). When x is less than 0, floating-point types return NaN, integer types return 0.
- Sqrt(Vector<float>)
Computes the square root of a vector on a per-element basis (计算向量中每个元素的平方根). Mnemonic:
rt[i] := sqrt(vector[i]) = pow(vector[i], 1.0/2). When x is less than 0, floating-point types return NaN, integer types return 0.
- Sqrt(Vector<ushort>)
Computes the square root of a vector on a per-element basis (计算向量中每个元素的平方根). Mnemonic:
rt[i] := sqrt(vector[i]) = pow(vector[i], 1.0/2). When x is less than 0, floating-point types return NaN, integer types return 0.
- Sqrt(Vector<uint>)
Computes the square root of a vector on a per-element basis (计算向量中每个元素的平方根). Mnemonic:
rt[i] := sqrt(vector[i]) = pow(vector[i], 1.0/2). When x is less than 0, floating-point types return NaN, integer types return 0.
- Sqrt(Vector<ulong>)
Computes the square root of a vector on a per-element basis (计算向量中每个元素的平方根). Mnemonic:
rt[i] := sqrt(vector[i]) = pow(vector[i], 1.0/2). When x is less than 0, floating-point types return NaN, integer types return 0.
- Sum(Vector<byte>)
Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic:
rt := value[0] + value[1] + value[2] + ... + value[Count-1].
- Sum(Vector<double>)
Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic:
rt := value[0] + value[1] + value[2] + ... + value[Count-1].
- Sum(Vector<short>)
Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic:
rt := value[0] + value[1] + value[2] + ... + value[Count-1].
- Sum(Vector<int>)
Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic:
rt := value[0] + value[1] + value[2] + ... + value[Count-1].
- Sum(Vector<long>)
Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic:
rt := value[0] + value[1] + value[2] + ... + value[Count-1].
- Sum(Vector<sbyte>)
Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic:
rt := value[0] + value[1] + value[2] + ... + value[Count-1].
- Sum(Vector<float>)
Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic:
rt := value[0] + value[1] + value[2] + ... + value[Count-1].
- Sum(Vector<ushort>)
Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic:
rt := value[0] + value[1] + value[2] + ... + value[Count-1].
- Sum(Vector<uint>)
Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic:
rt := value[0] + value[1] + value[2] + ... + value[Count-1].
- Sum(Vector<ulong>)
Computes the sum of all elements in a vector (计算向量中所有元素的总和). Mnemonic:
rt := value[0] + value[1] + value[2] + ... + value[Count-1].
- ThrowForUnsupported(bool)
Throw exception when not supported. (当不支持时抛出异常).
- Widen(Vector<byte>, out Vector<ushort>, out Vector<ushort>)
Widens a Vector<T> into two Vector<T> instances (将一个 Vector<T> 扩宽为两个 Vector<T> 实例). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(Vector<short>, out Vector<int>, out Vector<int>)
Widens a Vector<T> into two Vector<T> instances (将一个 Vector<T> 扩宽为两个 Vector<T> 实例). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(Vector<int>, out Vector<long>, out Vector<long>)
Widens a Vector<T> into two Vector<T> instances (将一个 Vector<T> 扩宽为两个 Vector<T> 实例). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(Vector<sbyte>, out Vector<short>, out Vector<short>)
Widens a Vector<T> into two Vector<T> instances (将一个 Vector<T> 扩宽为两个 Vector<T> 实例). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(Vector<float>, out Vector<double>, out Vector<double>)
Widens a Vector<T> into two Vector<T> instances (将一个 Vector<T> 扩宽为两个 Vector<T> 实例). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(Vector<ushort>, out Vector<uint>, out Vector<uint>)
Widens a Vector<T> into two Vector<T> instances (将一个 Vector<T> 扩宽为两个 Vector<T> 实例). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(Vector<uint>, out Vector<ulong>, out Vector<ulong>)
Widens a Vector<T> into two Vector<T> instances (将一个 Vector<T> 扩宽为两个 Vector<T> 实例). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- WidenLower(Vector<byte>)
Widens the lower half of a Vector into a Vector (将向量的低半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenLower(Vector<short>)
Widens the lower half of a Vector into a Vector (将向量的低半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenLower(Vector<int>)
Widens the lower half of a Vector into a Vector (将向量的低半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenLower(Vector<sbyte>)
Widens the lower half of a Vector into a Vector (将向量的低半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenLower(Vector<float>)
Widens the lower half of a Vector into a Vector (将向量的低半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenLower(Vector<ushort>)
Widens the lower half of a Vector into a Vector (将向量的低半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenLower(Vector<uint>)
Widens the lower half of a Vector into a Vector (将向量的低半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenUpper(Vector<byte>)
Widens the upper half of a Vector into a Vector (将向量的高半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenUpper(Vector<short>)
Widens the upper half of a Vector into a Vector (将向量的高半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenUpper(Vector<int>)
Widens the upper half of a Vector into a Vector (将向量的高半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenUpper(Vector<sbyte>)
Widens the upper half of a Vector into a Vector (将向量的高半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenUpper(Vector<float>)
Widens the upper half of a Vector into a Vector (将向量的高半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenUpper(Vector<ushort>)
Widens the upper half of a Vector into a Vector (将向量的高半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- WidenUpper(Vector<uint>)
Widens the upper half of a Vector into a Vector (将向量的高半部分扩宽为一个向量). Mnemonic:
rt[i] := widen(source[i]).
- YBitToByte(ulong)
Converts binary bits to each element of the Byte vector (将各个二进制位转换为 Byte 向量的每个元素). Bit 0 meaning is 0, bit 1 meaning is 1 for all bits (MaxValue). Mnemonic:
rt[i] := to_mask(0 != ((mask>>i)&1)).
- YBitToInt16(ulong)
Converts binary bits to each element of the Int16 vector (将各个二进制位转换为 Int16 向量的每个元素). Bit 0 meaning is 0, bit 1 meaning is 1 for all bits (-1). Mnemonic:
rt[i] := to_mask(0 != ((mask>>i)&1)).
- YBitToInt32(ulong)
Converts binary bits to each element of the Int32 vector (将各个二进制位转换为 Int32 向量的每个元素). Bit 0 meaning is 0, bit 1 meaning is 1 for all bits (-1). Mnemonic:
rt[i] := to_mask(0 != ((mask>>i)&1)).
- YBitToInt64(ulong)
Converts binary bits to each element of the Int64 vector (将各个二进制位转换为 Int64 向量的每个元素). Bit 0 meaning is 0, bit 1 meaning is 1 for all bits (-1). Mnemonic:
rt[i] := to_mask(0 != ((mask>>i)&1)).
- YClamp(Vector<byte>, Vector<byte>, Vector<byte>)
Computes the numerical clamp of each element in a vector (计算向量中每个元素的数值限制). Mnemonic:
rt[i] := clamp(value[i], amin[i], amax[i]) = min(max(amin[i], value[i]), amax[i]).
- YClamp(Vector<double>, Vector<double>, Vector<double>)
Computes the numerical clamp of each element in a vector (计算向量中每个元素的数值限制). Mnemonic:
rt[i] := clamp(value[i], amin[i], amax[i]) = min(max(amin[i], value[i]), amax[i]).
- YClamp(Vector<short>, Vector<short>, Vector<short>)
Computes the numerical clamp of each element in a vector (计算向量中每个元素的数值限制). Mnemonic:
rt[i] := clamp(value[i], amin[i], amax[i]) = min(max(amin[i], value[i]), amax[i]).
- YClamp(Vector<int>, Vector<int>, Vector<int>)
Computes the numerical clamp of each element in a vector (计算向量中每个元素的数值限制). Mnemonic:
rt[i] := clamp(value[i], amin[i], amax[i]) = min(max(amin[i], value[i]), amax[i]).
- YClamp(Vector<long>, Vector<long>, Vector<long>)
Computes the numerical clamp of each element in a vector (计算向量中每个元素的数值限制). Mnemonic:
rt[i] := clamp(value[i], amin[i], amax[i]) = min(max(amin[i], value[i]), amax[i]).
- YClamp(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Computes the numerical clamp of each element in a vector (计算向量中每个元素的数值限制). Mnemonic:
rt[i] := clamp(value[i], amin[i], amax[i]) = min(max(amin[i], value[i]), amax[i]).
- YClamp(Vector<float>, Vector<float>, Vector<float>)
Computes the numerical clamp of each element in a vector (计算向量中每个元素的数值限制). Mnemonic:
rt[i] := clamp(value[i], amin[i], amax[i]) = min(max(amin[i], value[i]), amax[i]).
- YClamp(Vector<ushort>, Vector<ushort>, Vector<ushort>)
Computes the numerical clamp of each element in a vector (计算向量中每个元素的数值限制). Mnemonic:
rt[i] := clamp(value[i], amin[i], amax[i]) = min(max(amin[i], value[i]), amax[i]).
- YClamp(Vector<uint>, Vector<uint>, Vector<uint>)
Computes the numerical clamp of each element in a vector (计算向量中每个元素的数值限制). Mnemonic:
rt[i] := clamp(value[i], amin[i], amax[i]) = min(max(amin[i], value[i]), amax[i]).
- YClamp(Vector<ulong>, Vector<ulong>, Vector<ulong>)
Computes the numerical clamp of each element in a vector (计算向量中每个元素的数值限制). Mnemonic:
rt[i] := clamp(value[i], amin[i], amax[i]) = min(max(amin[i], value[i]), amax[i]).
- YCopySign(Vector<double>, Vector<double>)
Copies the sign of a value to the sign of another value (将一个值的符号复制到另一个值). Mnemonic:
rt[i] := copySign(value[i], sign[i]).
- YCopySign(Vector<short>, Vector<short>)
Copies the sign of a value to the sign of another value (将一个值的符号复制到另一个值). Mnemonic:
rt[i] := copySign(value[i], sign[i]).
- YCopySign(Vector<int>, Vector<int>)
Copies the sign of a value to the sign of another value (将一个值的符号复制到另一个值). Mnemonic:
rt[i] := copySign(value[i], sign[i]).
- YCopySign(Vector<long>, Vector<long>)
Copies the sign of a value to the sign of another value (将一个值的符号复制到另一个值). Mnemonic:
rt[i] := copySign(value[i], sign[i]).
- YCopySign(Vector<sbyte>, Vector<sbyte>)
Copies the sign of a value to the sign of another value (将一个值的符号复制到另一个值). Mnemonic:
rt[i] := copySign(value[i], sign[i]).
- YCopySign(Vector<float>, Vector<float>)
Copies the sign of a value to the sign of another value (将一个值的符号复制到另一个值). Mnemonic:
rt[i] := copySign(value[i], sign[i]).
- YGroup1ToGroup3(Vector<byte>, out Vector<byte>, out Vector<byte>)
Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(x, x, x). View for element:element_ref(i, result0, result1, result2) := x[i/3].
- YGroup1ToGroup3(Vector<double>, out Vector<double>, out Vector<double>)
Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(x, x, x). View for element:element_ref(i, result0, result1, result2) := x[i/3].
- YGroup1ToGroup3(Vector<short>, out Vector<short>, out Vector<short>)
Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(x, x, x). View for element:element_ref(i, result0, result1, result2) := x[i/3].
- YGroup1ToGroup3(Vector<int>, out Vector<int>, out Vector<int>)
Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(x, x, x). View for element:element_ref(i, result0, result1, result2) := x[i/3].
- YGroup1ToGroup3(Vector<long>, out Vector<long>, out Vector<long>)
Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(x, x, x). View for element:element_ref(i, result0, result1, result2) := x[i/3].
- YGroup1ToGroup3(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(x, x, x). View for element:element_ref(i, result0, result1, result2) := x[i/3].
- YGroup1ToGroup3(Vector<float>, out Vector<float>, out Vector<float>)
Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(x, x, x). View for element:element_ref(i, result0, result1, result2) := x[i/3].
- YGroup1ToGroup3(Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(x, x, x). View for element:element_ref(i, result0, result1, result2) := x[i/3].
- YGroup1ToGroup3(Vector<uint>, out Vector<uint>, out Vector<uint>)
Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(x, x, x). View for element:element_ref(i, result0, result1, result2) := x[i/3].
- YGroup1ToGroup3(Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(x, x, x). View for element:element_ref(i, result0, result1, result2) := x[i/3].
- YGroup1ToGroup4(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>)
Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element:element_ref(i, result0, result1, result2, result4) := x[i/4].
- YGroup1ToGroup4(Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>)
Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element:element_ref(i, result0, result1, result2, result4) := x[i/4].
- YGroup1ToGroup4(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>)
Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element:element_ref(i, result0, result1, result2, result4) := x[i/4].
- YGroup1ToGroup4(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>)
Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element:element_ref(i, result0, result1, result2, result4) := x[i/4].
- YGroup1ToGroup4(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>)
Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element:element_ref(i, result0, result1, result2, result4) := x[i/4].
- YGroup1ToGroup4(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element:element_ref(i, result0, result1, result2, result4) := x[i/4].
- YGroup1ToGroup4(Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>)
Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element:element_ref(i, result0, result1, result2, result4) := x[i/4].
- YGroup1ToGroup4(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element:element_ref(i, result0, result1, result2, result4) := x[i/4].
- YGroup1ToGroup4(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>)
Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element:element_ref(i, result0, result1, result2, result4) := x[i/4].
- YGroup1ToGroup4(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element:element_ref(i, result0, result1, result2, result4) := x[i/4].
- YGroup1ToGroup4WithW(Vector<byte>, Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>)
Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element:element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ),i2 := i/4.
- YGroup1ToGroup4WithW(Vector<double>, Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>)
Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element:element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ),i2 := i/4.
- YGroup1ToGroup4WithW(Vector<short>, Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>)
Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element:element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ),i2 := i/4.
- YGroup1ToGroup4WithW(Vector<int>, Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>)
Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element:element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ),i2 := i/4.
- YGroup1ToGroup4WithW(Vector<long>, Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>)
Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element:element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ),i2 := i/4.
- YGroup1ToGroup4WithW(Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element:element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ),i2 := i/4.
- YGroup1ToGroup4WithW(Vector<float>, Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>)
Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element:element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ),i2 := i/4.
- YGroup1ToGroup4WithW(Vector<ushort>, Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element:element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ),i2 := i/4.
- YGroup1ToGroup4WithW(Vector<uint>, Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>)
Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element:element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ),i2 := i/4.
- YGroup1ToGroup4WithW(Vector<ulong>, Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element:element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ),i2 := i/4.
- YGroup2Transpose(Vector<byte>, Vector<byte>, out Vector<byte>)
Transpose a 22 matrix (对22矩阵进行转置). Mnemonic:
result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ),result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2Transpose(Vector<double>, Vector<double>, out Vector<double>)
Transpose a 22 matrix (对22矩阵进行转置). Mnemonic:
result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ),result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2Transpose(Vector<short>, Vector<short>, out Vector<short>)
Transpose a 22 matrix (对22矩阵进行转置). Mnemonic:
result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ),result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2Transpose(Vector<int>, Vector<int>, out Vector<int>)
Transpose a 22 matrix (对22矩阵进行转置). Mnemonic:
result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ),result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2Transpose(Vector<long>, Vector<long>, out Vector<long>)
Transpose a 22 matrix (对22矩阵进行转置). Mnemonic:
result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ),result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2Transpose(Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>)
Transpose a 22 matrix (对22矩阵进行转置). Mnemonic:
result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ),result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2Transpose(Vector<float>, Vector<float>, out Vector<float>)
Transpose a 22 matrix (对22矩阵进行转置). Mnemonic:
result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ),result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2Transpose(Vector<ushort>, Vector<ushort>, out Vector<ushort>)
Transpose a 22 matrix (对22矩阵进行转置). Mnemonic:
result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ),result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2Transpose(Vector<uint>, Vector<uint>, out Vector<uint>)
Transpose a 22 matrix (对22矩阵进行转置). Mnemonic:
result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ),result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2Transpose(Vector<ulong>, Vector<ulong>, out Vector<ulong>)
Transpose a 22 matrix (对22矩阵进行转置). Mnemonic:
result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ),result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2TransposeEven(Vector<byte>, Vector<byte>)
Transpose a 22 matrix and return a data in even positions (对22矩阵进行转置, 并返回偶数位置的数据). Mnemonic:
rt[i] =: (0==(i&1))?( x[i&~1] ):( y[i&~1] ).
- YGroup2TransposeEven(Vector<double>, Vector<double>)
Transpose a 22 matrix and return a data in even positions (对22矩阵进行转置, 并返回偶数位置的数据). Mnemonic:
rt[i] =: (0==(i&1))?( x[i&~1] ):( y[i&~1] ).
- YGroup2TransposeEven(Vector<short>, Vector<short>)
Transpose a 22 matrix and return a data in even positions (对22矩阵进行转置, 并返回偶数位置的数据). Mnemonic:
rt[i] =: (0==(i&1))?( x[i&~1] ):( y[i&~1] ).
- YGroup2TransposeEven(Vector<int>, Vector<int>)
Transpose a 22 matrix and return a data in even positions (对22矩阵进行转置, 并返回偶数位置的数据). Mnemonic:
rt[i] =: (0==(i&1))?( x[i&~1] ):( y[i&~1] ).
- YGroup2TransposeEven(Vector<long>, Vector<long>)
Transpose a 22 matrix and return a data in even positions (对22矩阵进行转置, 并返回偶数位置的数据). Mnemonic:
rt[i] =: (0==(i&1))?( x[i&~1] ):( y[i&~1] ).
- YGroup2TransposeEven(Vector<sbyte>, Vector<sbyte>)
Transpose a 22 matrix and return a data in even positions (对22矩阵进行转置, 并返回偶数位置的数据). Mnemonic:
rt[i] =: (0==(i&1))?( x[i&~1] ):( y[i&~1] ).
- YGroup2TransposeEven(Vector<float>, Vector<float>)
Transpose a 22 matrix and return a data in even positions (对22矩阵进行转置, 并返回偶数位置的数据). Mnemonic:
rt[i] =: (0==(i&1))?( x[i&~1] ):( y[i&~1] ).
- YGroup2TransposeEven(Vector<ushort>, Vector<ushort>)
Transpose a 22 matrix and return a data in even positions (对22矩阵进行转置, 并返回偶数位置的数据). Mnemonic:
rt[i] =: (0==(i&1))?( x[i&~1] ):( y[i&~1] ).
- YGroup2TransposeEven(Vector<uint>, Vector<uint>)
Transpose a 22 matrix and return a data in even positions (对22矩阵进行转置, 并返回偶数位置的数据). Mnemonic:
rt[i] =: (0==(i&1))?( x[i&~1] ):( y[i&~1] ).
- YGroup2TransposeEven(Vector<ulong>, Vector<ulong>)
Transpose a 22 matrix and return a data in even positions (对22矩阵进行转置, 并返回偶数位置的数据). Mnemonic:
rt[i] =: (0==(i&1))?( x[i&~1] ):( y[i&~1] ).
- YGroup2TransposeOdd(Vector<byte>, Vector<byte>)
Transpose a 22 matrix and return a data in odd positions (对22矩阵进行转置, 并返回奇数位置的数据). Mnemonic:
rt[i] =: (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2TransposeOdd(Vector<double>, Vector<double>)
Transpose a 22 matrix and return a data in odd positions (对22矩阵进行转置, 并返回奇数位置的数据). Mnemonic:
rt[i] =: (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2TransposeOdd(Vector<short>, Vector<short>)
Transpose a 22 matrix and return a data in odd positions (对22矩阵进行转置, 并返回奇数位置的数据). Mnemonic:
rt[i] =: (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2TransposeOdd(Vector<int>, Vector<int>)
Transpose a 22 matrix and return a data in odd positions (对22矩阵进行转置, 并返回奇数位置的数据). Mnemonic:
rt[i] =: (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2TransposeOdd(Vector<long>, Vector<long>)
Transpose a 22 matrix and return a data in odd positions (对22矩阵进行转置, 并返回奇数位置的数据). Mnemonic:
rt[i] =: (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2TransposeOdd(Vector<sbyte>, Vector<sbyte>)
Transpose a 22 matrix and return a data in odd positions (对22矩阵进行转置, 并返回奇数位置的数据). Mnemonic:
rt[i] =: (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2TransposeOdd(Vector<float>, Vector<float>)
Transpose a 22 matrix and return a data in odd positions (对22矩阵进行转置, 并返回奇数位置的数据). Mnemonic:
rt[i] =: (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2TransposeOdd(Vector<ushort>, Vector<ushort>)
Transpose a 22 matrix and return a data in odd positions (对22矩阵进行转置, 并返回奇数位置的数据). Mnemonic:
rt[i] =: (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2TransposeOdd(Vector<uint>, Vector<uint>)
Transpose a 22 matrix and return a data in odd positions (对22矩阵进行转置, 并返回奇数位置的数据). Mnemonic:
rt[i] =: (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2TransposeOdd(Vector<ulong>, Vector<ulong>)
Transpose a 22 matrix and return a data in odd positions (对22矩阵进行转置, 并返回奇数位置的数据). Mnemonic:
rt[i] =: (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2Unzip(Vector<byte>, Vector<byte>, out Vector<byte>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(Vector<double>, Vector<double>, out Vector<double>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(Vector<short>, Vector<short>, out Vector<short>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(Vector<int>, Vector<int>, out Vector<int>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(Vector<long>, Vector<long>, out Vector<long>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(Vector<float>, Vector<float>, out Vector<float>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(Vector<ushort>, Vector<ushort>, out Vector<ushort>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(Vector<uint>, Vector<uint>, out Vector<uint>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(Vector<ulong>, Vector<ulong>, out Vector<ulong>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(Vector<ExInt128>, Vector<ExInt128>, out Vector<ExInt128>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(Vector<ExUInt128>, Vector<ExUInt128>, out Vector<ExUInt128>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2UnzipEven(Vector<byte>, Vector<byte>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i, data0, data1).
- YGroup2UnzipEven(Vector<double>, Vector<double>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i, data0, data1).
- YGroup2UnzipEven(Vector<short>, Vector<short>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i, data0, data1).
- YGroup2UnzipEven(Vector<int>, Vector<int>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i, data0, data1).
- YGroup2UnzipEven(Vector<long>, Vector<long>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i, data0, data1).
- YGroup2UnzipEven(Vector<sbyte>, Vector<sbyte>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i, data0, data1).
- YGroup2UnzipEven(Vector<float>, Vector<float>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i, data0, data1).
- YGroup2UnzipEven(Vector<ushort>, Vector<ushort>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i, data0, data1).
- YGroup2UnzipEven(Vector<uint>, Vector<uint>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i, data0, data1).
- YGroup2UnzipEven(Vector<ulong>, Vector<ulong>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i, data0, data1).
- YGroup2UnzipEven(Vector<ExInt128>, Vector<ExInt128>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i, data0, data1).
- YGroup2UnzipEven(Vector<ExUInt128>, Vector<ExUInt128>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i, data0, data1).
- YGroup2UnzipOdd(Vector<byte>, Vector<byte>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i+1, data0, data1).
- YGroup2UnzipOdd(Vector<double>, Vector<double>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i+1, data0, data1).
- YGroup2UnzipOdd(Vector<short>, Vector<short>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i+1, data0, data1).
- YGroup2UnzipOdd(Vector<int>, Vector<int>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i+1, data0, data1).
- YGroup2UnzipOdd(Vector<long>, Vector<long>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i+1, data0, data1).
- YGroup2UnzipOdd(Vector<sbyte>, Vector<sbyte>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i+1, data0, data1).
- YGroup2UnzipOdd(Vector<float>, Vector<float>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i+1, data0, data1).
- YGroup2UnzipOdd(Vector<ushort>, Vector<ushort>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i+1, data0, data1).
- YGroup2UnzipOdd(Vector<uint>, Vector<uint>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i+1, data0, data1).
- YGroup2UnzipOdd(Vector<ulong>, Vector<ulong>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i+1, data0, data1).
- YGroup2UnzipOdd(Vector<ExInt128>, Vector<ExInt128>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i+1, data0, data1).
- YGroup2UnzipOdd(Vector<ExUInt128>, Vector<ExUInt128>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i+1, data0, data1).
- YGroup2Unzip_Bit128<T>(Vector<T>, Vector<T>, out Vector<T>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). It is specialized for process 128-bit element (它专门用于处理128位元素). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Zip(Vector<byte>, Vector<byte>, out Vector<byte>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(Vector<double>, Vector<double>, out Vector<double>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(Vector<short>, Vector<short>, out Vector<short>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(Vector<int>, Vector<int>, out Vector<int>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(Vector<long>, Vector<long>, out Vector<long>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(Vector<float>, Vector<float>, out Vector<float>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(Vector<ushort>, Vector<ushort>, out Vector<ushort>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(Vector<uint>, Vector<uint>, out Vector<uint>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(Vector<ulong>, Vector<ulong>, out Vector<ulong>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(Vector<ExInt128>, Vector<ExInt128>, out Vector<ExInt128>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(Vector<ExUInt128>, Vector<ExUInt128>, out Vector<ExUInt128>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2ZipHigh(Vector<byte>, Vector<byte>)
Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := (i+T.Count)/2.
- YGroup2ZipHigh(Vector<double>, Vector<double>)
Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := (i+T.Count)/2.
- YGroup2ZipHigh(Vector<short>, Vector<short>)
Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := (i+T.Count)/2.
- YGroup2ZipHigh(Vector<int>, Vector<int>)
Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := (i+T.Count)/2.
- YGroup2ZipHigh(Vector<long>, Vector<long>)
Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := (i+T.Count)/2.
- YGroup2ZipHigh(Vector<sbyte>, Vector<sbyte>)
Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := (i+T.Count)/2.
- YGroup2ZipHigh(Vector<float>, Vector<float>)
Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := (i+T.Count)/2.
- YGroup2ZipHigh(Vector<ushort>, Vector<ushort>)
Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := (i+T.Count)/2.
- YGroup2ZipHigh(Vector<uint>, Vector<uint>)
Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := (i+T.Count)/2.
- YGroup2ZipHigh(Vector<ulong>, Vector<ulong>)
Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := (i+T.Count)/2.
- YGroup2ZipHigh(Vector<ExInt128>, Vector<ExInt128>)
Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := (i+T.Count)/2.
- YGroup2ZipHigh(Vector<ExUInt128>, Vector<ExUInt128>)
Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := (i+T.Count)/2.
- YGroup2ZipLow(Vector<byte>, Vector<byte>)
Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2ZipLow(Vector<double>, Vector<double>)
Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2ZipLow(Vector<short>, Vector<short>)
Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2ZipLow(Vector<int>, Vector<int>)
Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2ZipLow(Vector<long>, Vector<long>)
Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2ZipLow(Vector<sbyte>, Vector<sbyte>)
Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2ZipLow(Vector<float>, Vector<float>)
Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2ZipLow(Vector<ushort>, Vector<ushort>)
Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2ZipLow(Vector<uint>, Vector<uint>)
Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2ZipLow(Vector<ulong>, Vector<ulong>)
Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2ZipLow(Vector<ExInt128>, Vector<ExInt128>)
Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2ZipLow(Vector<ExUInt128>, Vector<ExUInt128>)
Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip_Bit128<T>(Vector<T>, Vector<T>, out Vector<T>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). It is specialized for process 128-bit element (它专门用于处理128位元素). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup3ToGroup4(Vector<byte>, Vector<byte>, Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>)
Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将 已打包的RGB像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element:element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.
- YGroup3ToGroup4(Vector<double>, Vector<double>, Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>)
Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将 已打包的RGB像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element:element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.
- YGroup3ToGroup4(Vector<short>, Vector<short>, Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>)
Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将 已打包的RGB像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element:element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.
- YGroup3ToGroup4(Vector<int>, Vector<int>, Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>)
Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将 已打包的RGB像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element:element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.
- YGroup3ToGroup4(Vector<long>, Vector<long>, Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>)
Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将 已打包的RGB像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element:element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.
- YGroup3ToGroup4(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将 已打包的RGB像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element:element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.
- YGroup3ToGroup4(Vector<float>, Vector<float>, Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>)
Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将 已打包的RGB像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element:element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.
- YGroup3ToGroup4(Vector<ushort>, Vector<ushort>, Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将 已打包的RGB像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element:element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.
- YGroup3ToGroup4(Vector<uint>, Vector<uint>, Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>)
Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将 已打包的RGB像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element:element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.
- YGroup3ToGroup4(Vector<ulong>, Vector<ulong>, Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将 已打包的RGB像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element:element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.
- YGroup3Unzip(Vector<byte>, Vector<byte>, Vector<byte>, out Vector<byte>, out Vector<byte>)
De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic:
x[i] =: element_ref(3i, data0, data1, data2),y[i] =: element_ref(3i+1, data0, data1, data2),z[i] =: element_ref(3*i+2, data0, data1, data2).
- YGroup3Unzip(Vector<double>, Vector<double>, Vector<double>, out Vector<double>, out Vector<double>)
De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic:
x[i] =: element_ref(3i, data0, data1, data2),y[i] =: element_ref(3i+1, data0, data1, data2),z[i] =: element_ref(3*i+2, data0, data1, data2).
- YGroup3Unzip(Vector<short>, Vector<short>, Vector<short>, out Vector<short>, out Vector<short>)
De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic:
x[i] =: element_ref(3i, data0, data1, data2),y[i] =: element_ref(3i+1, data0, data1, data2),z[i] =: element_ref(3*i+2, data0, data1, data2).
- YGroup3Unzip(Vector<int>, Vector<int>, Vector<int>, out Vector<int>, out Vector<int>)
De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic:
x[i] =: element_ref(3i, data0, data1, data2),y[i] =: element_ref(3i+1, data0, data1, data2),z[i] =: element_ref(3*i+2, data0, data1, data2).
- YGroup3Unzip(Vector<long>, Vector<long>, Vector<long>, out Vector<long>, out Vector<long>)
De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic:
x[i] =: element_ref(3i, data0, data1, data2),y[i] =: element_ref(3i+1, data0, data1, data2),z[i] =: element_ref(3*i+2, data0, data1, data2).
- YGroup3Unzip(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic:
x[i] =: element_ref(3i, data0, data1, data2),y[i] =: element_ref(3i+1, data0, data1, data2),z[i] =: element_ref(3*i+2, data0, data1, data2).
- YGroup3Unzip(Vector<float>, Vector<float>, Vector<float>, out Vector<float>, out Vector<float>)
De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic:
x[i] =: element_ref(3i, data0, data1, data2),y[i] =: element_ref(3i+1, data0, data1, data2),z[i] =: element_ref(3*i+2, data0, data1, data2).
- YGroup3Unzip(Vector<ushort>, Vector<ushort>, Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic:
x[i] =: element_ref(3i, data0, data1, data2),y[i] =: element_ref(3i+1, data0, data1, data2),z[i] =: element_ref(3*i+2, data0, data1, data2).
- YGroup3Unzip(Vector<uint>, Vector<uint>, Vector<uint>, out Vector<uint>, out Vector<uint>)
De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic:
x[i] =: element_ref(3i, data0, data1, data2),y[i] =: element_ref(3i+1, data0, data1, data2),z[i] =: element_ref(3*i+2, data0, data1, data2).
- YGroup3Unzip(Vector<ulong>, Vector<ulong>, Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic:
x[i] =: element_ref(3i, data0, data1, data2),y[i] =: element_ref(3i+1, data0, data1, data2),z[i] =: element_ref(3*i+2, data0, data1, data2).
- YGroup3UnzipX2(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>)
De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic:
(x, y, z) = YGroup3Unzip(data0, data1, data2),(xB, yB, zB) = YGroup3Unzip(data3, data4, data5).
- YGroup3UnzipX2(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>)
De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic:
(x, y, z) = YGroup3Unzip(data0, data1, data2),(xB, yB, zB) = YGroup3Unzip(data3, data4, data5).
- YGroup3UnzipX2(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>)
De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic:
(x, y, z) = YGroup3Unzip(data0, data1, data2),(xB, yB, zB) = YGroup3Unzip(data3, data4, data5).
- YGroup3UnzipX2(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>)
De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic:
(x, y, z) = YGroup3Unzip(data0, data1, data2),(xB, yB, zB) = YGroup3Unzip(data3, data4, data5).
- YGroup3UnzipX2(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>)
De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic:
(x, y, z) = YGroup3Unzip(data0, data1, data2),(xB, yB, zB) = YGroup3Unzip(data3, data4, data5).
- YGroup3UnzipX2(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic:
(x, y, z) = YGroup3Unzip(data0, data1, data2),(xB, yB, zB) = YGroup3Unzip(data3, data4, data5).
- YGroup3UnzipX2(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>)
De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic:
(x, y, z) = YGroup3Unzip(data0, data1, data2),(xB, yB, zB) = YGroup3Unzip(data3, data4, data5).
- YGroup3UnzipX2(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic:
(x, y, z) = YGroup3Unzip(data0, data1, data2),(xB, yB, zB) = YGroup3Unzip(data3, data4, data5).
- YGroup3UnzipX2(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>)
De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic:
(x, y, z) = YGroup3Unzip(data0, data1, data2),(xB, yB, zB) = YGroup3Unzip(data3, data4, data5).
- YGroup3UnzipX2(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic:
(x, y, z) = YGroup3Unzip(data0, data1, data2),(xB, yB, zB) = YGroup3Unzip(data3, data4, data5).
- YGroup3UnzipX2_Bit128<T>(Vector<T>, Vector<T>, Vector<T>, Vector<T>, Vector<T>, Vector<T>, out Vector<T>, out Vector<T>, out Vector<T>, out Vector<T>, out Vector<T>)
De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). It is specialized for process 128-bit element (它专门用于处理128位元素). Mnemonic:
(x, y, z) = YGroup3Unzip(data0, data1, data2),(xB, yB, zB) = YGroup3Unzip(data3, data4, data5).
- YGroup3Unzip_Bit128<T>(Vector<T>, Vector<T>, Vector<T>, out Vector<T>, out Vector<T>)
De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGB像素数据, 解交织为 R,G,B 平面数据). It is specialized for process 128-bit element (它专门用于处理128位元素). Mnemonic:
x[i] =: element_ref(3i, data0, data1, data2),y[i] =: element_ref(3i+1, data0, data1, data2),z[i] =: element_ref(3*i+2, data0, data1, data2).
- YGroup3Zip(Vector<byte>, Vector<byte>, Vector<byte>, out Vector<byte>, out Vector<byte>)
Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B 平面数据, 交织为 已打包的RGB像素数据). Mnemonic:
element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ),i2 := i/3.
- YGroup3Zip(Vector<double>, Vector<double>, Vector<double>, out Vector<double>, out Vector<double>)
Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B 平面数据, 交织为 已打包的RGB像素数据). Mnemonic:
element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ),i2 := i/3.
- YGroup3Zip(Vector<short>, Vector<short>, Vector<short>, out Vector<short>, out Vector<short>)
Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B 平面数据, 交织为 已打包的RGB像素数据). Mnemonic:
element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ),i2 := i/3.
- YGroup3Zip(Vector<int>, Vector<int>, Vector<int>, out Vector<int>, out Vector<int>)
Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B 平面数据, 交织为 已打包的RGB像素数据). Mnemonic:
element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ),i2 := i/3.
- YGroup3Zip(Vector<long>, Vector<long>, Vector<long>, out Vector<long>, out Vector<long>)
Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B 平面数据, 交织为 已打包的RGB像素数据). Mnemonic:
element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ),i2 := i/3.
- YGroup3Zip(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B 平面数据, 交织为 已打包的RGB像素数据). Mnemonic:
element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ),i2 := i/3.
- YGroup3Zip(Vector<float>, Vector<float>, Vector<float>, out Vector<float>, out Vector<float>)
Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B 平面数据, 交织为 已打包的RGB像素数据). Mnemonic:
element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ),i2 := i/3.
- YGroup3Zip(Vector<ushort>, Vector<ushort>, Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B 平面数据, 交织为 已打包的RGB像素数据). Mnemonic:
element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ),i2 := i/3.
- YGroup3Zip(Vector<uint>, Vector<uint>, Vector<uint>, out Vector<uint>, out Vector<uint>)
Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B 平面数据, 交织为 已打包的RGB像素数据). Mnemonic:
element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ),i2 := i/3.
- YGroup3Zip(Vector<ulong>, Vector<ulong>, Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B 平面数据, 交织为 已打包的RGB像素数据). Mnemonic:
element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ),i2 := i/3.
- YGroup3ZipX2(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>)
Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic:
(data0, data1, data2) = YGroup3Zip(x, y, z),(data3, data4, data5) = YGroup3Zip(xB, yB, zB).
- YGroup3ZipX2(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>)
Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic:
(data0, data1, data2) = YGroup3Zip(x, y, z),(data3, data4, data5) = YGroup3Zip(xB, yB, zB).
- YGroup3ZipX2(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>)
Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic:
(data0, data1, data2) = YGroup3Zip(x, y, z),(data3, data4, data5) = YGroup3Zip(xB, yB, zB).
- YGroup3ZipX2(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>)
Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic:
(data0, data1, data2) = YGroup3Zip(x, y, z),(data3, data4, data5) = YGroup3Zip(xB, yB, zB).
- YGroup3ZipX2(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>)
Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic:
(data0, data1, data2) = YGroup3Zip(x, y, z),(data3, data4, data5) = YGroup3Zip(xB, yB, zB).
- YGroup3ZipX2(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic:
(data0, data1, data2) = YGroup3Zip(x, y, z),(data3, data4, data5) = YGroup3Zip(xB, yB, zB).
- YGroup3ZipX2(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>)
Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic:
(data0, data1, data2) = YGroup3Zip(x, y, z),(data3, data4, data5) = YGroup3Zip(xB, yB, zB).
- YGroup3ZipX2(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic:
(data0, data1, data2) = YGroup3Zip(x, y, z),(data3, data4, data5) = YGroup3Zip(xB, yB, zB).
- YGroup3ZipX2(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>)
Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic:
(data0, data1, data2) = YGroup3Zip(x, y, z),(data3, data4, data5) = YGroup3Zip(xB, yB, zB).
- YGroup3ZipX2(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic:
(data0, data1, data2) = YGroup3Zip(x, y, z),(data3, data4, data5) = YGroup3Zip(xB, yB, zB).
- YGroup3ZipX2_Bit128<T>(Vector<T>, Vector<T>, Vector<T>, Vector<T>, Vector<T>, Vector<T>, out Vector<T>, out Vector<T>, out Vector<T>, out Vector<T>, out Vector<T>)
Interleave 3 vectors into 3-element groups and process 2x data (将3个向量交织为3-元素组, 且处理2倍数据). Mnemonic:
(data0, data1, data2) = YGroup3Zip(x, y, z),(data3, data4, data5) = YGroup3Zip(xB, yB, zB).
- YGroup3Zip_Bit128<T>(Vector<T>, Vector<T>, Vector<T>, out Vector<T>, out Vector<T>)
Interleave 3 vectors into 3-element groups. It converts the 3-element groups SoA to AoS. It can also interleave R,G,B planar data into packed RGB pixel data (将3个向量交织为3-元素组. 它能将3元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B 平面数据, 交织为 已打包的RGB像素数据). Mnemonic:
element_ref(i, data0, data1, data2) := (0==(i%3))?( x[i2] ):( (1==(i%3))?( y[i2] ):( z[i2] ) ),i2 := i/3.
- YGroup4ToGroup3(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, out Vector<byte>, out Vector<byte>)
Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将 已打包的RGBA像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element:element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).
- YGroup4ToGroup3(Vector<double>, Vector<double>, Vector<double>, Vector<double>, out Vector<double>, out Vector<double>)
Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将 已打包的RGBA像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element:element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).
- YGroup4ToGroup3(Vector<short>, Vector<short>, Vector<short>, Vector<short>, out Vector<short>, out Vector<short>)
Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将 已打包的RGBA像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element:element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).
- YGroup4ToGroup3(Vector<int>, Vector<int>, Vector<int>, Vector<int>, out Vector<int>, out Vector<int>)
Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将 已打包的RGBA像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element:element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).
- YGroup4ToGroup3(Vector<long>, Vector<long>, Vector<long>, Vector<long>, out Vector<long>, out Vector<long>)
Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将 已打包的RGBA像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element:element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).
- YGroup4ToGroup3(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将 已打包的RGBA像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element:element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).
- YGroup4ToGroup3(Vector<float>, Vector<float>, Vector<float>, Vector<float>, out Vector<float>, out Vector<float>)
Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将 已打包的RGBA像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element:element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).
- YGroup4ToGroup3(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将 已打包的RGBA像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element:element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).
- YGroup4ToGroup3(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, out Vector<uint>, out Vector<uint>)
Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将 已打包的RGBA像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element:element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).
- YGroup4ToGroup3(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将 已打包的RGBA像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element:element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).
- YGroup4Unzip(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(Vector<double>, Vector<double>, Vector<double>, Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(Vector<short>, Vector<short>, Vector<short>, Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(Vector<int>, Vector<int>, Vector<int>, Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(Vector<long>, Vector<long>, Vector<long>, Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(Vector<float>, Vector<float>, Vector<float>, Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(Vector<ExInt128>, Vector<ExInt128>, Vector<ExInt128>, Vector<ExInt128>, out Vector<ExInt128>, out Vector<ExInt128>, out Vector<ExInt128>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(Vector<ExUInt128>, Vector<ExUInt128>, Vector<ExUInt128>, Vector<ExUInt128>, out Vector<ExUInt128>, out Vector<ExUInt128>, out Vector<ExUInt128>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip_Bit128<T>(Vector<T>, Vector<T>, Vector<T>, Vector<T>, out Vector<T>, out Vector<T>, out Vector<T>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). It is specialized for process 128-bit element (它专门用于处理128位元素). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Zip(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>)
Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B,A 平面数据, 交织为 已打包的RGBA像素数据). Mnemonic:
element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ),i2 := i/4.
- YGroup4Zip(Vector<double>, Vector<double>, Vector<double>, Vector<double>, out Vector<double>, out Vector<double>, out Vector<double>)
Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B,A 平面数据, 交织为 已打包的RGBA像素数据). Mnemonic:
element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ),i2 := i/4.
- YGroup4Zip(Vector<short>, Vector<short>, Vector<short>, Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>)
Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B,A 平面数据, 交织为 已打包的RGBA像素数据). Mnemonic:
element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ),i2 := i/4.
- YGroup4Zip(Vector<int>, Vector<int>, Vector<int>, Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>)
Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B,A 平面数据, 交织为 已打包的RGBA像素数据). Mnemonic:
element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ),i2 := i/4.
- YGroup4Zip(Vector<long>, Vector<long>, Vector<long>, Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>)
Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B,A 平面数据, 交织为 已打包的RGBA像素数据). Mnemonic:
element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ),i2 := i/4.
- YGroup4Zip(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B,A 平面数据, 交织为 已打包的RGBA像素数据). Mnemonic:
element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ),i2 := i/4.
- YGroup4Zip(Vector<float>, Vector<float>, Vector<float>, Vector<float>, out Vector<float>, out Vector<float>, out Vector<float>)
Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B,A 平面数据, 交织为 已打包的RGBA像素数据). Mnemonic:
element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ),i2 := i/4.
- YGroup4Zip(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B,A 平面数据, 交织为 已打包的RGBA像素数据). Mnemonic:
element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ),i2 := i/4.
- YGroup4Zip(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>)
Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B,A 平面数据, 交织为 已打包的RGBA像素数据). Mnemonic:
element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ),i2 := i/4.
- YGroup4Zip(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B,A 平面数据, 交织为 已打包的RGBA像素数据). Mnemonic:
element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ),i2 := i/4.
- YGroup4Zip(Vector<ExInt128>, Vector<ExInt128>, Vector<ExInt128>, Vector<ExInt128>, out Vector<ExInt128>, out Vector<ExInt128>, out Vector<ExInt128>)
Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B,A 平面数据, 交织为 已打包的RGBA像素数据). Mnemonic:
element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ),i2 := i/4.
- YGroup4Zip(Vector<ExUInt128>, Vector<ExUInt128>, Vector<ExUInt128>, Vector<ExUInt128>, out Vector<ExUInt128>, out Vector<ExUInt128>, out Vector<ExUInt128>)
Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B,A 平面数据, 交织为 已打包的RGBA像素数据). Mnemonic:
element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ),i2 := i/4.
- YGroup4Zip_Bit128<T>(Vector<T>, Vector<T>, Vector<T>, Vector<T>, out Vector<T>, out Vector<T>, out Vector<T>)
Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B,A 平面数据, 交织为 已打包的RGBA像素数据). It is specialized for process 128-bit element (它专门用于处理128位元素). Mnemonic:
element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ),i2 := i/4.
- YIsAllTrue<T>(Vector<T>)
Checks if all elements of the vector is true (检查向量中所有元素是不是都为true). Mnemonic:
rt := value[0] && value[1] && value[2] && ... && value[Count-1]. The element of value must be 0 or AllBitsSet (Signed integer value -1).
- YIsAnyTrue<T>(Vector<T>)
Checks if any elements of the vector is true (检查向量中任一元素是不是为true). Mnemonic:
rt := value[0] || value[1] || value[2] || ... || value[Count-1]. The element of value must be 0 or AllBitsSet (Signed integer value -1).
- YIsEvenInteger(Vector<byte>)
Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic:
rt[i] := to_mask(isEvenInteger(value[i])).
- YIsEvenInteger(Vector<double>)
Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic:
rt[i] := to_mask(isEvenInteger(value[i])).
- YIsEvenInteger(Vector<short>)
Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic:
rt[i] := to_mask(isEvenInteger(value[i])).
- YIsEvenInteger(Vector<int>)
Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic:
rt[i] := to_mask(isEvenInteger(value[i])).
- YIsEvenInteger(Vector<long>)
Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic:
rt[i] := to_mask(isEvenInteger(value[i])).
- YIsEvenInteger(Vector<sbyte>)
Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic:
rt[i] := to_mask(isEvenInteger(value[i])).
- YIsEvenInteger(Vector<float>)
Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic:
rt[i] := to_mask(isEvenInteger(value[i])).
- YIsEvenInteger(Vector<ushort>)
Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic:
rt[i] := to_mask(isEvenInteger(value[i])).
- YIsEvenInteger(Vector<uint>)
Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic:
rt[i] := to_mask(isEvenInteger(value[i])).
- YIsEvenInteger(Vector<ulong>)
Determines if a element represents an even integral number (确定元素是否为偶数整数). Mnemonic:
rt[i] := to_mask(isEvenInteger(value[i])).
- YIsFinite(Vector<double>)
Determines if a element is finite. It contains zero, subnormal, and normal. It does not contain infinity, NaN (确定元素是否为有限值. 它包含 零、次正规数、正规数. 它不含无穷大、非数). Mnemonic:
rt[i] := to_mask(isFinite(value[i])).
- YIsFinite(Vector<float>)
Determines if a element is finite. It contains zero, subnormal, and normal. It does not contain infinity, NaN (确定元素是否为有限值. 它包含 零、次正规数、正规数. 它不含无穷大、非数). Mnemonic:
rt[i] := to_mask(isFinite(value[i])).
- YIsInfinity(Vector<double>)
Determines if a element is infinite (确定元素是否为无穷大). Mnemonic:
rt[i] := to_mask(isInfinity(value[i])).
- YIsInfinity(Vector<float>)
Determines if a element is infinite (确定元素是否为无穷大). Mnemonic:
rt[i] := to_mask(isInfinity(value[i])).
- YIsInfinityOrNaN(Vector<double>)
Determines if a element is infinite or NaN (确定元素是否为无穷大或非数). Mnemonic:
rt[i] := to_mask(isInfinityOrNaN(value[i])).
- YIsInfinityOrNaN(Vector<float>)
Determines if a element is infinite or NaN (确定元素是否为无穷大或非数). Mnemonic:
rt[i] := to_mask(isInfinityOrNaN(value[i])).
- YIsInteger(Vector<double>)
Determines if a element represents an integral number (确定元素是否为整数). Mnemonic:
rt[i] := to_mask(isInteger(value[i])).
- YIsInteger(Vector<float>)
Determines if a element represents an integral number (确定元素是否为整数). Mnemonic:
rt[i] := to_mask(isInteger(value[i])).
- YIsNaN(Vector<double>)
Determines if a element is NaN (确定元素是否为非数). Mnemonic:
rt[i] := to_mask(isNaN(value[i])).
- YIsNaN(Vector<float>)
Determines if a element is NaN (确定元素是否为非数). Mnemonic:
rt[i] := to_mask(isNaN(value[i])).
- YIsNegative(Vector<double>)
Determines if a element represents a negative number or negative zero (确定元素是否为负数或负零). Mnemonic:
rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).
- YIsNegative(Vector<short>)
Determines if a element represents a negative number or negative zero (确定元素是否为负数或负零). Mnemonic:
rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).
- YIsNegative(Vector<int>)
Determines if a element represents a negative number or negative zero (确定元素是否为负数或负零). Mnemonic:
rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).
- YIsNegative(Vector<long>)
Determines if a element represents a negative number or negative zero (确定元素是否为负数或负零). Mnemonic:
rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).
- YIsNegative(Vector<sbyte>)
Determines if a element represents a negative number or negative zero (确定元素是否为负数或负零). Mnemonic:
rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).
- YIsNegative(Vector<float>)
Determines if a element represents a negative number or negative zero (确定元素是否为负数或负零). Mnemonic:
rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).
- YIsNegativeInfinity(Vector<double>)
Determines if a element is negative infinity (确定元素是否为负无穷大). Mnemonic:
rt[i] := to_mask(isNegativeInfinity(value[i])).
- YIsNegativeInfinity(Vector<float>)
Determines if a element is negative infinity (确定元素是否为负无穷大). Mnemonic:
rt[i] := to_mask(isNegativeInfinity(value[i])).
- YIsNegativeZero(Vector<double>)
Determines if a element represents a negative zero (确定元素是否为负零). Mnemonic:
rt[i] := to_mask(isNegativeZero(value[i])).
- YIsNegativeZero(Vector<float>)
Determines if a element represents a negative zero (确定元素是否为负零). Mnemonic:
rt[i] := to_mask(isNegativeZero(value[i])).
- YIsNormal(Vector<double>)
Determines if a element is normal (确定元素是否为正规数). Mnemonic:
rt[i] := to_mask(isFinite(value[i])).
- YIsNormal(Vector<float>)
Determines if a element is normal (确定元素是否为正规数). Mnemonic:
rt[i] := to_mask(isFinite(value[i])).
- YIsNotEquals(Vector<byte>, Vector<byte>)
Compares two vectors to determine if they are not equal on a per-element basis (比较两个向量，确定它们每个元素是否不相等). Mnemonic:
rt[i] := to_mask(left[i] != right[i]).
- YIsNotEquals(Vector<double>, Vector<double>)
Compares two vectors to determine if they are not equal on a per-element basis (比较两个向量，确定它们每个元素是否不相等). Mnemonic:
rt[i] := to_mask(left[i] != right[i]).
- YIsNotEquals(Vector<short>, Vector<short>)
Compares two vectors to determine if they are not equal on a per-element basis (比较两个向量，确定它们每个元素是否不相等). Mnemonic:
rt[i] := to_mask(left[i] != right[i]).
- YIsNotEquals(Vector<int>, Vector<int>)
Compares two vectors to determine if they are not equal on a per-element basis (比较两个向量，确定它们每个元素是否不相等). Mnemonic:
rt[i] := to_mask(left[i] != right[i]).
- YIsNotEquals(Vector<long>, Vector<long>)
Compares two vectors to determine if they are not equal on a per-element basis (比较两个向量，确定它们每个元素是否不相等). Mnemonic:
rt[i] := to_mask(left[i] != right[i]).
- YIsNotEquals(Vector<sbyte>, Vector<sbyte>)
Compares two vectors to determine if they are not equal on a per-element basis (比较两个向量，确定它们每个元素是否不相等). Mnemonic:
rt[i] := to_mask(left[i] != right[i]).
- YIsNotEquals(Vector<float>, Vector<float>)
Compares two vectors to determine if they are not equal on a per-element basis (比较两个向量，确定它们每个元素是否不相等). Mnemonic:
rt[i] := to_mask(left[i] != right[i]).
- YIsNotEquals(Vector<ushort>, Vector<ushort>)
Compares two vectors to determine if they are not equal on a per-element basis (比较两个向量，确定它们每个元素是否不相等). Mnemonic:
rt[i] := to_mask(left[i] != right[i]).
- YIsNotEquals(Vector<uint>, Vector<uint>)
Compares two vectors to determine if they are not equal on a per-element basis (比较两个向量，确定它们每个元素是否不相等). Mnemonic:
rt[i] := to_mask(left[i] != right[i]).
- YIsNotEquals(Vector<ulong>, Vector<ulong>)
Compares two vectors to determine if they are not equal on a per-element basis (比较两个向量，确定它们每个元素是否不相等). Mnemonic:
rt[i] := to_mask(left[i] != right[i]).
- YIsNotNaN(Vector<double>)
Determines if a element is not NaN (确定元素是否不为非数). Mnemonic:
rt[i] := to_mask(isNotNaN(value[i])) = to_mask(!isNaN(value[i])).
- YIsNotNaN(Vector<float>)
Determines if a element is not NaN (确定元素是否不为非数). Mnemonic:
rt[i] := to_mask(isNotNaN(value[i])) = to_mask(!isNaN(value[i])).
- YIsOddInteger(Vector<byte>)
Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic:
rt[i] := to_mask(isOddInteger(value[i])).
- YIsOddInteger(Vector<double>)
Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic:
rt[i] := to_mask(isOddInteger(value[i])).
- YIsOddInteger(Vector<short>)
Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic:
rt[i] := to_mask(isOddInteger(value[i])).
- YIsOddInteger(Vector<int>)
Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic:
rt[i] := to_mask(isOddInteger(value[i])).
- YIsOddInteger(Vector<long>)
Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic:
rt[i] := to_mask(isOddInteger(value[i])).
- YIsOddInteger(Vector<sbyte>)
Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic:
rt[i] := to_mask(isOddInteger(value[i])).
- YIsOddInteger(Vector<float>)
Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic:
rt[i] := to_mask(isOddInteger(value[i])).
- YIsOddInteger(Vector<ushort>)
Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic:
rt[i] := to_mask(isOddInteger(value[i])).
- YIsOddInteger(Vector<uint>)
Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic:
rt[i] := to_mask(isOddInteger(value[i])).
- YIsOddInteger(Vector<ulong>)
Determines if a element represents an odd integral number (确定元素是否为奇数整数). Mnemonic:
rt[i] := to_mask(isOddInteger(value[i])).
- YIsPositive(Vector<double>)
Determines if a element represents zero or a positive number (确定元素是否为零或正数). Mnemonic:
rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).
- YIsPositive(Vector<short>)
Determines if a element represents zero or a positive number (确定元素是否为零或正数). Mnemonic:
rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).
- YIsPositive(Vector<int>)
Determines if a element represents zero or a positive number (确定元素是否为零或正数). Mnemonic:
rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).
- YIsPositive(Vector<long>)
Determines if a element represents zero or a positive number (确定元素是否为零或正数). Mnemonic:
rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).
- YIsPositive(Vector<sbyte>)
Determines if a element represents zero or a positive number (确定元素是否为零或正数). Mnemonic:
rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).
- YIsPositive(Vector<float>)
Determines if a element represents zero or a positive number (确定元素是否为零或正数). Mnemonic:
rt[i] := to_mask(isNegative(value[i])) = to_mask((value[i]<0) || isNegativeZero(value[i])).
- YIsPositiveInfinity(Vector<double>)
Determines if a element is positive infinity (确定元素是否为正无穷大). Mnemonic:
rt[i] := to_mask(isNegativeInfinity(value[i])).
- YIsPositiveInfinity(Vector<float>)
Determines if a element is positive infinity (确定元素是否为正无穷大). Mnemonic:
rt[i] := to_mask(isNegativeInfinity(value[i])).
- YIsSubnormal(Vector<double>)
Determines if a element is subnormal (确定元素是否为次正规数). Mnemonic:
rt[i] := to_mask(IsSubnormal(value[i])).
- YIsSubnormal(Vector<float>)
Determines if a element is subnormal (确定元素是否为次正规数). Mnemonic:
rt[i] := to_mask(IsSubnormal(value[i])).
- YIsZero(Vector<byte>)
Determines if a element is zero (确定元素是否为零). Mnemonic:
rt[i] := to_mask(0==value[i]).
- YIsZero(Vector<double>)
Determines if a element is zero (确定元素是否为零). Mnemonic:
rt[i] := to_mask(0==value[i]).
- YIsZero(Vector<short>)
Determines if a element is zero (确定元素是否为零). Mnemonic:
rt[i] := to_mask(0==value[i]).
- YIsZero(Vector<int>)
Determines if a element is zero (确定元素是否为零). Mnemonic:
rt[i] := to_mask(0==value[i]).
- YIsZero(Vector<long>)
Determines if a element is zero (确定元素是否为零). Mnemonic:
rt[i] := to_mask(0==value[i]).
- YIsZero(Vector<sbyte>)
Determines if a element is zero (确定元素是否为零). Mnemonic:
rt[i] := to_mask(0==value[i]).
- YIsZero(Vector<float>)
Determines if a element is zero (确定元素是否为零). Mnemonic:
rt[i] := to_mask(0==value[i]).
- YIsZero(Vector<ushort>)
Determines if a element is zero (确定元素是否为零). Mnemonic:
rt[i] := to_mask(0==value[i]).
- YIsZero(Vector<uint>)
Determines if a element is zero (确定元素是否为零). Mnemonic:
rt[i] := to_mask(0==value[i]).
- YIsZero(Vector<ulong>)
Determines if a element is zero (确定元素是否为零). Mnemonic:
rt[i] := to_mask(0==value[i]).
- YIsZeroOrSubnormal(Vector<double>)
Determines if a element is zero or subnormal (确定元素是否为零或次正规数). Mnemonic:
rt[i] := to_mask(isZeroOrSubnormal(value[i])).
- YIsZeroOrSubnormal(Vector<float>)
Determines if a element is zero or subnormal (确定元素是否为零或次正规数). Mnemonic:
rt[i] := to_mask(isZeroOrSubnormal(value[i])).
- YMaxNumber(Vector<double>, Vector<double>)
Computes the maximum number of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最大数值). The maxNumber method matches the IEEE 754:2019 maximumNumber function. This requires
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(Vector<float>, Vector<float>)
Computes the maximum number of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最大数值). The maxNumber method matches the IEEE 754:2019 maximumNumber function. This requires
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(Vector<double>, Vector<double>)
Computes the minimum number of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最小数值). The minNumber method matches the IEEE 754:2019 minimumNumber function. This requires
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(Vector<float>, Vector<float>)
Computes the minimum number of two vectors on a per-element basis (在每个元素的基础上计算两个向量的最小数值). The minNumber method matches the IEEE 754:2019 minimumNumber function. This requires
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(Vector<short>, Vector<short>)
Saturate narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例饱和缩窄为一个 Vector<T> ). />. Mnemonic:
rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), TOut.MinValue, TOut.MaxValue)).
- YNarrowSaturate(Vector<int>, Vector<int>)
Saturate narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例饱和缩窄为一个 Vector<T> ). />. Mnemonic:
rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), TOut.MinValue, TOut.MaxValue)).
- YNarrowSaturate(Vector<long>, Vector<long>)
Saturate narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例饱和缩窄为一个 Vector<T> ). />. Mnemonic:
rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), TOut.MinValue, TOut.MaxValue)).
- YNarrowSaturate(Vector<ushort>, Vector<ushort>)
Saturate narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例饱和缩窄为一个 Vector<T> ). />. Mnemonic:
rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), TOut.MinValue, TOut.MaxValue)).
- YNarrowSaturate(Vector<uint>, Vector<uint>)
Saturate narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例饱和缩窄为一个 Vector<T> ). />. Mnemonic:
rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), TOut.MinValue, TOut.MaxValue)).
- YNarrowSaturate(Vector<ulong>, Vector<ulong>)
Saturate narrows two Vector<T> instances into one Vector<T>" (将两个 Vector<T> 实例饱和缩窄为一个 Vector<T> ). />. Mnemonic:
rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), TOut.MinValue, TOut.MaxValue)).
- YNarrowSaturateUnsigned(Vector<short>, Vector<short>)
Saturate narrows two signed Vector<T> instances into one unsigned Vector<T>" (将两个有符号 Vector<T> 实例饱和缩窄为一个无符号 Vector<T> ). />. Mnemonic:
rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), 0, TOut.MaxValue)).
- YNarrowSaturateUnsigned(Vector<int>, Vector<int>)
Saturate narrows two signed Vector<T> instances into one unsigned Vector<T>" (将两个有符号 Vector<T> 实例饱和缩窄为一个无符号 Vector<T> ). />. Mnemonic:
rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), 0, TOut.MaxValue)).
- YNarrowSaturateUnsigned(Vector<long>, Vector<long>)
Saturate narrows two signed Vector<T> instances into one unsigned Vector<T>" (将两个有符号 Vector<T> 实例饱和缩窄为一个无符号 Vector<T> ). />. Mnemonic:
rt[i] := narrow_saturate(element_ref(i, lower, upper)) = narrow(clamp(element_ref(i, lower, upper), 0, TOut.MaxValue)).
- YOrNot<T>(Vector<T>, Vector<T>)
Computes the bitwise-or of a given vector or the ones complement of another vector (计算一个给定的向量和另一个向量反码的位或). Mnemonic:
rt[i] := left[i] | ~right[i].
- YRoundToEven(Vector<double>)
Computes the round to even of each element in a vector (计算向量中每个元素的向偶数舍入). It is also known as
rounding half to even/round to nearest integer(它也被称作四舍六入五成双/舍入到最近整数). See more: ToEven. Mnemonic:rt[i] := round_to_even(value[i]).
- YRoundToEven(Vector<float>)
Computes the round to even of each element in a vector (计算向量中每个元素的向偶数舍入). It is also known as
rounding half to even/round to nearest integer(它也被称作四舍六入五成双/舍入到最近整数). See more: ToEven. Mnemonic:rt[i] := round_to_even(value[i]).
- YRoundToZero(Vector<double>)
Computes the round to zero of each element in a vector (计算向量中每个元素的向零舍入). It is also known as truncate (它也被称作截断取整). See more: ToZero. Mnemonic:
rt[i] := round_to_zero(value[i]).
- YRoundToZero(Vector<float>)
Computes the round to zero of each element in a vector (计算向量中每个元素的向零舍入). It is also known as truncate (它也被称作截断取整). See more: ToZero. Mnemonic:
rt[i] := round_to_zero(value[i]).
- YShuffleG2(Vector<byte>, ShuffleControlG2)
For each 2-element group in a vector, shuffle is performed (对于一个向量中的每个 2-元素组, 进行换位). Mnemonic: View for group:
rt.xy = shuffleG2_ref(control, source). View for element:rt[i] := source[(i&(~1)) | ((control >> (i&1)) & 1)].
- YShuffleG2(Vector<double>, ShuffleControlG2)
For each 2-element group in a vector, shuffle is performed (对于一个向量中的每个 2-元素组, 进行换位). Mnemonic: View for group:
rt.xy = shuffleG2_ref(control, source). View for element:rt[i] := source[(i&(~1)) | ((control >> (i&1)) & 1)].
- YShuffleG2(Vector<short>, ShuffleControlG2)
For each 2-element group in a vector, shuffle is performed (对于一个向量中的每个 2-元素组, 进行换位). Mnemonic: View for group:
rt.xy = shuffleG2_ref(control, source). View for element:rt[i] := source[(i&(~1)) | ((control >> (i&1)) & 1)].
- YShuffleG2(Vector<int>, ShuffleControlG2)
For each 2-element group in a vector, shuffle is performed (对于一个向量中的每个 2-元素组, 进行换位). Mnemonic: View for group:
rt.xy = shuffleG2_ref(control, source). View for element:rt[i] := source[(i&(~1)) | ((control >> (i&1)) & 1)].
- YShuffleG2(Vector<long>, ShuffleControlG2)
For each 2-element group in a vector, shuffle is performed (对于一个向量中的每个 2-元素组, 进行换位). Mnemonic: View for group:
rt.xy = shuffleG2_ref(control, source). View for element:rt[i] := source[(i&(~1)) | ((control >> (i&1)) & 1)].
- YShuffleG2(Vector<sbyte>, ShuffleControlG2)
For each 2-element group in a vector, shuffle is performed (对于一个向量中的每个 2-元素组, 进行换位). Mnemonic: View for group:
rt.xy = shuffleG2_ref(control, source). View for element:rt[i] := source[(i&(~1)) | ((control >> (i&1)) & 1)].
- YShuffleG2(Vector<float>, ShuffleControlG2)
For each 2-element group in a vector, shuffle is performed (对于一个向量中的每个 2-元素组, 进行换位). Mnemonic: View for group:
rt.xy = shuffleG2_ref(control, source). View for element:rt[i] := source[(i&(~1)) | ((control >> (i&1)) & 1)].
- YShuffleG2(Vector<ushort>, ShuffleControlG2)
For each 2-element group in a vector, shuffle is performed (对于一个向量中的每个 2-元素组, 进行换位). Mnemonic: View for group:
rt.xy = shuffleG2_ref(control, source). View for element:rt[i] := source[(i&(~1)) | ((control >> (i&1)) & 1)].
- YShuffleG2(Vector<uint>, ShuffleControlG2)
For each 2-element group in a vector, shuffle is performed (对于一个向量中的每个 2-元素组, 进行换位). Mnemonic: View for group:
rt.xy = shuffleG2_ref(control, source). View for element:rt[i] := source[(i&(~1)) | ((control >> (i&1)) & 1)].
- YShuffleG2(Vector<ulong>, ShuffleControlG2)
For each 2-element group in a vector, shuffle is performed (对于一个向量中的每个 2-元素组, 进行换位). Mnemonic: View for group:
rt.xy = shuffleG2_ref(control, source). View for element:rt[i] := source[(i&(~1)) | ((control >> (i&1)) & 1)].
- YShuffleG4(Vector<byte>, ShuffleControlG4)
For each 4-element group in a vector, shuffle is performed (对于一个向量中的每个 4-元素组, 进行换位). If the count of elements in a vector is less than 4, please use YShuffleG4X2 instead (如果向量的元素数量小于4，请使用 YShuffleG4X2 代替). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source). View for element:rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].
- YShuffleG4(Vector<double>, ShuffleControlG4)
For each 4-element group in a vector, shuffle is performed (对于一个向量中的每个 4-元素组, 进行换位). If the count of elements in a vector is less than 4, please use YShuffleG4X2 instead (如果向量的元素数量小于4，请使用 YShuffleG4X2 代替). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source). View for element:rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].
- YShuffleG4(Vector<short>, ShuffleControlG4)
For each 4-element group in a vector, shuffle is performed (对于一个向量中的每个 4-元素组, 进行换位). If the count of elements in a vector is less than 4, please use YShuffleG4X2 instead (如果向量的元素数量小于4，请使用 YShuffleG4X2 代替). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source). View for element:rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].
- YShuffleG4(Vector<int>, ShuffleControlG4)
For each 4-element group in a vector, shuffle is performed (对于一个向量中的每个 4-元素组, 进行换位). If the count of elements in a vector is less than 4, please use YShuffleG4X2 instead (如果向量的元素数量小于4，请使用 YShuffleG4X2 代替). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source). View for element:rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].
- YShuffleG4(Vector<long>, ShuffleControlG4)
For each 4-element group in a vector, shuffle is performed (对于一个向量中的每个 4-元素组, 进行换位). If the count of elements in a vector is less than 4, please use YShuffleG4X2 instead (如果向量的元素数量小于4，请使用 YShuffleG4X2 代替). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source). View for element:rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].
- YShuffleG4(Vector<sbyte>, ShuffleControlG4)
For each 4-element group in a vector, shuffle is performed (对于一个向量中的每个 4-元素组, 进行换位). If the count of elements in a vector is less than 4, please use YShuffleG4X2 instead (如果向量的元素数量小于4，请使用 YShuffleG4X2 代替). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source). View for element:rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].
- YShuffleG4(Vector<float>, ShuffleControlG4)
For each 4-element group in a vector, shuffle is performed (对于一个向量中的每个 4-元素组, 进行换位). If the count of elements in a vector is less than 4, please use YShuffleG4X2 instead (如果向量的元素数量小于4，请使用 YShuffleG4X2 代替). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source). View for element:rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].
- YShuffleG4(Vector<ushort>, ShuffleControlG4)
For each 4-element group in a vector, shuffle is performed (对于一个向量中的每个 4-元素组, 进行换位). If the count of elements in a vector is less than 4, please use YShuffleG4X2 instead (如果向量的元素数量小于4，请使用 YShuffleG4X2 代替). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source). View for element:rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].
- YShuffleG4(Vector<uint>, ShuffleControlG4)
For each 4-element group in a vector, shuffle is performed (对于一个向量中的每个 4-元素组, 进行换位). If the count of elements in a vector is less than 4, please use YShuffleG4X2 instead (如果向量的元素数量小于4，请使用 YShuffleG4X2 代替). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source). View for element:rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].
- YShuffleG4(Vector<ulong>, ShuffleControlG4)
For each 4-element group in a vector, shuffle is performed (对于一个向量中的每个 4-元素组, 进行换位). If the count of elements in a vector is less than 4, please use YShuffleG4X2 instead (如果向量的元素数量小于4，请使用 YShuffleG4X2 代替). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source). View for element:rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].
- YShuffleG4X2(Vector<byte>, Vector<byte>, ShuffleControlG4, out Vector<byte>)
For each 4-element group in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2(Vector<double>, Vector<double>, ShuffleControlG4, out Vector<double>)
For each 4-element group in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2(Vector<short>, Vector<short>, ShuffleControlG4, out Vector<short>)
For each 4-element group in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2(Vector<int>, Vector<int>, ShuffleControlG4, out Vector<int>)
For each 4-element group in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2(Vector<long>, Vector<long>, ShuffleControlG4, out Vector<long>)
For each 4-element group in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2(Vector<sbyte>, Vector<sbyte>, ShuffleControlG4, out Vector<sbyte>)
For each 4-element group in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2(Vector<float>, Vector<float>, ShuffleControlG4, out Vector<float>)
For each 4-element group in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2(Vector<ushort>, Vector<ushort>, ShuffleControlG4, out Vector<ushort>)
For each 4-element group in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2(Vector<uint>, Vector<uint>, ShuffleControlG4, out Vector<uint>)
For each 4-element group in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2(Vector<ulong>, Vector<ulong>, ShuffleControlG4, out Vector<ulong>)
For each 4-element group in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2_Const(Vector<byte>, Vector<byte>, ShuffleControlG4, out Vector<byte>)
For each 4-element group in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2_Const(Vector<double>, Vector<double>, ShuffleControlG4, out Vector<double>)
For each 4-element group in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2_Const(Vector<short>, Vector<short>, ShuffleControlG4, out Vector<short>)
For each 4-element group in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2_Const(Vector<int>, Vector<int>, ShuffleControlG4, out Vector<int>)
For each 4-element group in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2_Const(Vector<long>, Vector<long>, ShuffleControlG4, out Vector<long>)
For each 4-element group in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2_Const(Vector<sbyte>, Vector<sbyte>, ShuffleControlG4, out Vector<sbyte>)
For each 4-element group in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2_Const(Vector<float>, Vector<float>, ShuffleControlG4, out Vector<float>)
For each 4-element group in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2_Const(Vector<ushort>, Vector<ushort>, ShuffleControlG4, out Vector<ushort>)
For each 4-element group in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2_Const(Vector<uint>, Vector<uint>, ShuffleControlG4, out Vector<uint>)
For each 4-element group in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2_Const(Vector<ulong>, Vector<ulong>, ShuffleControlG4, out Vector<ulong>)
For each 4-element group in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4_Const(Vector<byte>, ShuffleControlG4)
For each 4-element group in a vector, shuffle is performed - Constant version (对于一个向量中的每个 4-元素组, 进行换位 - 常量版). If the count of the vector is less than 4, please use YShuffleG4X2_Const instead (如果向量的数量小于4，请使用 YShuffleG4X2_Const 代替). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source). View for element:rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].
- YShuffleG4_Const(Vector<double>, ShuffleControlG4)
For each 4-element group in a vector, shuffle is performed - Constant version (对于一个向量中的每个 4-元素组, 进行换位 - 常量版). If the count of the vector is less than 4, please use YShuffleG4X2_Const instead (如果向量的数量小于4，请使用 YShuffleG4X2_Const 代替). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source). View for element:rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].
- YShuffleG4_Const(Vector<short>, ShuffleControlG4)
For each 4-element group in a vector, shuffle is performed - Constant version (对于一个向量中的每个 4-元素组, 进行换位 - 常量版). If the count of the vector is less than 4, please use YShuffleG4X2_Const instead (如果向量的数量小于4，请使用 YShuffleG4X2_Const 代替). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source). View for element:rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].
- YShuffleG4_Const(Vector<int>, ShuffleControlG4)
For each 4-element group in a vector, shuffle is performed - Constant version (对于一个向量中的每个 4-元素组, 进行换位 - 常量版). If the count of the vector is less than 4, please use YShuffleG4X2_Const instead (如果向量的数量小于4，请使用 YShuffleG4X2_Const 代替). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source). View for element:rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].
- YShuffleG4_Const(Vector<long>, ShuffleControlG4)
For each 4-element group in a vector, shuffle is performed - Constant version (对于一个向量中的每个 4-元素组, 进行换位 - 常量版). If the count of the vector is less than 4, please use YShuffleG4X2_Const instead (如果向量的数量小于4，请使用 YShuffleG4X2_Const 代替). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source). View for element:rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].
- YShuffleG4_Const(Vector<sbyte>, ShuffleControlG4)
For each 4-element group in a vector, shuffle is performed - Constant version (对于一个向量中的每个 4-元素组, 进行换位 - 常量版). If the count of the vector is less than 4, please use YShuffleG4X2_Const instead (如果向量的数量小于4，请使用 YShuffleG4X2_Const 代替). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source). View for element:rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].
- YShuffleG4_Const(Vector<float>, ShuffleControlG4)
For each 4-element group in a vector, shuffle is performed - Constant version (对于一个向量中的每个 4-元素组, 进行换位 - 常量版). If the count of the vector is less than 4, please use YShuffleG4X2_Const instead (如果向量的数量小于4，请使用 YShuffleG4X2_Const 代替). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source). View for element:rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].
- YShuffleG4_Const(Vector<ushort>, ShuffleControlG4)
For each 4-element group in a vector, shuffle is performed - Constant version (对于一个向量中的每个 4-元素组, 进行换位 - 常量版). If the count of the vector is less than 4, please use YShuffleG4X2_Const instead (如果向量的数量小于4，请使用 YShuffleG4X2_Const 代替). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source). View for element:rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].
- YShuffleG4_Const(Vector<uint>, ShuffleControlG4)
For each 4-element group in a vector, shuffle is performed - Constant version (对于一个向量中的每个 4-元素组, 进行换位 - 常量版). If the count of the vector is less than 4, please use YShuffleG4X2_Const instead (如果向量的数量小于4，请使用 YShuffleG4X2_Const 代替). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source). View for element:rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].
- YShuffleG4_Const(Vector<ulong>, ShuffleControlG4)
For each 4-element group in a vector, shuffle is performed - Constant version (对于一个向量中的每个 4-元素组, 进行换位 - 常量版). If the count of the vector is less than 4, please use YShuffleG4X2_Const instead (如果向量的数量小于4，请使用 YShuffleG4X2_Const 代替). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source). View for element:rt[i] := source[(i&(~3)) | ((control >> ((i&3)*2)) & 3)].
- YShuffleInsert(Vector<byte>, Vector<byte>, Vector<byte>)
Shuffle and insert (换位并插入). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert(Vector<double>, Vector<double>, Vector<long>)
Shuffle and insert (换位并插入). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert(Vector<short>, Vector<short>, Vector<short>)
Shuffle and insert (换位并插入). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert(Vector<int>, Vector<int>, Vector<int>)
Shuffle and insert (换位并插入). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert(Vector<long>, Vector<long>, Vector<long>)
Shuffle and insert (换位并插入). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Shuffle and insert (换位并插入). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert(Vector<float>, Vector<float>, Vector<int>)
Shuffle and insert (换位并插入). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert(Vector<ushort>, Vector<ushort>, Vector<ushort>)
Shuffle and insert (换位并插入). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert(Vector<uint>, Vector<uint>, Vector<uint>)
Shuffle and insert (换位并插入). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert(Vector<ulong>, Vector<ulong>, Vector<ulong>)
Shuffle and insert (换位并插入). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Args(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>)
Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Args(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>)
Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Args(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>)
Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Args(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>)
Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Args(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>)
Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>)
Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Core(Vector<double>, Vector<double>, Vector<long>, Vector<long>, Vector<long>)
Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>)
Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Core(Vector<float>, Vector<float>, Vector<int>, Vector<int>, Vector<int>)
Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>)
Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>)
Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>)
Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleKernel(Vector<byte>, Vector<byte>)
Only shuffle (仅换位). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel(Vector<double>, Vector<long>)
Only shuffle (仅换位). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel(Vector<short>, Vector<short>)
Only shuffle (仅换位). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel(Vector<int>, Vector<int>)
Only shuffle (仅换位). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel(Vector<long>, Vector<long>)
Only shuffle (仅换位). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel(Vector<sbyte>, Vector<sbyte>)
Only shuffle (仅换位). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel(Vector<float>, Vector<int>)
Only shuffle (仅换位). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel(Vector<ushort>, Vector<ushort>)
Only shuffle (仅换位). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel(Vector<uint>, Vector<uint>)
Only shuffle (仅换位). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel(Vector<ulong>, Vector<ulong>)
Only shuffle (仅换位). Creates a new vector by selecting values from an input vector using a set of indices (通过使用一组索引从输入向量中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Args(Vector<byte>, out Vector<byte>, out Vector<byte>)
Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Args(Vector<short>, out Vector<short>, out Vector<short>)
Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Args(Vector<int>, out Vector<int>, out Vector<int>)
Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Args(Vector<long>, out Vector<long>, out Vector<long>)
Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Args(Vector<uint>, out Vector<uint>, out Vector<uint>)
Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Core(Vector<byte>, Vector<byte>, Vector<byte>)
Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Core(Vector<double>, Vector<long>, Vector<long>)
Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Core(Vector<short>, Vector<short>, Vector<short>)
Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Core(Vector<int>, Vector<int>, Vector<int>)
Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Core(Vector<long>, Vector<long>, Vector<long>)
Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Core(Vector<float>, Vector<int>, Vector<int>)
Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>)
Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Core(Vector<uint>, Vector<uint>, Vector<uint>)
Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>)
Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleX2(Vector<byte>, Vector<byte>, Vector<byte>)
Shuffle and clear on 2 vectors (在2个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2(Vector<double>, Vector<double>, Vector<long>)
Shuffle and clear on 2 vectors (在2个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2(Vector<short>, Vector<short>, Vector<short>)
Shuffle and clear on 2 vectors (在2个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2(Vector<int>, Vector<int>, Vector<int>)
Shuffle and clear on 2 vectors (在2个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2(Vector<long>, Vector<long>, Vector<long>)
Shuffle and clear on 2 vectors (在2个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Shuffle and clear on 2 vectors (在2个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2(Vector<float>, Vector<float>, Vector<int>)
Shuffle and clear on 2 vectors (在2个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2(Vector<ushort>, Vector<ushort>, Vector<ushort>)
Shuffle and clear on 2 vectors (在2个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2(Vector<uint>, Vector<uint>, Vector<uint>)
Shuffle and clear on 2 vectors (在2个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2(Vector<ulong>, Vector<ulong>, Vector<ulong>)
Shuffle and clear on 2 vectors (在2个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2Insert(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>)
Shuffle and insert on 2 vectors (在2个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert(Vector<double>, Vector<double>, Vector<double>, Vector<long>)
Shuffle and insert on 2 vectors (在2个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert(Vector<short>, Vector<short>, Vector<short>, Vector<short>)
Shuffle and insert on 2 vectors (在2个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert(Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Shuffle and insert on 2 vectors (在2个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert(Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Shuffle and insert on 2 vectors (在2个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Shuffle and insert on 2 vectors (在2个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert(Vector<float>, Vector<float>, Vector<float>, Vector<int>)
Shuffle and insert on 2 vectors (在2个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>)
Shuffle and insert on 2 vectors (在2个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>)
Shuffle and insert on 2 vectors (在2个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>)
Shuffle and insert on 2 vectors (在2个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Args(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>)
Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Args(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>)
Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Args(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>)
Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Args(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>)
Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Args(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>)
Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>)
Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Core(Vector<double>, Vector<double>, Vector<double>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>)
Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Core(Vector<float>, Vector<float>, Vector<float>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>)
Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>)
Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>)
Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Kernel(Vector<byte>, Vector<byte>, Vector<byte>)
Only shuffle on 2 vectors (在2个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel(Vector<double>, Vector<double>, Vector<long>)
Only shuffle on 2 vectors (在2个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel(Vector<short>, Vector<short>, Vector<short>)
Only shuffle on 2 vectors (在2个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel(Vector<int>, Vector<int>, Vector<int>)
Only shuffle on 2 vectors (在2个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel(Vector<long>, Vector<long>, Vector<long>)
Only shuffle on 2 vectors (在2个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Only shuffle on 2 vectors (在2个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel(Vector<float>, Vector<float>, Vector<int>)
Only shuffle on 2 vectors (在2个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel(Vector<ushort>, Vector<ushort>, Vector<ushort>)
Only shuffle on 2 vectors (在2个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel(Vector<uint>, Vector<uint>, Vector<uint>)
Only shuffle on 2 vectors (在2个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel(Vector<ulong>, Vector<ulong>, Vector<ulong>)
Only shuffle on 2 vectors (在2个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Args(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>)
Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Args(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>)
Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Args(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>)
Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Args(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>)
Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Args(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>)
Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>)
Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Core(Vector<double>, Vector<double>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>)
Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Core(Vector<float>, Vector<float>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>)
Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>)
Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>)
Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2_Args(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>)
Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Args(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>)
Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Args(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>)
Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Args(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>)
Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Args(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>)
Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>)
Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Core(Vector<double>, Vector<double>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>)
Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Core(Vector<float>, Vector<float>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>)
Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>)
Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>)
Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX3(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>)
Shuffle and clear on 3 vectors (在3个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3(Vector<double>, Vector<double>, Vector<double>, Vector<long>)
Shuffle and clear on 3 vectors (在3个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3(Vector<short>, Vector<short>, Vector<short>, Vector<short>)
Shuffle and clear on 3 vectors (在3个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3(Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Shuffle and clear on 3 vectors (在3个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3(Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Shuffle and clear on 3 vectors (在3个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Shuffle and clear on 3 vectors (在3个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3(Vector<float>, Vector<float>, Vector<float>, Vector<int>)
Shuffle and clear on 3 vectors (在3个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>)
Shuffle and clear on 3 vectors (在3个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>)
Shuffle and clear on 3 vectors (在3个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>)
Shuffle and clear on 3 vectors (在3个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3Insert(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>)
Shuffle and insert on 3 vectors (在3个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<long>)
Shuffle and insert on 3 vectors (在3个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>)
Shuffle and insert on 3 vectors (在3个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Shuffle and insert on 3 vectors (在3个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Shuffle and insert on 3 vectors (在3个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Shuffle and insert on 3 vectors (在3个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<int>)
Shuffle and insert on 3 vectors (在3个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>)
Shuffle and insert on 3 vectors (在3个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>)
Shuffle and insert on 3 vectors (在3个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>)
Shuffle and insert on 3 vectors (在3个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Args(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>)
Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Args(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>)
Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Args(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>)
Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Args(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>)
Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Args(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>)
Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>)
Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Core(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>)
Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Core(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>)
Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>)
Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>)
Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Kernel(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>)
Only shuffle on 3 vectors (在3个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel(Vector<double>, Vector<double>, Vector<double>, Vector<long>)
Only shuffle on 3 vectors (在3个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel(Vector<short>, Vector<short>, Vector<short>, Vector<short>)
Only shuffle on 3 vectors (在3个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel(Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Only shuffle on 3 vectors (在3个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel(Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Only shuffle on 3 vectors (在3个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Only shuffle on 3 vectors (在3个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel(Vector<float>, Vector<float>, Vector<float>, Vector<int>)
Only shuffle on 3 vectors (在3个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>)
Only shuffle on 3 vectors (在3个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>)
Only shuffle on 3 vectors (在3个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>)
Only shuffle on 3 vectors (在3个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Args(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>)
Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Args(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>)
Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Args(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>)
Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Args(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>)
Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Args(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>)
Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>)
Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Core(Vector<double>, Vector<double>, Vector<double>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>)
Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Core(Vector<float>, Vector<float>, Vector<float>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>)
Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>)
Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>)
Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3_Args(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>)
Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Args(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>)
Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Args(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>)
Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Args(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>)
Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Args(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>)
Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>)
Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Core(Vector<double>, Vector<double>, Vector<double>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>)
Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Core(Vector<float>, Vector<float>, Vector<float>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>)
Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>)
Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>)
Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX4(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>)
Shuffle and clear on 4 vectors (在4个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<long>)
Shuffle and clear on 4 vectors (在4个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>)
Shuffle and clear on 4 vectors (在4个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Shuffle and clear on 4 vectors (在4个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Shuffle and clear on 4 vectors (在4个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Shuffle and clear on 4 vectors (在4个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<int>)
Shuffle and clear on 4 vectors (在4个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>)
Shuffle and clear on 4 vectors (在4个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>)
Shuffle and clear on 4 vectors (在4个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>)
Shuffle and clear on 4 vectors (在4个向量上进行换位并清零). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4Insert(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>)
Shuffle and insert on 4 vectors (在4个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<long>)
Shuffle and insert on 4 vectors (在4个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>)
Shuffle and insert on 4 vectors (在4个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Shuffle and insert on 4 vectors (在4个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Shuffle and insert on 4 vectors (在4个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Shuffle and insert on 4 vectors (在4个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<int>)
Shuffle and insert on 4 vectors (在4个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>)
Shuffle and insert on 4 vectors (在4个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>)
Shuffle and insert on 4 vectors (在4个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>)
Shuffle and insert on 4 vectors (在4个向量上进行换位并插入) Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Args(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>)
Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Args(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>)
Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Args(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>)
Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Args(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>)
Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Args(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>)
Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>)
Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Core(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>)
Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Core(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>)
Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>)
Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>)
Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Kernel(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>)
Only shuffle on 4 vectors (在4个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<long>)
Only shuffle on 4 vectors (在4个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>)
Only shuffle on 4 vectors (在4个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Only shuffle on 4 vectors (在4个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Only shuffle on 4 vectors (在4个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Only shuffle on 4 vectors (在4个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<int>)
Only shuffle on 4 vectors (在4个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>)
Only shuffle on 4 vectors (在4个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>)
Only shuffle on 4 vectors (在4个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>)
Only shuffle on 4 vectors (在4个向量上进行仅换位). Creates a new vector by selecting values from an input vectors using a set of indices (通过使用一组索引从输入向量集中选择值，来创建一个新向量). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Args(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>)
Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Args(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>)
Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Args(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>)
Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Args(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>)
Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Args(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>)
Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>)
Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Core(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>)
Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Core(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>)
Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>)
Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>)
Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4_Args(Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>, out Vector<byte>)
Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Args(Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>, out Vector<short>)
Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Args(Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>, out Vector<int>)
Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Args(Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>, out Vector<long>)
Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Args(Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>, out Vector<sbyte>)
Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Args(Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>, out Vector<ushort>)
Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Args(Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>, out Vector<uint>)
Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Args(Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>, out Vector<ulong>)
Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Core(Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>)
Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Core(Vector<double>, Vector<double>, Vector<double>, Vector<double>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Core(Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>, Vector<short>)
Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Core(Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Core(Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>, Vector<long>)
Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Core(Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>)
Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Core(Vector<float>, Vector<float>, Vector<float>, Vector<float>, Vector<int>, Vector<int>, Vector<int>, Vector<int>, Vector<int>)
Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Core(Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>)
Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Core(Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>)
Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Core(Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>)
Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YSign(Vector<double>)
Determine the sign of each element (判断各个元素的符号). Mnemonic:
rt[i] := sign(value[i]).
- YSign(Vector<short>)
Determine the sign of each element (判断各个元素的符号). Mnemonic:
rt[i] := sign(value[i]).
- YSign(Vector<int>)
Determine the sign of each element (判断各个元素的符号). Mnemonic:
rt[i] := sign(value[i]).
- YSign(Vector<long>)
Determine the sign of each element (判断各个元素的符号). Mnemonic:
rt[i] := sign(value[i]).
- YSign(Vector<sbyte>)
Determine the sign of each element (判断各个元素的符号). Mnemonic:
rt[i] := sign(value[i]).
- YSign(Vector<float>)
Determine the sign of each element (判断各个元素的符号). Mnemonic:
rt[i] := sign(value[i]).
- YSignFloat(Vector<double>)
Determine the sign of each element and returns a floating point number (判断各个元素的符号并返回浮点数). Mnemonic:
rt[i] := signFloat(value[i]).
- YSignFloat(Vector<float>)
Determine the sign of each element and returns a floating point number (判断各个元素的符号并返回浮点数). Mnemonic:
rt[i] := signFloat(value[i]).