Class VectorTraits128Abstract
- Namespace
- Zyl.VectorTraits.Impl.AVector
- Assembly
- VectorTraits.dll
Vector<T> traits 128 - abstract.
public abstract class VectorTraits128Abstract : VectorTraitsAbstract, IVectorTraits, IBaseTraits- Inheritance
-
VectorTraits128Abstract
- Implements
- Derived
- Inherited Members
-
VectorTraitsAbstract.YShuffleG4X2(Vector<float>, Vector<float>, ShuffleControlG4, out Vector<float>)VectorTraitsAbstract.YShuffleG4X2(Vector<sbyte>, Vector<sbyte>, ShuffleControlG4, out Vector<sbyte>)VectorTraitsAbstract.YShuffleG4X2(Vector<short>, Vector<short>, ShuffleControlG4, out Vector<short>)VectorTraitsAbstract.YShuffleG4X2(Vector<ulong>, Vector<ulong>, ShuffleControlG4, out Vector<ulong>)
- 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)
Fields
- ByteCountValue
ByteCount value
Properties
- ByteCount
Get byte count (取得字节数量).
- IsHardwareAccelerated
Whether to exist hardware accelerated (是否存在硬件加速).
- IsSupported
Whether to support the run (是否支持运行).
- 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时具有硬件加速的类型).
- Widen_AcceleratedTypes
Types with hardware acceleration when running
Widen(运行Widen时具有硬件加速的类型).
- 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时具有硬件加速的类型).
Methods
- GetBestInstance()
Get best instance.
- GetIsSupported(bool)
Gets it is support the run (取得它是否支持运行).
- GetUnsupportedMessage(bool)
Get unsupported messages (取得不支持时的消息).
- 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.
- 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]).
- 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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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.