Class VectorTraits256Base.Statics

Namespace: Zyl.VectorTraits.Impl.AVector

Assembly: VectorTraits.dll

Vector<T> traits.Statics 256 - base.

public static class VectorTraits256Base.Statics

Inheritance: object

VectorTraits256Base.Statics

Inherited Members: object.Equals(object)

object.Equals(object, object)

object.GetHashCode()

object.GetType()

object.MemberwiseClone()

object.ReferenceEquals(object, object)

object.ToString()

Properties

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

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

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

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

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

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

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

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

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Edit this page