Class IWVectorTraits256_Extensions
- Namespace
- Zyl.VectorTraits.Impl
- Assembly
- VectorTraits.dll
Extension methods of IWVectorTraits256 (IWVectorTraits256 的扩展方法)
public static class IWVectorTraits256_Extensions- Inheritance
-
IWVectorTraits256_Extensions
- Inherited Members
Methods
- GreaterThan_Unsigned(IWVectorTraits256, Vector256<byte>, Vector256<byte>)
Compares two vectors to determine which is unsigned greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个是无符号更大). Mnemonic:
rt[i] := (T)to_mask(asUnsigned(left[i]) > asUnsigned(right[i])).
- GreaterThan_Unsigned(IWVectorTraits256, Vector256<short>, Vector256<short>)
Compares two vectors to determine which is unsigned greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个是无符号更大). Mnemonic:
rt[i] := (T)to_mask(asUnsigned(left[i]) > asUnsigned(right[i])).
- GreaterThan_Unsigned(IWVectorTraits256, Vector256<int>, Vector256<int>)
Compares two vectors to determine which is unsigned greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个是无符号更大). Mnemonic:
rt[i] := (T)to_mask(asUnsigned(left[i]) > asUnsigned(right[i])).
- GreaterThan_Unsigned(IWVectorTraits256, Vector256<long>, Vector256<long>)
Compares two vectors to determine which is unsigned greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个是无符号更大). Mnemonic:
rt[i] := (T)to_mask(asUnsigned(left[i]) > asUnsigned(right[i])).
- GreaterThan_Unsigned(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>)
Compares two vectors to determine which is unsigned greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个是无符号更大). Mnemonic:
rt[i] := (T)to_mask(asUnsigned(left[i]) > asUnsigned(right[i])).
- GreaterThan_Unsigned(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>)
Compares two vectors to determine which is unsigned greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个是无符号更大). Mnemonic:
rt[i] := (T)to_mask(asUnsigned(left[i]) > asUnsigned(right[i])).
- GreaterThan_Unsigned(IWVectorTraits256, Vector256<uint>, Vector256<uint>)
Compares two vectors to determine which is unsigned greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个是无符号更大). Mnemonic:
rt[i] := (T)to_mask(asUnsigned(left[i]) > asUnsigned(right[i])).
- GreaterThan_Unsigned(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>)
Compares two vectors to determine which is unsigned greater on a per-element basis (比较两个向量，在每个元素的基础上确定哪个是无符号更大). Mnemonic:
rt[i] := (T)to_mask(asUnsigned(left[i]) > asUnsigned(right[i])).
- ShiftLeft_Args(IWVectorTraits256, Vector256<byte>, int)
Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Args(IWVectorTraits256, Vector256<short>, int)
Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Args(IWVectorTraits256, Vector256<int>, int)
Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Args(IWVectorTraits256, Vector256<long>, int)
Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Args(IWVectorTraits256, Vector256<sbyte>, int)
Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Args(IWVectorTraits256, Vector256<ushort>, int)
Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Args(IWVectorTraits256, Vector256<uint>, int)
Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Args(IWVectorTraits256, Vector256<ulong>, int)
Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftLeft_Args<T>(IWVectorTraits256, Vector256<T>, int)
Arguments calculation for shifts each element of a vector left by the specified amount (将向量的每个元素左移指定量的参数计算). Provide arguments for ShiftLeft_Core (为 ShiftLeft_Core 提供参数). Mnemonic:
rt[i] := value[i] << shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightArithmetic_Args(IWVectorTraits256, Vector256<short>, int)
Arguments calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的参数计算). Provide arguments for ShiftRightArithmetic_Core (为 ShiftRightArithmetic_Core 提供参数). Mnemonic:
rt[i] := value[i] >> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightArithmetic_Args(IWVectorTraits256, Vector256<int>, int)
Arguments calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的参数计算). Provide arguments for ShiftRightArithmetic_Core (为 ShiftRightArithmetic_Core 提供参数). Mnemonic:
rt[i] := value[i] >> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightArithmetic_Args(IWVectorTraits256, Vector256<long>, int)
Arguments calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的参数计算). Provide arguments for ShiftRightArithmetic_Core (为 ShiftRightArithmetic_Core 提供参数). Mnemonic:
rt[i] := value[i] >> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightArithmetic_Args(IWVectorTraits256, Vector256<sbyte>, int)
Arguments calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的参数计算). Provide arguments for ShiftRightArithmetic_Core (为 ShiftRightArithmetic_Core 提供参数). Mnemonic:
rt[i] := value[i] >> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightArithmetic_Args<T>(IWVectorTraits256, Vector256<T>, int)
Arguments calculation for shifts (signed) each element of a vector right by the specified amount (将向量的每个有符号元素算术右移指定量的参数计算). Provide arguments for ShiftRightArithmetic_Core (为 ShiftRightArithmetic_Core 提供参数). Mnemonic:
rt[i] := value[i] >> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Args(IWVectorTraits256, Vector256<byte>, int)
Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Args(IWVectorTraits256, Vector256<short>, int)
Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Args(IWVectorTraits256, Vector256<int>, int)
Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Args(IWVectorTraits256, Vector256<long>, int)
Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Args(IWVectorTraits256, Vector256<sbyte>, int)
Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Args(IWVectorTraits256, Vector256<ushort>, int)
Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Args(IWVectorTraits256, Vector256<uint>, int)
Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Args(IWVectorTraits256, Vector256<ulong>, int)
Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- ShiftRightLogical_Args<T>(IWVectorTraits256, Vector256<T>, int)
Arguments calculation for shifts (unsigned) each element of a vector right by the specified amount. (将向量的每个无符号元素逻辑右移指定量的参数计算). Provide arguments for ShiftRightLogical_Core (为 ShiftRightLogical_Core 提供参数). Mnemonic:
rt[i] := value[i] >>> shiftAmount,shiftAmount &= (T.BitSize-1).
- Shuffle_Args(IWVectorTraits256, Vector256<byte>)
Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Args(IWVectorTraits256, Vector256<short>)
Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Args(IWVectorTraits256, Vector256<int>)
Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Args(IWVectorTraits256, Vector256<long>)
Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Args(IWVectorTraits256, Vector256<sbyte>)
Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Args(IWVectorTraits256, Vector256<ushort>)
Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Args(IWVectorTraits256, Vector256<uint>)
Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Args(IWVectorTraits256, Vector256<ulong>)
Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>)
Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>)
Arguments calculation for shuffle and clear (换位并清零的参数计算). Provide arguments for Shuffle_Core (为 Shuffle_Core 提供参数). If the index value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Core(IWVectorTraits256, Vector256<byte>, (Vector256<byte> args0, Vector256<byte> args1))
Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Core(IWVectorTraits256, Vector256<double>, (Vector256<long> args0, Vector256<long> args1))
Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Core(IWVectorTraits256, Vector256<short>, (Vector256<short> args0, Vector256<short> args1))
Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Core(IWVectorTraits256, Vector256<int>, (Vector256<int> args0, Vector256<int> args1))
Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Core(IWVectorTraits256, Vector256<long>, (Vector256<long> args0, Vector256<long> args1))
Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Core(IWVectorTraits256, Vector256<sbyte>, (Vector256<sbyte> args0, Vector256<sbyte> args1))
Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Core(IWVectorTraits256, Vector256<float>, (Vector256<int> args0, Vector256<int> args1))
Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Core(IWVectorTraits256, Vector256<ushort>, (Vector256<ushort> args0, Vector256<ushort> args1))
Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Core(IWVectorTraits256, Vector256<uint>, (Vector256<uint> args0, Vector256<uint> args1))
Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Core(IWVectorTraits256, Vector256<ulong>, (Vector256<ulong> args0, Vector256<ulong> args1))
Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Shuffle_Core<T, TIdx>(IWVectorTraits256, Vector256<T>, (Vector256<TIdx> args0, Vector256<TIdx> args1))
Core calculation for shuffle and clear (换位并清零的核心计算). Its arguments are derived from Shuffle_Args (其参数来源于 Shuffle_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):0.
- Widen(IWVectorTraits256, Vector256<byte>)
Widens a Vector256<T> into two Vector256<T> instances - Generic version (将一个 Vector256<T> 扩宽为两个 Vector256<T> 实例 - 泛型版). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(IWVectorTraits256, Vector256<short>)
Widens a Vector256<T> into two Vector256<T> instances - Generic version (将一个 Vector256<T> 扩宽为两个 Vector256<T> 实例 - 泛型版). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(IWVectorTraits256, Vector256<int>)
Widens a Vector256<T> into two Vector256<T> instances - Generic version (将一个 Vector256<T> 扩宽为两个 Vector256<T> 实例 - 泛型版). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(IWVectorTraits256, Vector256<sbyte>)
Widens a Vector256<T> into two Vector256<T> instances - Generic version (将一个 Vector256<T> 扩宽为两个 Vector256<T> 实例 - 泛型版). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(IWVectorTraits256, Vector256<float>)
Widens a Vector256<T> into two Vector256<T> instances - Generic version (将一个 Vector256<T> 扩宽为两个 Vector256<T> 实例 - 泛型版). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(IWVectorTraits256, Vector256<ushort>)
Widens a Vector256<T> into two Vector256<T> instances - Generic version (将一个 Vector256<T> 扩宽为两个 Vector256<T> 实例 - 泛型版). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen(IWVectorTraits256, Vector256<uint>)
Widens a Vector256<T> into two Vector256<T> instances - Generic version (将一个 Vector256<T> 扩宽为两个 Vector256<T> 实例 - 泛型版). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- Widen<T, TOut>(IWVectorTraits256, Vector256<T>, out Vector256<TOut>, out Vector256<TOut>)
Widens a Vector256<T> into two Vector256<T> instances - Generic version (将一个 Vector256<T> 扩宽为两个 Vector256<T> 实例 - 泛型版). Mnemonic:
element_ref(i, lower, upper) := widen(source[i]).
- YGroup1ToGroup3(IWVectorTraits256, Vector256<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(IWVectorTraits256, Vector256<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(IWVectorTraits256, Vector256<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(IWVectorTraits256, Vector256<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(IWVectorTraits256, Vector256<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(IWVectorTraits256, Vector256<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(IWVectorTraits256, Vector256<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(IWVectorTraits256, Vector256<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(IWVectorTraits256, Vector256<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(IWVectorTraits256, Vector256<ulong>)
Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(x, x, x). View for element:element_ref(i, result0, result1, result2) := x[i/3].
- YGroup1ToGroup3<T>(IWVectorTraits256, Vector256<T>)
Convert a 1-element group, to a 3-element group. It also converts grayscale pixel data to packed RGB pixel data (将1-元素组, 转为3-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(x, x, x). View for element:element_ref(i, result0, result1, result2) := x[i/3].
- YGroup1ToGroup4(IWVectorTraits256, Vector256<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(IWVectorTraits256, Vector256<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(IWVectorTraits256, Vector256<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(IWVectorTraits256, Vector256<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(IWVectorTraits256, Vector256<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(IWVectorTraits256, Vector256<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(IWVectorTraits256, Vector256<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(IWVectorTraits256, Vector256<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(IWVectorTraits256, Vector256<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(IWVectorTraits256, Vector256<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(IWVectorTraits256, Vector256<byte>, Vector256<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(IWVectorTraits256, Vector256<double>, Vector256<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(IWVectorTraits256, Vector256<short>, Vector256<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(IWVectorTraits256, Vector256<int>, Vector256<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(IWVectorTraits256, Vector256<long>, Vector256<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(IWVectorTraits256, Vector256<sbyte>, Vector256<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(IWVectorTraits256, Vector256<float>, Vector256<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(IWVectorTraits256, Vector256<ushort>, Vector256<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(IWVectorTraits256, Vector256<uint>, Vector256<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(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>)
Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element:element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ),i2 := i/4.
- YGroup1ToGroup4WithW<T>(IWVectorTraits256, Vector256<T>, Vector256<T>)
Convert a 1-element group and w argument, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组及w参数, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, w). View for element:element_ref(i, result0, result1, result2, result4) := ((i%4)<3)?( x[i2] ):( w[i2] ),i2 := i/4.
- YGroup1ToGroup4<T>(IWVectorTraits256, Vector256<T>)
Convert a 1-element group, to a 4-element group. It also converts grayscale pixel data to packed RGBA pixel data (将1-元素组, 转为4-元素组. 它还能将 灰度像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result4) = YGroup4Zip(x, x, x, x). View for element:element_ref(i, result0, result1, result2, result4) := x[i/4].
- YGroup2Transpose(IWVectorTraits256, Vector256<byte>, Vector256<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(IWVectorTraits256, Vector256<double>, Vector256<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(IWVectorTraits256, Vector256<short>, Vector256<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(IWVectorTraits256, Vector256<int>, Vector256<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(IWVectorTraits256, Vector256<long>, Vector256<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(IWVectorTraits256, Vector256<sbyte>, Vector256<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(IWVectorTraits256, Vector256<float>, Vector256<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(IWVectorTraits256, Vector256<ushort>, Vector256<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(IWVectorTraits256, Vector256<uint>, Vector256<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(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>)
Transpose a 22 matrix (对22矩阵进行转置). Mnemonic:
result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ),result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2Transpose<T>(IWVectorTraits256, Vector256<T>, Vector256<T>)
Transpose a 22 matrix (对22矩阵进行转置). Mnemonic:
result0[i] := (0==(i&1))?( x[i&~1] ):( y[i&~1] ),result1[i] := (0==(i&1))?( x[(i&~1) + 1] ):( y[(i&~1) + 1] ).
- YGroup2Unzip(IWVectorTraits256, Vector256<byte>, Vector256<byte>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(IWVectorTraits256, Vector256<double>, Vector256<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(IWVectorTraits256, Vector256<Int128>, Vector256<Int128>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(IWVectorTraits256, Vector256<Int128>, Vector256<Int128>, out Vector256<Int128>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(IWVectorTraits256, Vector256<short>, Vector256<short>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(IWVectorTraits256, Vector256<int>, Vector256<int>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(IWVectorTraits256, Vector256<long>, Vector256<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(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(IWVectorTraits256, Vector256<float>, Vector256<float>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(IWVectorTraits256, Vector256<UInt128>, Vector256<UInt128>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(IWVectorTraits256, Vector256<UInt128>, Vector256<UInt128>, out Vector256<UInt128>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(IWVectorTraits256, Vector256<uint>, Vector256<uint>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Unzip(IWVectorTraits256, Vector256<ulong>, Vector256<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(IWVectorTraits256, Vector256<ExInt128>, Vector256<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(IWVectorTraits256, Vector256<ExUInt128>, Vector256<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(IWVectorTraits256, Vector256<Int128>, Vector256<Int128>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i, data0, data1).
- YGroup2UnzipEven(IWVectorTraits256, Vector256<UInt128>, Vector256<UInt128>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i, data0, data1).
- YGroup2UnzipEven<T>(IWVectorTraits256, Vector256<T>, Vector256<T>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of even positions (将2-元素组解交织为2个向量, 并返回偶数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i, data0, data1).
- YGroup2UnzipOdd(IWVectorTraits256, Vector256<Int128>, Vector256<Int128>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i+1, data0, data1).
- YGroup2UnzipOdd(IWVectorTraits256, Vector256<UInt128>, Vector256<UInt128>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i+1, data0, data1).
- YGroup2UnzipOdd<T>(IWVectorTraits256, Vector256<T>, Vector256<T>)
De-Interleave the 2-element groups into 2 vectors, and return the vector of odd positions (将2-元素组解交织为2个向量, 并返回奇数位置的数据). Mnemonic:
rt[i] =: element_ref(2*i+1, data0, data1).
- YGroup2Unzip<T>(IWVectorTraits256, Vector256<T>, Vector256<T>)
De-Interleave 2-element groups into 2 vectors. It converts the 2-element groups AoS to SoA (将2-元素组解交织为2个向量. 它能将2元素组的 数组结构体 转为 结构体数组). Mnemonic:
x[i] =: element_ref(2i, data0, data1),y[i] =: element_ref(2i+1, data0, data1).
- YGroup2Zip(IWVectorTraits256, Vector256<byte>, Vector256<byte>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(IWVectorTraits256, Vector256<double>, Vector256<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(IWVectorTraits256, Vector256<Int128>, Vector256<Int128>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(IWVectorTraits256, Vector256<Int128>, Vector256<Int128>, out Vector256<Int128>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(IWVectorTraits256, Vector256<short>, Vector256<short>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(IWVectorTraits256, Vector256<int>, Vector256<int>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(IWVectorTraits256, Vector256<long>, Vector256<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(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(IWVectorTraits256, Vector256<float>, Vector256<float>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(IWVectorTraits256, Vector256<UInt128>, Vector256<UInt128>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(IWVectorTraits256, Vector256<UInt128>, Vector256<UInt128>, out Vector256<UInt128>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(IWVectorTraits256, Vector256<uint>, Vector256<uint>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip(IWVectorTraits256, Vector256<ulong>, Vector256<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(IWVectorTraits256, Vector256<ExInt128>, Vector256<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(IWVectorTraits256, Vector256<ExUInt128>, Vector256<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(IWVectorTraits256, Vector256<Int128>, Vector256<Int128>)
Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := (i+T.Count)/2.
- YGroup2ZipHigh(IWVectorTraits256, Vector256<UInt128>, Vector256<UInt128>)
Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := (i+T.Count)/2.
- YGroup2ZipHigh<T>(IWVectorTraits256, Vector256<T>, Vector256<T>)
Interleave 2 vectors into 2-element groups and returns the data in the high position. (将2个向量交织为2-元素组, 并返回高位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := (i+T.Count)/2.
- YGroup2ZipLow(IWVectorTraits256, Vector256<Int128>, Vector256<Int128>)
Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2ZipLow(IWVectorTraits256, Vector256<UInt128>, Vector256<UInt128>)
Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2ZipLow<T>(IWVectorTraits256, Vector256<T>, Vector256<T>)
Interleave 2 vectors into 2-element groups and returns the data in the low position. (将2个向量交织为2-元素组, 并返回低位置的数据). Mnemonic:
rt[i] := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup2Zip<T>(IWVectorTraits256, Vector256<T>, Vector256<T>)
Interleave 2 vectors into 2-element groups. It converts the 2-element groups SoA to AoS (将2个向量交织为2-元素组. 它能将2元素组的 结构体数组 转为 数组结构体). Mnemonic:
element_ref(i, data0, data1) := (0==(i&1))?( x[i2] ):( y[i2] ),i2 := i/2.
- YGroup3ToGroup4(IWVectorTraits256, Vector256<byte>, Vector256<byte>, Vector256<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(IWVectorTraits256, Vector256<double>, Vector256<double>, Vector256<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(IWVectorTraits256, Vector256<short>, Vector256<short>, Vector256<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(IWVectorTraits256, Vector256<int>, Vector256<int>, Vector256<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(IWVectorTraits256, Vector256<long>, Vector256<long>, Vector256<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(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>, Vector256<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(IWVectorTraits256, Vector256<float>, Vector256<float>, Vector256<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(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>, Vector256<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(IWVectorTraits256, Vector256<uint>, Vector256<uint>, Vector256<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(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>)
Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将 已打包的RGB像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element:element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.
- YGroup3ToGroup4<T>(IWVectorTraits256, Vector256<T>, Vector256<T>, Vector256<T>)
Convert a 3-element group, to a 4-element group. It also converts packed RGB pixel data to packed RGBA pixel data (将3-元素组, 转为4-元素组. 它还能将 已打包的RGB像素数据, 转换为 已打包的RGBA像素数据). Mnemonic: View for group:
(result0, result1, result2, result3) = YGroup4Zip(YGroup3Unzip(data0, data1, data2), Vector.Zero)). View for element:element_ref(i, result0, result1, result2, result3) := (3!=(i%4))?element_ref((i/4)*3+(i%4), data0, data1, data2):0.
- YGroup3Unzip(IWVectorTraits256, Vector256<byte>, Vector256<byte>, Vector256<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(IWVectorTraits256, Vector256<double>, Vector256<double>, Vector256<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(IWVectorTraits256, Vector256<short>, Vector256<short>, Vector256<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(IWVectorTraits256, Vector256<int>, Vector256<int>, Vector256<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(IWVectorTraits256, Vector256<long>, Vector256<long>, Vector256<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(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>, Vector256<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(IWVectorTraits256, Vector256<float>, Vector256<float>, Vector256<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(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>, Vector256<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(IWVectorTraits256, Vector256<uint>, Vector256<uint>, Vector256<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(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>, Vector256<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(IWVectorTraits256, Vector256<byte>, Vector256<byte>, Vector256<byte>, Vector256<byte>, Vector256<byte>, Vector256<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(IWVectorTraits256, Vector256<double>, Vector256<double>, Vector256<double>, Vector256<double>, Vector256<double>, Vector256<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(IWVectorTraits256, Vector256<short>, Vector256<short>, Vector256<short>, Vector256<short>, Vector256<short>, Vector256<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(IWVectorTraits256, Vector256<int>, Vector256<int>, Vector256<int>, Vector256<int>, Vector256<int>, Vector256<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(IWVectorTraits256, Vector256<long>, Vector256<long>, Vector256<long>, Vector256<long>, Vector256<long>, Vector256<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(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>, Vector256<sbyte>, Vector256<sbyte>, Vector256<sbyte>, Vector256<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(IWVectorTraits256, Vector256<float>, Vector256<float>, Vector256<float>, Vector256<float>, Vector256<float>, Vector256<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(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>, Vector256<ushort>, Vector256<ushort>, Vector256<ushort>, Vector256<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(IWVectorTraits256, Vector256<uint>, Vector256<uint>, Vector256<uint>, Vector256<uint>, Vector256<uint>, Vector256<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(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>, Vector256<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<T>(IWVectorTraits256, Vector256<T>, Vector256<T>, Vector256<T>, Vector256<T>, Vector256<T>, Vector256<T>)
De-Interleave 3-element groups into 3 vectors and process 2x data (将3-元素组解交织为3个向量, 且处理2倍数据). Mnemonic:
(x, y, z) = YGroup3Unzip(data0, data1, data2),(xB, yB, zB) = YGroup3Unzip(data3, data4, data5).
- YGroup3Unzip<T>(IWVectorTraits256, Vector256<T>, Vector256<T>, Vector256<T>)
De-Interleave 3-element groups into 3 vectors. It converts the 3-element groups AoS to SoA. It can also deinterleave packed RGB pixel data into R,G,B planar data (将3-元素组解交织为3个向量. 它能将3元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGB像素数据, 解交织为 R,G,B 平面数据). Mnemonic:
x[i] =: element_ref(3i, data0, data1, data2),y[i] =: element_ref(3i+1, data0, data1, data2),z[i] =: element_ref(3*i+2, data0, data1, data2).
- YGroup3Zip(IWVectorTraits256, Vector256<byte>, Vector256<byte>, Vector256<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(IWVectorTraits256, Vector256<double>, Vector256<double>, Vector256<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(IWVectorTraits256, Vector256<short>, Vector256<short>, Vector256<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(IWVectorTraits256, Vector256<int>, Vector256<int>, Vector256<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(IWVectorTraits256, Vector256<long>, Vector256<long>, Vector256<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(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>, Vector256<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(IWVectorTraits256, Vector256<float>, Vector256<float>, Vector256<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(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>, Vector256<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(IWVectorTraits256, Vector256<uint>, Vector256<uint>, Vector256<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(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>, Vector256<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(IWVectorTraits256, Vector256<byte>, Vector256<byte>, Vector256<byte>, Vector256<byte>, Vector256<byte>, Vector256<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(IWVectorTraits256, Vector256<double>, Vector256<double>, Vector256<double>, Vector256<double>, Vector256<double>, Vector256<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(IWVectorTraits256, Vector256<short>, Vector256<short>, Vector256<short>, Vector256<short>, Vector256<short>, Vector256<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(IWVectorTraits256, Vector256<int>, Vector256<int>, Vector256<int>, Vector256<int>, Vector256<int>, Vector256<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(IWVectorTraits256, Vector256<long>, Vector256<long>, Vector256<long>, Vector256<long>, Vector256<long>, Vector256<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(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>, Vector256<sbyte>, Vector256<sbyte>, Vector256<sbyte>, Vector256<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(IWVectorTraits256, Vector256<float>, Vector256<float>, Vector256<float>, Vector256<float>, Vector256<float>, Vector256<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(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>, Vector256<ushort>, Vector256<ushort>, Vector256<ushort>, Vector256<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(IWVectorTraits256, Vector256<uint>, Vector256<uint>, Vector256<uint>, Vector256<uint>, Vector256<uint>, Vector256<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(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>, Vector256<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<T>(IWVectorTraits256, Vector256<T>, Vector256<T>, Vector256<T>, Vector256<T>, Vector256<T>, Vector256<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<T>(IWVectorTraits256, Vector256<T>, Vector256<T>, Vector256<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(IWVectorTraits256, Vector256<byte>, Vector256<byte>, Vector256<byte>, Vector256<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(IWVectorTraits256, Vector256<double>, Vector256<double>, Vector256<double>, Vector256<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(IWVectorTraits256, Vector256<short>, Vector256<short>, Vector256<short>, Vector256<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(IWVectorTraits256, Vector256<int>, Vector256<int>, Vector256<int>, Vector256<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(IWVectorTraits256, Vector256<long>, Vector256<long>, Vector256<long>, Vector256<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(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>, Vector256<sbyte>, Vector256<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(IWVectorTraits256, Vector256<float>, Vector256<float>, Vector256<float>, Vector256<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(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>, Vector256<ushort>, Vector256<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(IWVectorTraits256, Vector256<uint>, Vector256<uint>, Vector256<uint>, Vector256<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(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>)
Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将 已打包的RGBA像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element:element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).
- YGroup4ToGroup3<T>(IWVectorTraits256, Vector256<T>, Vector256<T>, Vector256<T>, Vector256<T>)
Convert a 4-element group, to a 3-element group. It also converts packed RGBA pixel data to packed RGB pixel data (将4-元素组, 转为3-元素组. 它还能将 已打包的RGBA像素数据, 转换为 已打包的RGB像素数据). Mnemonic: View for group:
(result0, result1, result2) = YGroup3Zip(YGroup4Unzip(data0, data1, data2, data3))). View for element:element_ref(i, result0, result1, result2) := element_ref((i/3)*4+(i%3), data0, data1, data2, data3).
- YGroup4Unzip(IWVectorTraits256, Vector256<byte>, Vector256<byte>, Vector256<byte>, Vector256<byte>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(IWVectorTraits256, Vector256<double>, Vector256<double>, Vector256<double>, Vector256<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(IWVectorTraits256, Vector256<Int128>, Vector256<Int128>, Vector256<Int128>, Vector256<Int128>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(IWVectorTraits256, Vector256<Int128>, Vector256<Int128>, Vector256<Int128>, Vector256<Int128>, out Vector256<Int128>, out Vector256<Int128>, out Vector256<Int128>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(IWVectorTraits256, Vector256<short>, Vector256<short>, Vector256<short>, Vector256<short>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(IWVectorTraits256, Vector256<int>, Vector256<int>, Vector256<int>, Vector256<int>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(IWVectorTraits256, Vector256<long>, Vector256<long>, Vector256<long>, Vector256<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(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>, Vector256<sbyte>, Vector256<sbyte>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(IWVectorTraits256, Vector256<float>, Vector256<float>, Vector256<float>, Vector256<float>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(IWVectorTraits256, Vector256<UInt128>, Vector256<UInt128>, Vector256<UInt128>, Vector256<UInt128>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(IWVectorTraits256, Vector256<UInt128>, Vector256<UInt128>, Vector256<UInt128>, Vector256<UInt128>, out Vector256<UInt128>, out Vector256<UInt128>, out Vector256<UInt128>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>, Vector256<ushort>, Vector256<ushort>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(IWVectorTraits256, Vector256<uint>, Vector256<uint>, Vector256<uint>, Vector256<uint>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Unzip(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>, Vector256<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(IWVectorTraits256, Vector256<ExInt128>, Vector256<ExInt128>, Vector256<ExInt128>, Vector256<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(IWVectorTraits256, Vector256<ExUInt128>, Vector256<ExUInt128>, Vector256<ExUInt128>, Vector256<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<T>(IWVectorTraits256, Vector256<T>, Vector256<T>, Vector256<T>, Vector256<T>)
De-Interleave 4-element groups into 4 vectors. It converts the 4-element groups AoS to SoA. It can also deinterleave packed RGBA pixel data into R,G,B,A planar data (将4-元素组解交织为4个向量. 它能将4元素组的 数组结构体 转为 结构体数组. 它还能将 已打包的RGBA像素数据, 解交织为 R,G,B,A 平面数据). Mnemonic:
x[i] =: element_ref(4i, data0, data1, data2, data3),y[i] =: element_ref(4i+1, data0, data1, data2, data3),z[i] =: element_ref(4i+2, data0, data1, data2, data3),w[i] =: element_ref(4i+3, data0, data1, data2, data3).
- YGroup4Zip(IWVectorTraits256, Vector256<Int128>, Vector256<Int128>, Vector256<Int128>, Vector256<Int128>, out Vector256<Int128>, out Vector256<Int128>, out Vector256<Int128>)
Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B,A 平面数据, 交织为 已打包的RGBA像素数据). Mnemonic:
element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ),i2 := i/4.
- YGroup4Zip(IWVectorTraits256, Vector256<float>, Vector256<float>, Vector256<float>, Vector256<float>)
Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B,A 平面数据, 交织为 已打包的RGBA像素数据). Mnemonic:
element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ),i2 := i/4.
- YGroup4Zip(IWVectorTraits256, Vector256<UInt128>, Vector256<UInt128>, Vector256<UInt128>, Vector256<UInt128>, out Vector256<UInt128>, out Vector256<UInt128>, out Vector256<UInt128>)
Interleave 4 vectors into 4-element groups. It converts the 4-element groups SoA to AoS. It can also interleave R,G,B,A planar data into packed RGBA pixel data (将4个向量交织为4-元素组. 它能将4元素组的 结构体数组 转为 数组结构体. 它还能将 R,G,B,A 平面数据, 交织为 已打包的RGBA像素数据). Mnemonic:
element_ref(i, data0, data1, data2, data3) := (0==(i&3))?( x[i2] ):( (1==(i&3))?( y[i2] ):( (2==(i&s3))?( z[i2] ):( w[i2] ) ) ),i2 := i/4.
- YShuffleG4X2(IWVectorTraits256, Vector256<byte>, Vector256<byte>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2(IWVectorTraits256, Vector256<double>, Vector256<double>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2(IWVectorTraits256, Vector256<short>, Vector256<short>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2(IWVectorTraits256, Vector256<int>, Vector256<int>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2(IWVectorTraits256, Vector256<long>, Vector256<long>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2(IWVectorTraits256, Vector256<float>, Vector256<float>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2(IWVectorTraits256, Vector256<uint>, Vector256<uint>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2_Const(IWVectorTraits256, Vector256<byte>, Vector256<byte>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2_Const(IWVectorTraits256, Vector256<double>, Vector256<double>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2_Const(IWVectorTraits256, Vector256<short>, Vector256<short>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2_Const(IWVectorTraits256, Vector256<int>, Vector256<int>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2_Const(IWVectorTraits256, Vector256<long>, Vector256<long>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2_Const(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2_Const(IWVectorTraits256, Vector256<float>, Vector256<float>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2_Const(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2_Const(IWVectorTraits256, Vector256<uint>, Vector256<uint>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2_Const(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2_Const<T>(IWVectorTraits256, Vector256<T>, Vector256<T>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed - Constant version (对于两个向量中的每个 4-元素组, 进行换位 - 常量版). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleG4X2<T>(IWVectorTraits256, Vector256<T>, Vector256<T>, ShuffleControlG4)
For each 4-element groups in two vector, shuffle is performed (对于两个向量中的每个 4-元素组, 进行换位). Mnemonic: View for group:
rt.xyzw = shuffleG4_ref(control, source0, source1). View for element:element_ref(i, result0, result1) := element_ref((i&(~3)) | ((control >> ((i&3)*2)) & 3), source0, source1).
- YShuffleInsert_Args(IWVectorTraits256, Vector256<byte>)
Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Args(IWVectorTraits256, Vector256<short>)
Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Args(IWVectorTraits256, Vector256<int>)
Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Args(IWVectorTraits256, Vector256<long>)
Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Args(IWVectorTraits256, Vector256<sbyte>)
Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Args(IWVectorTraits256, Vector256<ushort>)
Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Args(IWVectorTraits256, Vector256<uint>)
Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Args(IWVectorTraits256, Vector256<ulong>)
Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>)
Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>)
Arguments calculation for shuffle and insert (换位并插入的参数计算). Provide arguments for YShuffleInsert_Core (为 YShuffleInsert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Core(IWVectorTraits256, Vector256<byte>, Vector256<byte>, (Vector256<byte> args0, Vector256<byte> args1, Vector256<byte> args2))
Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Core(IWVectorTraits256, Vector256<double>, Vector256<double>, (Vector256<long> args0, Vector256<long> args1, Vector256<long> args2))
Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Core(IWVectorTraits256, Vector256<short>, Vector256<short>, (Vector256<short> args0, Vector256<short> args1, Vector256<short> args2))
Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Core(IWVectorTraits256, Vector256<int>, Vector256<int>, (Vector256<int> args0, Vector256<int> args1, Vector256<int> args2))
Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Core(IWVectorTraits256, Vector256<long>, Vector256<long>, (Vector256<long> args0, Vector256<long> args1, Vector256<long> args2))
Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Core(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>, (Vector256<sbyte> args0, Vector256<sbyte> args1, Vector256<sbyte> args2))
Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Core(IWVectorTraits256, Vector256<float>, Vector256<float>, (Vector256<int> args0, Vector256<int> args1, Vector256<int> args2))
Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Core(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>, (Vector256<ushort> args0, Vector256<ushort> args1, Vector256<ushort> args2))
Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Core(IWVectorTraits256, Vector256<uint>, Vector256<uint>, (Vector256<uint> args0, Vector256<uint> args1, Vector256<uint> args2))
Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Core(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>, (Vector256<ulong> args0, Vector256<ulong> args1, Vector256<ulong> args2))
Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleInsert_Core<T, TIdx>(IWVectorTraits256, Vector256<T>, Vector256<T>, (Vector256<TIdx> args0, Vector256<TIdx> args1, Vector256<TIdx> args2))
Core calculation for shuffle and insert (换位并插入的核心计算). Its arguments are derived from YShuffleInsert_Args (其参数来源于 YShuffleInsert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<Count)?( vector[indices[i]] ):back[i].
- YShuffleKernel_Args(IWVectorTraits256, Vector256<byte>)
Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Args(IWVectorTraits256, Vector256<short>)
Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Args(IWVectorTraits256, Vector256<int>)
Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Args(IWVectorTraits256, Vector256<long>)
Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Args(IWVectorTraits256, Vector256<sbyte>)
Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Args(IWVectorTraits256, Vector256<ushort>)
Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Args(IWVectorTraits256, Vector256<uint>)
Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Args(IWVectorTraits256, Vector256<ulong>)
Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>)
Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>)
Arguments calculation for only shuffle (仅换位的参数计算). Provide arguments for YShuffleKernel_Core (为 YShuffleKernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexMask to constrain the parameters (可使用 IndexMask 掩码来约束参数). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Core(IWVectorTraits256, Vector256<byte>, (Vector256<byte> args0, Vector256<byte> args1))
Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Core(IWVectorTraits256, Vector256<double>, (Vector256<long> args0, Vector256<long> args1))
Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Core(IWVectorTraits256, Vector256<short>, (Vector256<short> args0, Vector256<short> args1))
Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Core(IWVectorTraits256, Vector256<int>, (Vector256<int> args0, Vector256<int> args1))
Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Core(IWVectorTraits256, Vector256<long>, (Vector256<long> args0, Vector256<long> args1))
Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Core(IWVectorTraits256, Vector256<sbyte>, (Vector256<sbyte> args0, Vector256<sbyte> args1))
Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Core(IWVectorTraits256, Vector256<float>, (Vector256<int> args0, Vector256<int> args1))
Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Core(IWVectorTraits256, Vector256<ushort>, (Vector256<ushort> args0, Vector256<ushort> args1))
Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Core(IWVectorTraits256, Vector256<uint>, (Vector256<uint> args0, Vector256<uint> args1))
Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Core(IWVectorTraits256, Vector256<ulong>, (Vector256<ulong> args0, Vector256<ulong> args1))
Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleKernel_Core<T, TIdx>(IWVectorTraits256, Vector256<T>, (Vector256<TIdx> args0, Vector256<TIdx> args1))
Core calculation for only shuffle (仅换位的核心计算). Its arguments are derived from YShuffleKernel_Args (其参数来源于 YShuffleKernel_Args). Mnemonic:
rt[i] := vector[indices[i]]. Conditions:0<=indices[i] && indices[i]<Count.
- YShuffleX2Insert_Args(IWVectorTraits256, Vector256<byte>)
Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Args(IWVectorTraits256, Vector256<short>)
Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Args(IWVectorTraits256, Vector256<int>)
Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Args(IWVectorTraits256, Vector256<long>)
Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Args(IWVectorTraits256, Vector256<sbyte>)
Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Args(IWVectorTraits256, Vector256<ushort>)
Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Args(IWVectorTraits256, Vector256<uint>)
Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Args(IWVectorTraits256, Vector256<ulong>)
Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>)
Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>)
Arguments calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX2Insert_Core (为 YShuffleX2Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Core(IWVectorTraits256, Vector256<byte>, Vector256<byte>, Vector256<byte>, (Vector256<byte> args0, Vector256<byte> args1, Vector256<byte> args2, Vector256<byte> args3, Vector256<byte> args4))
Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Core(IWVectorTraits256, Vector256<double>, Vector256<double>, Vector256<double>, (Vector256<long> args0, Vector256<long> args1, Vector256<long> args2, Vector256<long> args3, Vector256<long> args4))
Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Core(IWVectorTraits256, Vector256<short>, Vector256<short>, Vector256<short>, (Vector256<short> args0, Vector256<short> args1, Vector256<short> args2, Vector256<short> args3, Vector256<short> args4))
Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Core(IWVectorTraits256, Vector256<int>, Vector256<int>, Vector256<int>, (Vector256<int> args0, Vector256<int> args1, Vector256<int> args2, Vector256<int> args3, Vector256<int> args4))
Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Core(IWVectorTraits256, Vector256<long>, Vector256<long>, Vector256<long>, (Vector256<long> args0, Vector256<long> args1, Vector256<long> args2, Vector256<long> args3, Vector256<long> args4))
Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Core(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>, Vector256<sbyte>, (Vector256<sbyte> args0, Vector256<sbyte> args1, Vector256<sbyte> args2, Vector256<sbyte> args3, Vector256<sbyte> args4))
Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Core(IWVectorTraits256, Vector256<float>, Vector256<float>, Vector256<float>, (Vector256<int> args0, Vector256<int> args1, Vector256<int> args2, Vector256<int> args3, Vector256<int> args4))
Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Core(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>, Vector256<ushort>, (Vector256<ushort> args0, Vector256<ushort> args1, Vector256<ushort> args2, Vector256<ushort> args3, Vector256<ushort> args4))
Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Core(IWVectorTraits256, Vector256<uint>, Vector256<uint>, Vector256<uint>, (Vector256<uint> args0, Vector256<uint> args1, Vector256<uint> args2, Vector256<uint> args3, Vector256<uint> args4))
Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Core(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>, (Vector256<ulong> args0, Vector256<ulong> args1, Vector256<ulong> args2, Vector256<ulong> args3, Vector256<ulong> args4))
Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Insert_Core<T, TIdx>(IWVectorTraits256, Vector256<T>, Vector256<T>, Vector256<T>, (Vector256<TIdx> args0, Vector256<TIdx> args1, Vector256<TIdx> args2, Vector256<TIdx> args3, Vector256<TIdx> args4))
Core calculation for shuffle and insert on 2 vectors (在2个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX2Insert_Args (其参数来源于 YShuffleX2Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):back[i].
- YShuffleX2Kernel_Args(IWVectorTraits256, Vector256<byte>)
Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Args(IWVectorTraits256, Vector256<short>)
Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Args(IWVectorTraits256, Vector256<int>)
Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Args(IWVectorTraits256, Vector256<long>)
Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Args(IWVectorTraits256, Vector256<sbyte>)
Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Args(IWVectorTraits256, Vector256<ushort>)
Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Args(IWVectorTraits256, Vector256<uint>)
Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Args(IWVectorTraits256, Vector256<ulong>)
Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>)
Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>)
Arguments calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的参数计算). Provide arguments for YShuffleX2Kernel_Core (为 YShuffleX2Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX2Mask to constrain the parameters (可使用 IndexX2Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Core(IWVectorTraits256, Vector256<byte>, Vector256<byte>, (Vector256<byte> args0, Vector256<byte> args1, Vector256<byte> args2, Vector256<byte> args3))
Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Core(IWVectorTraits256, Vector256<double>, Vector256<double>, (Vector256<long> args0, Vector256<long> args1, Vector256<long> args2, Vector256<long> args3))
Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Core(IWVectorTraits256, Vector256<short>, Vector256<short>, (Vector256<short> args0, Vector256<short> args1, Vector256<short> args2, Vector256<short> args3))
Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Core(IWVectorTraits256, Vector256<int>, Vector256<int>, (Vector256<int> args0, Vector256<int> args1, Vector256<int> args2, Vector256<int> args3))
Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Core(IWVectorTraits256, Vector256<long>, Vector256<long>, (Vector256<long> args0, Vector256<long> args1, Vector256<long> args2, Vector256<long> args3))
Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Core(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>, (Vector256<sbyte> args0, Vector256<sbyte> args1, Vector256<sbyte> args2, Vector256<sbyte> args3))
Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Core(IWVectorTraits256, Vector256<float>, Vector256<float>, (Vector256<int> args0, Vector256<int> args1, Vector256<int> args2, Vector256<int> args3))
Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Core(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>, (Vector256<ushort> args0, Vector256<ushort> args1, Vector256<ushort> args2, Vector256<ushort> args3))
Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Core(IWVectorTraits256, Vector256<uint>, Vector256<uint>, (Vector256<uint> args0, Vector256<uint> args1, Vector256<uint> args2, Vector256<uint> args3))
Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Core(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>, (Vector256<ulong> args0, Vector256<ulong> args1, Vector256<ulong> args2, Vector256<ulong> args3))
Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2Kernel_Core<T, TIdx>(IWVectorTraits256, Vector256<T>, Vector256<T>, (Vector256<TIdx> args0, Vector256<TIdx> args1, Vector256<TIdx> args2, Vector256<TIdx> args3))
Core calculation for only shuffle on 2 vectors (在2个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX2Kernel_Args (其参数来源于 YShuffleX2Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1). Conditions:0<=indices[i] && indices[i]<(Count*2).
- YShuffleX2_Args(IWVectorTraits256, Vector256<byte>)
Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Args(IWVectorTraits256, Vector256<short>)
Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Args(IWVectorTraits256, Vector256<int>)
Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Args(IWVectorTraits256, Vector256<long>)
Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Args(IWVectorTraits256, Vector256<sbyte>)
Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Args(IWVectorTraits256, Vector256<ushort>)
Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Args(IWVectorTraits256, Vector256<uint>)
Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Args(IWVectorTraits256, Vector256<ulong>)
Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>)
Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>)
Arguments calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX2_Core (为 YShuffleX2_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Core(IWVectorTraits256, Vector256<byte>, Vector256<byte>, (Vector256<byte> args0, Vector256<byte> args1, Vector256<byte> args2, Vector256<byte> args3, Vector256<byte> args4))
Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Core(IWVectorTraits256, Vector256<double>, Vector256<double>, (Vector256<long> args0, Vector256<long> args1, Vector256<long> args2, Vector256<long> args3, Vector256<long> args4))
Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Core(IWVectorTraits256, Vector256<short>, Vector256<short>, (Vector256<short> args0, Vector256<short> args1, Vector256<short> args2, Vector256<short> args3, Vector256<short> args4))
Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Core(IWVectorTraits256, Vector256<int>, Vector256<int>, (Vector256<int> args0, Vector256<int> args1, Vector256<int> args2, Vector256<int> args3, Vector256<int> args4))
Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Core(IWVectorTraits256, Vector256<long>, Vector256<long>, (Vector256<long> args0, Vector256<long> args1, Vector256<long> args2, Vector256<long> args3, Vector256<long> args4))
Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Core(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>, (Vector256<sbyte> args0, Vector256<sbyte> args1, Vector256<sbyte> args2, Vector256<sbyte> args3, Vector256<sbyte> args4))
Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Core(IWVectorTraits256, Vector256<float>, Vector256<float>, (Vector256<int> args0, Vector256<int> args1, Vector256<int> args2, Vector256<int> args3, Vector256<int> args4))
Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Core(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>, (Vector256<ushort> args0, Vector256<ushort> args1, Vector256<ushort> args2, Vector256<ushort> args3, Vector256<ushort> args4))
Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Core(IWVectorTraits256, Vector256<uint>, Vector256<uint>, (Vector256<uint> args0, Vector256<uint> args1, Vector256<uint> args2, Vector256<uint> args3, Vector256<uint> args4))
Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Core(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>, (Vector256<ulong> args0, Vector256<ulong> args1, Vector256<ulong> args2, Vector256<ulong> args3, Vector256<ulong> args4))
Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX2_Core<T, TIdx>(IWVectorTraits256, Vector256<T>, Vector256<T>, (Vector256<TIdx> args0, Vector256<TIdx> args1, Vector256<TIdx> args2, Vector256<TIdx> args3, Vector256<TIdx> args4))
Core calculation for shuffle and clear on 2 vectors (在2个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX2_Args (其参数来源于 YShuffleX2_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*2))?( element_ref(indices[i], vector0, vector1) ):0.
- YShuffleX3Insert_Args(IWVectorTraits256, Vector256<byte>)
Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Args(IWVectorTraits256, Vector256<short>)
Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Args(IWVectorTraits256, Vector256<int>)
Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Args(IWVectorTraits256, Vector256<long>)
Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Args(IWVectorTraits256, Vector256<sbyte>)
Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Args(IWVectorTraits256, Vector256<ushort>)
Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Args(IWVectorTraits256, Vector256<uint>)
Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Args(IWVectorTraits256, Vector256<ulong>)
Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>)
Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>)
Arguments calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX3Insert_Core (为 YShuffleX3Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Core(IWVectorTraits256, Vector256<byte>, Vector256<byte>, Vector256<byte>, Vector256<byte>, (Vector256<byte> args0, Vector256<byte> args1, Vector256<byte> args2, Vector256<byte> args3, Vector256<byte> args4))
Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Core(IWVectorTraits256, Vector256<double>, Vector256<double>, Vector256<double>, Vector256<double>, (Vector256<long> args0, Vector256<long> args1, Vector256<long> args2, Vector256<long> args3, Vector256<long> args4))
Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Core(IWVectorTraits256, Vector256<short>, Vector256<short>, Vector256<short>, Vector256<short>, (Vector256<short> args0, Vector256<short> args1, Vector256<short> args2, Vector256<short> args3, Vector256<short> args4))
Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Core(IWVectorTraits256, Vector256<int>, Vector256<int>, Vector256<int>, Vector256<int>, (Vector256<int> args0, Vector256<int> args1, Vector256<int> args2, Vector256<int> args3, Vector256<int> args4))
Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Core(IWVectorTraits256, Vector256<long>, Vector256<long>, Vector256<long>, Vector256<long>, (Vector256<long> args0, Vector256<long> args1, Vector256<long> args2, Vector256<long> args3, Vector256<long> args4))
Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Core(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>, Vector256<sbyte>, Vector256<sbyte>, (Vector256<sbyte> args0, Vector256<sbyte> args1, Vector256<sbyte> args2, Vector256<sbyte> args3, Vector256<sbyte> args4))
Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Core(IWVectorTraits256, Vector256<float>, Vector256<float>, Vector256<float>, Vector256<float>, (Vector256<int> args0, Vector256<int> args1, Vector256<int> args2, Vector256<int> args3, Vector256<int> args4))
Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Core(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>, Vector256<ushort>, Vector256<ushort>, (Vector256<ushort> args0, Vector256<ushort> args1, Vector256<ushort> args2, Vector256<ushort> args3, Vector256<ushort> args4))
Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Core(IWVectorTraits256, Vector256<uint>, Vector256<uint>, Vector256<uint>, Vector256<uint>, (Vector256<uint> args0, Vector256<uint> args1, Vector256<uint> args2, Vector256<uint> args3, Vector256<uint> args4))
Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Core(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>, (Vector256<ulong> args0, Vector256<ulong> args1, Vector256<ulong> args2, Vector256<ulong> args3, Vector256<ulong> args4))
Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Insert_Core<T, TIdx>(IWVectorTraits256, Vector256<T>, Vector256<T>, Vector256<T>, Vector256<T>, (Vector256<TIdx> args0, Vector256<TIdx> args1, Vector256<TIdx> args2, Vector256<TIdx> args3, Vector256<TIdx> args4))
Core calculation for shuffle and insert on 3 vectors (在3个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX3Insert_Args (其参数来源于 YShuffleX3Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):back[i].
- YShuffleX3Kernel_Args(IWVectorTraits256, Vector256<byte>)
Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Args(IWVectorTraits256, Vector256<short>)
Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Args(IWVectorTraits256, Vector256<int>)
Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Args(IWVectorTraits256, Vector256<long>)
Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Args(IWVectorTraits256, Vector256<sbyte>)
Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Args(IWVectorTraits256, Vector256<ushort>)
Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Args(IWVectorTraits256, Vector256<uint>)
Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Args(IWVectorTraits256, Vector256<ulong>)
Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>)
Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>)
Arguments calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的参数计算). Provide arguments for YShuffleX3Kernel_Core (为 YShuffleX3Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Core(IWVectorTraits256, Vector256<byte>, Vector256<byte>, Vector256<byte>, (Vector256<byte> args0, Vector256<byte> args1, Vector256<byte> args2, Vector256<byte> args3))
Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Core(IWVectorTraits256, Vector256<double>, Vector256<double>, Vector256<double>, (Vector256<long> args0, Vector256<long> args1, Vector256<long> args2, Vector256<long> args3))
Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Core(IWVectorTraits256, Vector256<short>, Vector256<short>, Vector256<short>, (Vector256<short> args0, Vector256<short> args1, Vector256<short> args2, Vector256<short> args3))
Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Core(IWVectorTraits256, Vector256<int>, Vector256<int>, Vector256<int>, (Vector256<int> args0, Vector256<int> args1, Vector256<int> args2, Vector256<int> args3))
Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Core(IWVectorTraits256, Vector256<long>, Vector256<long>, Vector256<long>, (Vector256<long> args0, Vector256<long> args1, Vector256<long> args2, Vector256<long> args3))
Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Core(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>, Vector256<sbyte>, (Vector256<sbyte> args0, Vector256<sbyte> args1, Vector256<sbyte> args2, Vector256<sbyte> args3))
Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Core(IWVectorTraits256, Vector256<float>, Vector256<float>, Vector256<float>, (Vector256<int> args0, Vector256<int> args1, Vector256<int> args2, Vector256<int> args3))
Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Core(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>, Vector256<ushort>, (Vector256<ushort> args0, Vector256<ushort> args1, Vector256<ushort> args2, Vector256<ushort> args3))
Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Core(IWVectorTraits256, Vector256<uint>, Vector256<uint>, Vector256<uint>, (Vector256<uint> args0, Vector256<uint> args1, Vector256<uint> args2, Vector256<uint> args3))
Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Core(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>, (Vector256<ulong> args0, Vector256<ulong> args1, Vector256<ulong> args2, Vector256<ulong> args3))
Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3Kernel_Core<T, TIdx>(IWVectorTraits256, Vector256<T>, Vector256<T>, Vector256<T>, (Vector256<TIdx> args0, Vector256<TIdx> args1, Vector256<TIdx> args2, Vector256<TIdx> args3))
Core calculation for only shuffle on 3 vectors (在3个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX3Kernel_Args (其参数来源于 YShuffleX3Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2). Conditions:0<=indices[i] && indices[i]<(Count*3).
- YShuffleX3_Args(IWVectorTraits256, Vector256<byte>)
Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Args(IWVectorTraits256, Vector256<short>)
Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Args(IWVectorTraits256, Vector256<int>)
Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Args(IWVectorTraits256, Vector256<long>)
Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Args(IWVectorTraits256, Vector256<sbyte>)
Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Args(IWVectorTraits256, Vector256<ushort>)
Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Args(IWVectorTraits256, Vector256<uint>)
Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Args(IWVectorTraits256, Vector256<ulong>)
Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>)
Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>)
Arguments calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX3_Core (为 YShuffleX3_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Core(IWVectorTraits256, Vector256<byte>, Vector256<byte>, Vector256<byte>, (Vector256<byte> args0, Vector256<byte> args1, Vector256<byte> args2, Vector256<byte> args3, Vector256<byte> args4))
Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Core(IWVectorTraits256, Vector256<double>, Vector256<double>, Vector256<double>, (Vector256<long> args0, Vector256<long> args1, Vector256<long> args2, Vector256<long> args3, Vector256<long> args4))
Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Core(IWVectorTraits256, Vector256<short>, Vector256<short>, Vector256<short>, (Vector256<short> args0, Vector256<short> args1, Vector256<short> args2, Vector256<short> args3, Vector256<short> args4))
Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Core(IWVectorTraits256, Vector256<int>, Vector256<int>, Vector256<int>, (Vector256<int> args0, Vector256<int> args1, Vector256<int> args2, Vector256<int> args3, Vector256<int> args4))
Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Core(IWVectorTraits256, Vector256<long>, Vector256<long>, Vector256<long>, (Vector256<long> args0, Vector256<long> args1, Vector256<long> args2, Vector256<long> args3, Vector256<long> args4))
Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Core(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>, Vector256<sbyte>, (Vector256<sbyte> args0, Vector256<sbyte> args1, Vector256<sbyte> args2, Vector256<sbyte> args3, Vector256<sbyte> args4))
Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Core(IWVectorTraits256, Vector256<float>, Vector256<float>, Vector256<float>, (Vector256<int> args0, Vector256<int> args1, Vector256<int> args2, Vector256<int> args3, Vector256<int> args4))
Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Core(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>, Vector256<ushort>, (Vector256<ushort> args0, Vector256<ushort> args1, Vector256<ushort> args2, Vector256<ushort> args3, Vector256<ushort> args4))
Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Core(IWVectorTraits256, Vector256<uint>, Vector256<uint>, Vector256<uint>, (Vector256<uint> args0, Vector256<uint> args1, Vector256<uint> args2, Vector256<uint> args3, Vector256<uint> args4))
Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Core(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>, (Vector256<ulong> args0, Vector256<ulong> args1, Vector256<ulong> args2, Vector256<ulong> args3, Vector256<ulong> args4))
Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX3_Core<T, TIdx>(IWVectorTraits256, Vector256<T>, Vector256<T>, Vector256<T>, (Vector256<TIdx> args0, Vector256<TIdx> args1, Vector256<TIdx> args2, Vector256<TIdx> args3, Vector256<TIdx> args4))
Core calculation for shuffle and clear on 3 vectors (在3个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX3_Args (其参数来源于 YShuffleX3_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*3))?( element_ref(indices[i], vector0, vector1, vector2) ):0.
- YShuffleX4Insert_Args(IWVectorTraits256, Vector256<byte>)
Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Args(IWVectorTraits256, Vector256<short>)
Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Args(IWVectorTraits256, Vector256<int>)
Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Args(IWVectorTraits256, Vector256<long>)
Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Args(IWVectorTraits256, Vector256<sbyte>)
Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Args(IWVectorTraits256, Vector256<ushort>)
Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Args(IWVectorTraits256, Vector256<uint>)
Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Args(IWVectorTraits256, Vector256<ulong>)
Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>)
Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>)
Arguments calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的参数计算). Provide arguments for YShuffleX4Insert_Core (为 YShuffleX4Insert_Core 提供参数). If the index value is out of range, the elements of the background vector will be inserted (若索引值超出范围, 会插入背景向量的元素). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Core(IWVectorTraits256, Vector256<byte>, Vector256<byte>, Vector256<byte>, Vector256<byte>, Vector256<byte>, (Vector256<byte> args0, Vector256<byte> args1, Vector256<byte> args2, Vector256<byte> args3, Vector256<byte> args4))
Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Core(IWVectorTraits256, Vector256<double>, Vector256<double>, Vector256<double>, Vector256<double>, Vector256<double>, (Vector256<long> args0, Vector256<long> args1, Vector256<long> args2, Vector256<long> args3, Vector256<long> args4))
Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Core(IWVectorTraits256, Vector256<short>, Vector256<short>, Vector256<short>, Vector256<short>, Vector256<short>, (Vector256<short> args0, Vector256<short> args1, Vector256<short> args2, Vector256<short> args3, Vector256<short> args4))
Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Core(IWVectorTraits256, Vector256<int>, Vector256<int>, Vector256<int>, Vector256<int>, Vector256<int>, (Vector256<int> args0, Vector256<int> args1, Vector256<int> args2, Vector256<int> args3, Vector256<int> args4))
Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Core(IWVectorTraits256, Vector256<long>, Vector256<long>, Vector256<long>, Vector256<long>, Vector256<long>, (Vector256<long> args0, Vector256<long> args1, Vector256<long> args2, Vector256<long> args3, Vector256<long> args4))
Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Core(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>, Vector256<sbyte>, Vector256<sbyte>, Vector256<sbyte>, (Vector256<sbyte> args0, Vector256<sbyte> args1, Vector256<sbyte> args2, Vector256<sbyte> args3, Vector256<sbyte> args4))
Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Core(IWVectorTraits256, Vector256<float>, Vector256<float>, Vector256<float>, Vector256<float>, Vector256<float>, (Vector256<int> args0, Vector256<int> args1, Vector256<int> args2, Vector256<int> args3, Vector256<int> args4))
Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Core(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>, Vector256<ushort>, Vector256<ushort>, Vector256<ushort>, (Vector256<ushort> args0, Vector256<ushort> args1, Vector256<ushort> args2, Vector256<ushort> args3, Vector256<ushort> args4))
Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Core(IWVectorTraits256, Vector256<uint>, Vector256<uint>, Vector256<uint>, Vector256<uint>, Vector256<uint>, (Vector256<uint> args0, Vector256<uint> args1, Vector256<uint> args2, Vector256<uint> args3, Vector256<uint> args4))
Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Core(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>, (Vector256<ulong> args0, Vector256<ulong> args1, Vector256<ulong> args2, Vector256<ulong> args3, Vector256<ulong> args4))
Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Insert_Core<T, TIdx>(IWVectorTraits256, Vector256<T>, Vector256<T>, Vector256<T>, Vector256<T>, Vector256<T>, (Vector256<TIdx> args0, Vector256<TIdx> args1, Vector256<TIdx> args2, Vector256<TIdx> args3, Vector256<TIdx> args4))
Core calculation for shuffle and insert on 4 vectors (在4个向量上进行换位并插入的核心计算). Its arguments are derived from YShuffleX4Insert_Args (其参数来源于 YShuffleX4Insert_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):back[i].
- YShuffleX4Kernel_Args(IWVectorTraits256, Vector256<byte>)
Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Args(IWVectorTraits256, Vector256<short>)
Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Args(IWVectorTraits256, Vector256<int>)
Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Args(IWVectorTraits256, Vector256<long>)
Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Args(IWVectorTraits256, Vector256<sbyte>)
Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Args(IWVectorTraits256, Vector256<ushort>)
Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Args(IWVectorTraits256, Vector256<uint>)
Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Args(IWVectorTraits256, Vector256<ulong>)
Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>)
Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>)
Arguments calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的参数计算). Provide arguments for YShuffleX4Kernel_Core (为 YShuffleX4Kernel_Core 提供参数). If the index value is out of range, the result is undefined (若索引值超出范围, 结果是未定义的). You can use the IndexX4Mask to constrain the parameters (可使用 IndexX4Mask 掩码来约束参数). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Core(IWVectorTraits256, Vector256<byte>, Vector256<byte>, Vector256<byte>, Vector256<byte>, (Vector256<byte> args0, Vector256<byte> args1, Vector256<byte> args2, Vector256<byte> args3))
Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Core(IWVectorTraits256, Vector256<double>, Vector256<double>, Vector256<double>, Vector256<double>, (Vector256<long> args0, Vector256<long> args1, Vector256<long> args2, Vector256<long> args3))
Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Core(IWVectorTraits256, Vector256<short>, Vector256<short>, Vector256<short>, Vector256<short>, (Vector256<short> args0, Vector256<short> args1, Vector256<short> args2, Vector256<short> args3))
Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Core(IWVectorTraits256, Vector256<int>, Vector256<int>, Vector256<int>, Vector256<int>, (Vector256<int> args0, Vector256<int> args1, Vector256<int> args2, Vector256<int> args3))
Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Core(IWVectorTraits256, Vector256<long>, Vector256<long>, Vector256<long>, Vector256<long>, (Vector256<long> args0, Vector256<long> args1, Vector256<long> args2, Vector256<long> args3))
Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Core(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>, Vector256<sbyte>, Vector256<sbyte>, (Vector256<sbyte> args0, Vector256<sbyte> args1, Vector256<sbyte> args2, Vector256<sbyte> args3))
Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Core(IWVectorTraits256, Vector256<float>, Vector256<float>, Vector256<float>, Vector256<float>, (Vector256<int> args0, Vector256<int> args1, Vector256<int> args2, Vector256<int> args3))
Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Core(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>, Vector256<ushort>, Vector256<ushort>, (Vector256<ushort> args0, Vector256<ushort> args1, Vector256<ushort> args2, Vector256<ushort> args3))
Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Core(IWVectorTraits256, Vector256<uint>, Vector256<uint>, Vector256<uint>, Vector256<uint>, (Vector256<uint> args0, Vector256<uint> args1, Vector256<uint> args2, Vector256<uint> args3))
Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Core(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>, (Vector256<ulong> args0, Vector256<ulong> args1, Vector256<ulong> args2, Vector256<ulong> args3))
Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4Kernel_Core<T, TIdx>(IWVectorTraits256, Vector256<T>, Vector256<T>, Vector256<T>, Vector256<T>, (Vector256<TIdx> args0, Vector256<TIdx> args1, Vector256<TIdx> args2, Vector256<TIdx> args3))
Core calculation for only shuffle on 4 vectors (在4个向量上进行仅换位的核心计算). Its arguments are derived from YShuffleX4Kernel_Args (其参数来源于 YShuffleX4Kernel_Args). Mnemonic:
rt[i] := element_ref(indices[i], vector0, vector1, vector2, vector3). Conditions:0<=indices[i] && indices[i]<(Count*4).
- YShuffleX4_Args(IWVectorTraits256, Vector256<byte>)
Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Args(IWVectorTraits256, Vector256<short>)
Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Args(IWVectorTraits256, Vector256<int>)
Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Args(IWVectorTraits256, Vector256<long>)
Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Args(IWVectorTraits256, Vector256<sbyte>)
Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Args(IWVectorTraits256, Vector256<ushort>)
Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Args(IWVectorTraits256, Vector256<uint>)
Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Args(IWVectorTraits256, Vector256<ulong>)
Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>)
Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Args<TIdx>(IWVectorTraits256, Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>, out Vector256<TIdx>)
Arguments calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的参数计算). Provide arguments for YShuffleX4_Core (为 YShuffleX4_Core 提供参数). If the indices value is out of range, the element will be cleared (若索引值超出范围, 元素会被清零). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Core(IWVectorTraits256, Vector256<byte>, Vector256<byte>, Vector256<byte>, Vector256<byte>, (Vector256<byte> args0, Vector256<byte> args1, Vector256<byte> args2, Vector256<byte> args3, Vector256<byte> args4))
Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Core(IWVectorTraits256, Vector256<double>, Vector256<double>, Vector256<double>, Vector256<double>, (Vector256<long> args0, Vector256<long> args1, Vector256<long> args2, Vector256<long> args3, Vector256<long> args4))
Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Core(IWVectorTraits256, Vector256<short>, Vector256<short>, Vector256<short>, Vector256<short>, (Vector256<short> args0, Vector256<short> args1, Vector256<short> args2, Vector256<short> args3, Vector256<short> args4))
Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Core(IWVectorTraits256, Vector256<int>, Vector256<int>, Vector256<int>, Vector256<int>, (Vector256<int> args0, Vector256<int> args1, Vector256<int> args2, Vector256<int> args3, Vector256<int> args4))
Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Core(IWVectorTraits256, Vector256<long>, Vector256<long>, Vector256<long>, Vector256<long>, (Vector256<long> args0, Vector256<long> args1, Vector256<long> args2, Vector256<long> args3, Vector256<long> args4))
Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Core(IWVectorTraits256, Vector256<sbyte>, Vector256<sbyte>, Vector256<sbyte>, Vector256<sbyte>, (Vector256<sbyte> args0, Vector256<sbyte> args1, Vector256<sbyte> args2, Vector256<sbyte> args3, Vector256<sbyte> args4))
Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Core(IWVectorTraits256, Vector256<float>, Vector256<float>, Vector256<float>, Vector256<float>, (Vector256<int> args0, Vector256<int> args1, Vector256<int> args2, Vector256<int> args3, Vector256<int> args4))
Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Core(IWVectorTraits256, Vector256<ushort>, Vector256<ushort>, Vector256<ushort>, Vector256<ushort>, (Vector256<ushort> args0, Vector256<ushort> args1, Vector256<ushort> args2, Vector256<ushort> args3, Vector256<ushort> args4))
Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Core(IWVectorTraits256, Vector256<uint>, Vector256<uint>, Vector256<uint>, Vector256<uint>, (Vector256<uint> args0, Vector256<uint> args1, Vector256<uint> args2, Vector256<uint> args3, Vector256<uint> args4))
Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Core(IWVectorTraits256, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>, Vector256<ulong>, (Vector256<ulong> args0, Vector256<ulong> args1, Vector256<ulong> args2, Vector256<ulong> args3, Vector256<ulong> args4))
Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.
- YShuffleX4_Core<T, TIdx>(IWVectorTraits256, Vector256<T>, Vector256<T>, Vector256<T>, Vector256<T>, (Vector256<TIdx> args0, Vector256<TIdx> args1, Vector256<TIdx> args2, Vector256<TIdx> args3, Vector256<TIdx> args4))
Core calculation for shuffle and clear on 4 vectors (在4个向量上进行换位并清零的核心计算). Its arguments are derived from YShuffleX4_Args (其参数来源于 YShuffleX4_Args). Mnemonic:
rt[i] := (0<=indices[i] && indices[i]<(Count*4))?( element_ref(indices[i], vector0, vector1, vector2, vector3) ):0.