diff --git a/src/coreclr/inc/readytorun.h b/src/coreclr/inc/readytorun.h index 21bd50642d4b7..4754e0a294fe8 100644 --- a/src/coreclr/inc/readytorun.h +++ b/src/coreclr/inc/readytorun.h @@ -14,11 +14,13 @@ #define READYTORUN_SIGNATURE 0x00525452 // 'RTR' -// Keep these in sync with src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs -#define READYTORUN_MAJOR_VERSION 0x0008 +// Keep these in sync with +// src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs +// src/coreclr/nativeaot/Runtime/inc/ModuleHeaders.h +#define READYTORUN_MAJOR_VERSION 0x0009 #define READYTORUN_MINOR_VERSION 0x0000 -#define MINIMUM_READYTORUN_MAJOR_VERSION 0x008 +#define MINIMUM_READYTORUN_MAJOR_VERSION 0x009 // R2R Version 2.1 adds the InliningInfo section // R2R Version 2.2 adds the ProfileDataInfo section @@ -27,6 +29,7 @@ // R2R Version 6.0 changes managed layout for sequential types with any unmanaged non-blittable fields. // R2R 6.0 is not backward compatible with 5.x or earlier. // R2R Version 8.0 Changes the alignment of the Int128 type +// R2R Version 9.0 adds support for the Vector512 type struct READYTORUN_CORE_HEADER { diff --git a/src/coreclr/jit/hwintrinsicarm64.cpp b/src/coreclr/jit/hwintrinsicarm64.cpp index 78357b2918cb5..9603fd7c1bb6b 100644 --- a/src/coreclr/jit/hwintrinsicarm64.cpp +++ b/src/coreclr/jit/hwintrinsicarm64.cpp @@ -762,22 +762,25 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, { assert(sig->numArgs == 2); - if (varTypeIsFloating(simdBaseType)) + if (!varTypeIsFloating(simdBaseType)) { - CORINFO_ARG_LIST_HANDLE arg1 = sig->args; - CORINFO_ARG_LIST_HANDLE arg2 = info.compCompHnd->getArgNext(arg1); - var_types argType = TYP_UNKNOWN; - CORINFO_CLASS_HANDLE argClass = NO_CLASS_HANDLE; + // We can't trivially handle division for integral types using SIMD + break; + } + + CORINFO_ARG_LIST_HANDLE arg1 = sig->args; + CORINFO_ARG_LIST_HANDLE arg2 = info.compCompHnd->getArgNext(arg1); + var_types argType = TYP_UNKNOWN; + CORINFO_CLASS_HANDLE argClass = NO_CLASS_HANDLE; - argType = JITtype2varType(strip(info.compCompHnd->getArgType(sig, arg2, &argClass))); - op2 = getArgForHWIntrinsic(argType, argClass); + argType = JITtype2varType(strip(info.compCompHnd->getArgType(sig, arg2, &argClass))); + op2 = getArgForHWIntrinsic(argType, argClass); - argType = JITtype2varType(strip(info.compCompHnd->getArgType(sig, arg1, &argClass))); - op1 = getArgForHWIntrinsic(argType, argClass); + argType = JITtype2varType(strip(info.compCompHnd->getArgType(sig, arg1, &argClass))); + op1 = getArgForHWIntrinsic(argType, argClass); - retNode = gtNewSimdBinOpNode(GT_DIV, retType, op1, op2, simdBaseJitType, simdSize, - /* isSimdAsHWIntrinsic */ false); - } + retNode = gtNewSimdBinOpNode(GT_DIV, retType, op1, op2, simdBaseJitType, simdSize, + /* isSimdAsHWIntrinsic */ false); break; } diff --git a/src/coreclr/jit/hwintrinsicxarch.cpp b/src/coreclr/jit/hwintrinsicxarch.cpp index 2f79e46fb3585..7c9479bbc5caa 100644 --- a/src/coreclr/jit/hwintrinsicxarch.cpp +++ b/src/coreclr/jit/hwintrinsicxarch.cpp @@ -1145,23 +1145,25 @@ GenTree* Compiler::impBaseIntrinsic(NamedIntrinsic intrinsic, { assert(sig->numArgs == 2); - if (varTypeIsFloating(simdBaseType)) + if (!varTypeIsFloating(simdBaseType)) { - CORINFO_ARG_LIST_HANDLE arg1 = sig->args; - CORINFO_ARG_LIST_HANDLE arg2 = info.compCompHnd->getArgNext(arg1); - var_types argType = TYP_UNKNOWN; - CORINFO_CLASS_HANDLE argClass = NO_CLASS_HANDLE; + // We can't trivially handle division for integral types using SIMD + break; + } - argType = JITtype2varType(strip(info.compCompHnd->getArgType(sig, arg2, &argClass))); - op2 = getArgForHWIntrinsic(argType, argClass); + CORINFO_ARG_LIST_HANDLE arg1 = sig->args; + CORINFO_ARG_LIST_HANDLE arg2 = info.compCompHnd->getArgNext(arg1); + var_types argType = TYP_UNKNOWN; + CORINFO_CLASS_HANDLE argClass = NO_CLASS_HANDLE; - argType = JITtype2varType(strip(info.compCompHnd->getArgType(sig, arg1, &argClass))); - op1 = getArgForHWIntrinsic(argType, argClass); + argType = JITtype2varType(strip(info.compCompHnd->getArgType(sig, arg2, &argClass))); + op2 = getArgForHWIntrinsic(argType, argClass); - retNode = gtNewSimdBinOpNode(GT_DIV, retType, op1, op2, simdBaseJitType, simdSize, - /* isSimdAsHWIntrinsic */ false); - break; - } + argType = JITtype2varType(strip(info.compCompHnd->getArgType(sig, arg1, &argClass))); + op1 = getArgForHWIntrinsic(argType, argClass); + + retNode = gtNewSimdBinOpNode(GT_DIV, retType, op1, op2, simdBaseJitType, simdSize, + /* isSimdAsHWIntrinsic */ false); break; } @@ -2061,7 +2063,7 @@ GenTree* Compiler::impBaseIntrinsic(NamedIntrinsic intrinsic, { assert(sig->numArgs == 2); - if (varTypeIsByte(simdBaseType) || varTypeIsLong(simdBaseType)) + if (varTypeIsByte(simdBaseType) || varTypeIsLong(simdBaseType) || (simdBaseType == TYP_DOUBLE)) { // byte, sbyte, long, and ulong would require more work to support break; diff --git a/src/coreclr/nativeaot/Runtime/inc/ModuleHeaders.h b/src/coreclr/nativeaot/Runtime/inc/ModuleHeaders.h index 6f77813cd0614..7d0c985486c9d 100644 --- a/src/coreclr/nativeaot/Runtime/inc/ModuleHeaders.h +++ b/src/coreclr/nativeaot/Runtime/inc/ModuleHeaders.h @@ -4,13 +4,14 @@ // // Please keep the data structures in this file in sync with the managed version at // src/Common/src/Internal/Runtime/ModuleHeaders.cs -// +// src/coreclr/inc/readytorun.h + struct ReadyToRunHeaderConstants { static const uint32_t Signature = 0x00525452; // 'RTR' - static const uint32_t CurrentMajorVersion = 8; + static const uint32_t CurrentMajorVersion = 9; static const uint32_t CurrentMinorVersion = 0; }; diff --git a/src/coreclr/tools/Common/Compiler/VectorFieldLayoutAlgorithm.cs b/src/coreclr/tools/Common/Compiler/VectorFieldLayoutAlgorithm.cs index ae5d8c58c2a9c..ac5247190775a 100644 --- a/src/coreclr/tools/Common/Compiler/VectorFieldLayoutAlgorithm.cs +++ b/src/coreclr/tools/Common/Compiler/VectorFieldLayoutAlgorithm.cs @@ -44,9 +44,28 @@ public override ComputedInstanceFieldLayout ComputeInstanceLayout(DefType defTyp alignment = new LayoutInt(16); } } + else if (name == "Vector256`1") + { + if (defType.Context.Target.Architecture == TargetArchitecture.ARM) + { + // No such type exists for the Procedure Call Standard for ARM. We will default + // to the same alignment as __m128, which is supported by the ABI. + alignment = new LayoutInt(8); + } + else if (defType.Context.Target.Architecture == TargetArchitecture.ARM64) + { + // The Procedure Call Standard for ARM 64-bit (with SVE support) defaults to + // 16-byte alignment for __m256. + alignment = new LayoutInt(16); + } + else + { + alignment = new LayoutInt(32); + } + } else { - Debug.Assert(name == "Vector256`1"); + Debug.Assert(name == "Vector512`1"); if (defType.Context.Target.Architecture == TargetArchitecture.ARM) { @@ -62,7 +81,7 @@ public override ComputedInstanceFieldLayout ComputeInstanceLayout(DefType defTyp } else { - alignment = new LayoutInt(32); + alignment = new LayoutInt(64); } } @@ -106,6 +125,7 @@ public override ValueTypeShapeCharacteristics ComputeValueTypeShapeCharacteristi 8 => ValueTypeShapeCharacteristics.Vector64Aggregate, 16 => ValueTypeShapeCharacteristics.Vector128Aggregate, 32 => ValueTypeShapeCharacteristics.Vector128Aggregate, + 64 => ValueTypeShapeCharacteristics.Vector128Aggregate, _ => ValueTypeShapeCharacteristics.None }; } @@ -116,9 +136,10 @@ public static bool IsVectorType(DefType type) { return type.IsIntrinsic && type.Namespace == "System.Runtime.Intrinsics" && - (type.Name == "Vector64`1" || - type.Name == "Vector128`1" || - type.Name == "Vector256`1"); + ((type.Name == "Vector64`1") || + (type.Name == "Vector128`1") || + (type.Name == "Vector256`1") || + (type.Name == "Vector512`1")); } } } diff --git a/src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs b/src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs index 144bd50f949db..f198538949666 100644 --- a/src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs +++ b/src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs @@ -8,13 +8,14 @@ namespace Internal.Runtime // // Please keep the data structures in this file in sync with the native version at // src/coreclr/inc/readytorun.h + // src/coreclr/nativeaot/Runtime/inc/ModuleHeaders.h // internal struct ReadyToRunHeaderConstants { public const uint Signature = 0x00525452; // 'RTR' - public const ushort CurrentMajorVersion = 8; + public const ushort CurrentMajorVersion = 9; public const ushort CurrentMinorVersion = 0; } #if READYTORUN diff --git a/src/coreclr/tools/Common/TypeSystem/CodeGen/TargetDetails.CodeGen.cs b/src/coreclr/tools/Common/TypeSystem/CodeGen/TargetDetails.CodeGen.cs index 353399eb78b7f..d02249f296890 100644 --- a/src/coreclr/tools/Common/TypeSystem/CodeGen/TargetDetails.CodeGen.cs +++ b/src/coreclr/tools/Common/TypeSystem/CodeGen/TargetDetails.CodeGen.cs @@ -40,5 +40,10 @@ public enum SimdVectorLength /// Specifies that native vectors are 256 bit (e.g. AVX on x86). /// Vector256Bit, + + /// + /// Specifies that native vectors are 512 bit (e.g. AVX512 on x86). + /// + Vector512Bit, } } diff --git a/src/coreclr/tools/Common/TypeSystem/Common/TargetDetails.cs b/src/coreclr/tools/Common/TypeSystem/Common/TargetDetails.cs index a090cbf1b0542..ef77bfa5d10df 100644 --- a/src/coreclr/tools/Common/TypeSystem/Common/TargetDetails.cs +++ b/src/coreclr/tools/Common/TypeSystem/Common/TargetDetails.cs @@ -109,12 +109,12 @@ public int MaximumAlignment { if (Architecture == TargetArchitecture.ARM) { - // Corresponds to alignment required for __m128 (there's no __m256) + // Corresponds to alignment required for __m128 (there's no __m256/__m512) return 8; } else if (Architecture == TargetArchitecture.ARM64) { - // Corresponds to alignmet required for __m256 + // Corresponds to alignmet required for __m128 (there's no __m256/__m512) return 16; } else if (Architecture == TargetArchitecture.LoongArch64) @@ -122,8 +122,8 @@ public int MaximumAlignment return 16; } - // 256-bit vector is the type with the highest alignment we support - return 32; + // 512-bit vector is the type with the highest alignment we support + return 64; } } @@ -136,8 +136,8 @@ public int DefaultPackingSize { get { - // We use default packing size of 32 irrespective of the platform. - return 32; + // We use default packing size of 64 irrespective of the platform. + return 64; } } diff --git a/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshalHelpers.cs b/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshalHelpers.cs index 91a9834603764..6402d5e535a2a 100644 --- a/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshalHelpers.cs +++ b/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshalHelpers.cs @@ -874,6 +874,7 @@ private static bool IsValidForGenericMarshalling( // * Vector64: Represents the __m64 ABI primitive which requires currently unimplemented handling // * Vector128: Represents the __m128 ABI primitive which requires currently unimplemented handling // * Vector256: Represents the __m256 ABI primitive which requires currently unimplemented handling + // * Vector512: Represents the __m512 ABI primitive which requires currently unimplemented handling // * Vector: Has a variable size (either __m128 or __m256) and isn't readily usable for interop scenarios return !InteropTypes.IsSystemNullable(type.Context, type) && !InteropTypes.IsSystemSpan(type.Context, type) @@ -881,6 +882,7 @@ private static bool IsValidForGenericMarshalling( && !InteropTypes.IsSystemRuntimeIntrinsicsVector64T(type.Context, type) && !InteropTypes.IsSystemRuntimeIntrinsicsVector128T(type.Context, type) && !InteropTypes.IsSystemRuntimeIntrinsicsVector256T(type.Context, type) + && !InteropTypes.IsSystemRuntimeIntrinsicsVector512T(type.Context, type) && !InteropTypes.IsSystemNumericsVectorT(type.Context, type); } diff --git a/src/coreclr/tools/Common/TypeSystem/Interop/InteropTypes.cs b/src/coreclr/tools/Common/TypeSystem/Interop/InteropTypes.cs index 8bbdb13630bfe..3beeb5f187a89 100644 --- a/src/coreclr/tools/Common/TypeSystem/Interop/InteropTypes.cs +++ b/src/coreclr/tools/Common/TypeSystem/Interop/InteropTypes.cs @@ -145,6 +145,11 @@ public static bool IsSystemRuntimeIntrinsicsVector256T(TypeSystemContext context return IsCoreNamedType(context, type, "System.Runtime.Intrinsics", "Vector256`1"); } + public static bool IsSystemRuntimeIntrinsicsVector512T(TypeSystemContext context, TypeDesc type) + { + return IsCoreNamedType(context, type, "System.Runtime.Intrinsics", "Vector512`1"); + } + public static bool IsSystemNumericsVectorT(TypeSystemContext context, TypeDesc type) { return IsCoreNamedType(context, type, "System.Numerics", "Vector`1"); diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/VectorOfTFieldLayoutAlgorithm.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/VectorOfTFieldLayoutAlgorithm.cs index e0e175c0dcefe..1a1eef14d5582 100644 --- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/VectorOfTFieldLayoutAlgorithm.cs +++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/VectorOfTFieldLayoutAlgorithm.cs @@ -36,6 +36,10 @@ public override ComputedInstanceFieldLayout ComputeInstanceLayout(DefType defTyp { instanceFieldSize = new LayoutInt(32); } + else if (targetDetails.MaximumSimdVectorLength == SimdVectorLength.Vector512Bit) + { + instanceFieldSize = new LayoutInt(64); + } else { Debug.Assert(targetDetails.MaximumSimdVectorLength == SimdVectorLength.None); diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilerContext.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilerContext.cs index 73dcd33c1b2f9..88a74a9ebc2f0 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilerContext.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilerContext.cs @@ -52,6 +52,8 @@ public ReadyToRunCompilerContext(TargetDetails details, SharedGenericsMode gener matchingVectorType = "Vector128`1"; else if (details.MaximumSimdVectorLength == SimdVectorLength.Vector256Bit) matchingVectorType = "Vector256`1"; + else if (details.MaximumSimdVectorLength == SimdVectorLength.Vector512Bit) + matchingVectorType = "Vector512`1"; // No architecture has completely stable handling of Vector in the abi (Arm64 may change to SVE) _vectorOfTFieldLayoutAlgorithm = new VectorOfTFieldLayoutAlgorithm(_r2rFieldLayoutAlgorithm, _vectorFieldLayoutAlgorithm, matchingVectorType, bubbleIncludesCorelib); diff --git a/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/InstanceFieldLayout.cs b/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/InstanceFieldLayout.cs index 249090e38eae5..a67197c0a1901 100644 --- a/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/InstanceFieldLayout.cs +++ b/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/InstanceFieldLayout.cs @@ -230,6 +230,18 @@ public class Class16Align { Vector128 vector16Align; } + + [StructLayout(LayoutKind.Sequential)] + public class Class32Align + { + Vector256 vector32Align; + } + + [StructLayout(LayoutKind.Sequential)] + public class Class64Align + { + Vector512 vector64Align; + } } namespace Auto @@ -358,17 +370,53 @@ public struct int8x16x2 public Vector128 _1; } + [StructLayout(LayoutKind.Auto)] + public struct int8x32x2 + { + public Vector256 _0; + public Vector256 _1; + } + + [StructLayout(LayoutKind.Auto)] + public struct int8x64x2 + { + public Vector512 _0; + public Vector512 _1; + } + public struct Wrapper_int8x16x2 { public int8x16x2 fld; } + public struct Wrapper_int8x32x2 + { + public int8x32x2 fld; + } + + public struct Wrapper_int8x64x2 + { + public int8x64x2 fld; + } + public struct Wrapper_int8x16x2_2 { public bool fld1; public int8x16x2 fld2; } + public struct Wrapper_int8x32x2_2 + { + public bool fld1; + public int8x32x2 fld2; + } + + public struct Wrapper_int8x64x2_2 + { + public bool fld1; + public int8x64x2 fld2; + } + [StructLayout(LayoutKind.Auto)] public struct StructByte { @@ -453,6 +501,18 @@ public class Class16Align { Vector128 vector16Align; } + + [StructLayout(LayoutKind.Sequential)] + public class Class32Align + { + Vector256 vector32Align; + } + + [StructLayout(LayoutKind.Sequential)] + public class Class64Align + { + Vector512 vector64Align; + } } namespace IsByRefLike diff --git a/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/Platform.cs b/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/Platform.cs index 2239925645c77..75ade965f9318 100644 --- a/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/Platform.cs +++ b/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/Platform.cs @@ -182,4 +182,22 @@ public readonly struct Vector128 private readonly ulong _00; private readonly ulong _01; } + + [Intrinsic] + [StructLayout(LayoutKind.Sequential, Size = 32)] + public readonly struct Vector256 + where T : struct + { + private readonly Vector128 _lower; + private readonly Vector128 _upper; + } + + [Intrinsic] + [StructLayout(LayoutKind.Sequential, Size = 64)] + public readonly struct Vector512 + where T : struct + { + private readonly Vector256 _lower; + private readonly Vector256 _upper; + } } diff --git a/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/InstanceFieldLayoutTests.cs b/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/InstanceFieldLayoutTests.cs index e846cbfe31af9..8c49d5ad91b81 100644 --- a/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/InstanceFieldLayoutTests.cs +++ b/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/InstanceFieldLayoutTests.cs @@ -303,6 +303,50 @@ public void TestSequentialTypeLayoutClass16Align() } } + [Fact] + public void TestSequentialTypeLayoutClass32Align() + { + MetadataType classType = _testModule.GetType("Sequential", "Class32Align"); + Assert.Equal(0x28, classType.InstanceByteCount.AsInt); + foreach (var f in classType.GetFields()) + { + if (f.IsStatic) + continue; + + switch (f.Name) + { + case "vector32Align": + Assert.Equal(0x8, f.Offset.AsInt); + break; + default: + Assert.True(false); + break; + } + } + } + + [Fact] + public void TestSequentialTypeLayoutClass64Align() + { + MetadataType classType = _testModule.GetType("Sequential", "Class64Align"); + Assert.Equal(0x48, classType.InstanceByteCount.AsInt); + foreach (var f in classType.GetFields()) + { + if (f.IsStatic) + continue; + + switch (f.Name) + { + case "vector64Align": + Assert.Equal(0x8, f.Offset.AsInt); + break; + default: + Assert.True(false); + break; + } + } + } + [Fact] public void TestAutoLayoutStruct() { @@ -826,6 +870,50 @@ public void TestAutoTypeLayoutClass16Align() } } + [Fact] + public void TestAutoTypeLayoutClass32Align() + { + MetadataType classType = _testModule.GetType("Auto", "Class32Align"); + Assert.Equal(0x28, classType.InstanceByteCount.AsInt); + foreach (var f in classType.GetFields()) + { + if (f.IsStatic) + continue; + + switch (f.Name) + { + case "vector32Align": + Assert.Equal(0x8, f.Offset.AsInt); + break; + default: + Assert.True(false); + break; + } + } + } + + [Fact] + public void TestAutoTypeLayoutClass64Align() + { + MetadataType classType = _testModule.GetType("Auto", "Class64Align"); + Assert.Equal(0x48, classType.InstanceByteCount.AsInt); + foreach (var f in classType.GetFields()) + { + if (f.IsStatic) + continue; + + switch (f.Name) + { + case "vector64Align": + Assert.Equal(0x8, f.Offset.AsInt); + break; + default: + Assert.True(false); + break; + } + } + } + [Fact] public void TestTypeContainsGCPointers() { @@ -904,15 +992,47 @@ public void TestWrapperAroundVectorTypes() Assert.Equal(16, instantiatedType.InstanceFieldAlignment.AsInt); } + { + MetadataType type = (MetadataType)_testModule.GetType("System.Runtime.Intrinsics", "Vector256`1"); + MetadataType instantiatedType = type.MakeInstantiatedType(_context.GetWellKnownType(WellKnownType.Byte)); + Assert.Equal(32, instantiatedType.InstanceFieldAlignment.AsInt); + } + + { + MetadataType type = (MetadataType)_testModule.GetType("System.Runtime.Intrinsics", "Vector512`1"); + MetadataType instantiatedType = type.MakeInstantiatedType(_context.GetWellKnownType(WellKnownType.Byte)); + Assert.Equal(64, instantiatedType.InstanceFieldAlignment.AsInt); + } + { DefType type = _testModule.GetType("Auto", "int8x16x2"); Assert.Equal(16, type.InstanceFieldAlignment.AsInt); } + { + DefType type = _testModule.GetType("Auto", "int8x32x2"); + Assert.Equal(32, type.InstanceFieldAlignment.AsInt); + } + + { + DefType type = _testModule.GetType("Auto", "int8x64x2"); + Assert.Equal(64, type.InstanceFieldAlignment.AsInt); + } + { DefType type = _testModule.GetType("Auto", "Wrapper_int8x16x2"); Assert.Equal(16, type.InstanceFieldAlignment.AsInt); } + + { + DefType type = _testModule.GetType("Auto", "Wrapper_int8x32x2"); + Assert.Equal(32, type.InstanceFieldAlignment.AsInt); + } + + { + DefType type = _testModule.GetType("Auto", "Wrapper_int8x64x2"); + Assert.Equal(64, type.InstanceFieldAlignment.AsInt); + } } } } diff --git a/src/coreclr/vm/classlayoutinfo.cpp b/src/coreclr/vm/classlayoutinfo.cpp index a37d7a0652121..c326a3e26e15b 100644 --- a/src/coreclr/vm/classlayoutinfo.cpp +++ b/src/coreclr/vm/classlayoutinfo.cpp @@ -162,6 +162,7 @@ namespace case 8: case 16: case 32: + case 64: break; default: COMPlusThrowHR(COR_E_INVALIDPROGRAM, BFA_METADATA_CORRUPT); @@ -979,7 +980,8 @@ EEClassNativeLayoutInfo* EEClassNativeLayoutInfo::CollectNativeLayoutFieldMetada pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__UINT128)) || pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__VECTOR64T)) || pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__VECTOR128T)) || - pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__VECTOR256T))) + pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__VECTOR256T)) || + pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__VECTOR512T))) { pNativeLayoutInfo->m_alignmentRequirement = pEEClassLayoutInfo->m_ManagedLargestAlignmentRequirementOfAllMembers; } diff --git a/src/coreclr/vm/classnames.h b/src/coreclr/vm/classnames.h index 00a192fd36f39..29ee7c26d5e84 100644 --- a/src/coreclr/vm/classnames.h +++ b/src/coreclr/vm/classnames.h @@ -52,6 +52,9 @@ #define g_Vector256ClassName "System.Runtime.Intrinsics.Vector256`1" #define g_Vector256Name "Vector256`1" +#define g_Vector512ClassName "System.Runtime.Intrinsics.Vector512`1" +#define g_Vector512Name "Vector512`1" + #define g_EnumeratorToEnumClassName "System.Runtime.InteropServices.CustomMarshalers.EnumeratorToEnumVariantMarshaler" #define g_ExceptionClassName "System.Exception" #define g_ExecutionEngineExceptionClassName "System.ExecutionEngineException" diff --git a/src/coreclr/vm/corelib.h b/src/coreclr/vm/corelib.h index 5e1b486c9f2fb..61946c83fb224 100644 --- a/src/coreclr/vm/corelib.h +++ b/src/coreclr/vm/corelib.h @@ -484,6 +484,7 @@ DEFINE_METHOD(NATIVELIBRARY, LOADLIBRARYCALLBACKSTUB, LoadLibraryCallback DEFINE_CLASS(VECTOR64T, Intrinsics, Vector64`1) DEFINE_CLASS(VECTOR128T, Intrinsics, Vector128`1) DEFINE_CLASS(VECTOR256T, Intrinsics, Vector256`1) +DEFINE_CLASS(VECTOR512T, Intrinsics, Vector512`1) DEFINE_CLASS(VECTORT, Numerics, Vector`1) diff --git a/src/coreclr/vm/fieldmarshaler.h b/src/coreclr/vm/fieldmarshaler.h index a5c77ca5bfd11..83b2c79fb4f05 100644 --- a/src/coreclr/vm/fieldmarshaler.h +++ b/src/coreclr/vm/fieldmarshaler.h @@ -24,7 +24,7 @@ class MethodTable; // Currently we set this to the packing size of the largest supported // fundamental type and let the field marshaller downsize where needed. //======================================================================= -#define DEFAULT_PACKING_SIZE 32 +#define DEFAULT_PACKING_SIZE 64 //======================================================================= // This structure contains information about where a field is placed in a structure, as well as it's size and alignment. diff --git a/src/coreclr/vm/methodtable.cpp b/src/coreclr/vm/methodtable.cpp index 0c97fe4064237..8e79bd6ab8498 100644 --- a/src/coreclr/vm/methodtable.cpp +++ b/src/coreclr/vm/methodtable.cpp @@ -2238,8 +2238,8 @@ bool MethodTable::ClassifyEightBytesWithManagedLayout(SystemVStructRegisterPassi LPCUTF8 namespaceName; LPCUTF8 className = GetFullyQualifiedNameInfo(&namespaceName); - if ((strcmp(className, "Vector256`1") == 0) || (strcmp(className, "Vector128`1") == 0) || - (strcmp(className, "Vector64`1") == 0)) + if ((strcmp(className, "Vector512`1") == 0) || (strcmp(className, "Vector256`1") == 0) || + (strcmp(className, "Vector128`1") == 0) || (strcmp(className, "Vector64`1") == 0)) { assert(strcmp(namespaceName, "System.Runtime.Intrinsics") == 0); @@ -2488,8 +2488,8 @@ bool MethodTable::ClassifyEightBytesWithNativeLayout(SystemVStructRegisterPassin LPCUTF8 namespaceName; LPCUTF8 className = GetFullyQualifiedNameInfo(&namespaceName); - if ((strcmp(className, "Vector256`1") == 0) || (strcmp(className, "Vector128`1") == 0) || - (strcmp(className, "Vector64`1") == 0)) + if ((strcmp(className, "Vector512`1") == 0) || (strcmp(className, "Vector256`1") == 0) || + (strcmp(className, "Vector128`1") == 0) || (strcmp(className, "Vector64`1") == 0)) { assert(strcmp(namespaceName, "System.Runtime.Intrinsics") == 0); diff --git a/src/coreclr/vm/methodtablebuilder.cpp b/src/coreclr/vm/methodtablebuilder.cpp index d77b5c5c826d1..fae0605d0b0bd 100644 --- a/src/coreclr/vm/methodtablebuilder.cpp +++ b/src/coreclr/vm/methodtablebuilder.cpp @@ -9884,6 +9884,22 @@ void MethodTableBuilder::CheckForSystemTypes() pLayout->m_ManagedLargestAlignmentRequirementOfAllMembers = 16; #else pLayout->m_ManagedLargestAlignmentRequirementOfAllMembers = 32; // sizeof(__m256) + #endif // TARGET_ARM elif TARGET_ARM64 + } + else if (strcmp(name, g_Vector512Name) == 0) + { + #ifdef TARGET_ARM + // No such type exists for the Procedure Call Standard for ARM. We will default + // to the same alignment as __m128, which is supported by the ABI. + + pLayout->m_ManagedLargestAlignmentRequirementOfAllMembers = 8; + #elif defined(TARGET_ARM64) + // The Procedure Call Standard for ARM 64-bit (with SVE support) defaults to + // 16-byte alignment for __m256. + + pLayout->m_ManagedLargestAlignmentRequirementOfAllMembers = 16; + #else + pLayout->m_ManagedLargestAlignmentRequirementOfAllMembers = 64; // sizeof(__m512) #endif // TARGET_ARM elif TARGET_ARM64 } else diff --git a/src/coreclr/vm/mlinfo.cpp b/src/coreclr/vm/mlinfo.cpp index a0080a6747534..3f74772e014c4 100644 --- a/src/coreclr/vm/mlinfo.cpp +++ b/src/coreclr/vm/mlinfo.cpp @@ -1081,6 +1081,7 @@ namespace // * Vector64: Represents the __m64 ABI primitive which requires currently unimplemented handling // * Vector128: Represents the __m128 ABI primitive which requires currently unimplemented handling // * Vector256: Represents the __m256 ABI primitive which requires currently unimplemented handling + // * Vector512: Represents the __m512 ABI primitive which requires currently unimplemented handling // * Vector: Has a variable size (either __m128 or __m256) and isn't readily usable for interop scenarios return !pMT->HasSameTypeDefAs(g_pNullableClass) && !pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__SPAN)) @@ -1088,6 +1089,7 @@ namespace && !pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__VECTOR64T)) && !pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__VECTOR128T)) && !pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__VECTOR256T)) + && !pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__VECTOR512T)) && !pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__VECTORT)); } diff --git a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems index 9d3d95c4e2631..bb540ae696aac 100644 --- a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems +++ b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems @@ -957,6 +957,9 @@ + + + diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128_1.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128_1.cs index 541f64416fca0..b8e80993de38d 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128_1.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128_1.cs @@ -198,15 +198,10 @@ public T this[int index] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector128 operator /(Vector128 left, T right) { - Unsafe.SkipInit(out Vector128 result); - - for (int index = 0; index < Count; index++) - { - T value = Scalar.Divide(left.GetElementUnsafe(index), right); - result.SetElementUnsafe(index, value); - } - - return result; + return Vector128.Create( + left._lower / right, + left._upper / right + ); } /// Compares two vectors to determine if all elements are equal. @@ -258,15 +253,10 @@ public T this[int index] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector128 operator <<(Vector128 value, int shiftCount) { - Unsafe.SkipInit(out Vector128 result); - - for (int index = 0; index < Count; index++) - { - T element = Scalar.ShiftLeft(value.GetElementUnsafe(index), shiftCount); - result.SetElementUnsafe(index, element); - } - - return result; + return Vector128.Create( + value._lower << shiftCount, + value._upper << shiftCount + ); } /// Multiplies two vectors to compute their element-wise product. @@ -330,15 +320,10 @@ public T this[int index] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector128 operator >>(Vector128 value, int shiftCount) { - Unsafe.SkipInit(out Vector128 result); - - for (int index = 0; index < Count; index++) - { - T element = Scalar.ShiftRightArithmetic(value.GetElementUnsafe(index), shiftCount); - result.SetElementUnsafe(index, element); - } - - return result; + return Vector128.Create( + value._lower >> shiftCount, + value._upper >> shiftCount + ); } /// Subtracts two vectors to compute their difference. @@ -390,15 +375,10 @@ public static Vector128 operator >>(Vector128 value, int shiftCount) [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector128 operator >>>(Vector128 value, int shiftCount) { - Unsafe.SkipInit(out Vector128 result); - - for (int index = 0; index < Count; index++) - { - T element = Scalar.ShiftRightLogical(value.GetElementUnsafe(index), shiftCount); - result.SetElementUnsafe(index, element); - } - - return result; + return Vector128.Create( + value._lower >>> shiftCount, + value._upper >>> shiftCount + ); } /// Determines whether the specified object is equal to the current instance. diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs index 14b8e5bdfd1b0..212133baf28b3 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs @@ -236,7 +236,7 @@ public static Vector256 AsUInt32(this Vector256 vector) public static Vector256 AsUInt64(this Vector256 vector) where T : struct => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. /// reinterpreted as a new . @@ -254,10 +254,10 @@ public static Vector256 AsVector256(this Vector value) return result; } - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -796,7 +796,8 @@ public static Vector256 Create(ReadOnlySpan values) /// On x86, this method corresponds to __m256i _mm256_setr_epi8 [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static Vector256 Create(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7, byte e8, byte e9, byte e10, byte e11, byte e12, byte e13, byte e14, byte e15, byte e16, byte e17, byte e18, byte e19, byte e20, byte e21, byte e22, byte e23, byte e24, byte e25, byte e26, byte e27, byte e28, byte e29, byte e30, byte e31) + public static Vector256 Create(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7, byte e8, byte e9, byte e10, byte e11, byte e12, byte e13, byte e14, byte e15, + byte e16, byte e17, byte e18, byte e19, byte e20, byte e21, byte e22, byte e23, byte e24, byte e25, byte e26, byte e27, byte e28, byte e29, byte e30, byte e31) { return Create( Vector128.Create(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15), @@ -926,7 +927,8 @@ public static Vector256 Create(long e0, long e1, long e2, long e3) [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static Vector256 Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, sbyte e4, sbyte e5, sbyte e6, sbyte e7, sbyte e8, sbyte e9, sbyte e10, sbyte e11, sbyte e12, sbyte e13, sbyte e14, sbyte e15, sbyte e16, sbyte e17, sbyte e18, sbyte e19, sbyte e20, sbyte e21, sbyte e22, sbyte e23, sbyte e24, sbyte e25, sbyte e26, sbyte e27, sbyte e28, sbyte e29, sbyte e30, sbyte e31) + public static Vector256 Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, sbyte e4, sbyte e5, sbyte e6, sbyte e7, sbyte e8, sbyte e9, sbyte e10, sbyte e11, sbyte e12, sbyte e13, sbyte e14, sbyte e15, + sbyte e16, sbyte e17, sbyte e18, sbyte e19, sbyte e20, sbyte e21, sbyte e22, sbyte e23, sbyte e24, sbyte e25, sbyte e26, sbyte e27, sbyte e28, sbyte e29, sbyte e30, sbyte e31) { return Create( Vector128.Create(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15), @@ -2743,6 +2745,41 @@ public static T ToScalar(this Vector256 vector) return vector.GetElementUnsafe(0); } + /// Converts the given vector to a new with the lower 256-bits set to the value of the given vector and the upper 256-bits initialized to zero. + /// The type of the input vector. + /// The vector to extend. + /// A new with the lower 256-bits set to the value of and the upper 256-bits initialized to zero. + /// The type of () is not supported. + [Intrinsic] + public static Vector512 ToVector512(this Vector256 vector) + where T : struct + { + ThrowHelper.ThrowForUnsupportedIntrinsicsVector256BaseType(); + + Vector512 result = default; + result.SetLowerUnsafe(vector); + return result; + } + + /// Converts the given vector to a new with the lower 256-bits set to the value of the given vector and the upper 256-bits left uninitialized. + /// The type of the input vector. + /// The vector to extend. + /// A new with the lower 256-bits set to the value of and the upper 256-bits left uninitialized. + /// The type of () is not supported. + [Intrinsic] + public static unsafe Vector512 ToVector512Unsafe(this Vector256 vector) + where T : struct + { + ThrowHelper.ThrowForUnsupportedIntrinsicsVector256BaseType(); + + // This relies on us stripping the "init" flag from the ".locals" + // declaration to let the upper bits be uninitialized. + + Unsafe.SkipInit(out Vector512 result); + result.SetLowerUnsafe(vector); + return result; + } + /// Tries to copy a to a given span. /// The type of the input vector. /// The vector to copy. @@ -2808,7 +2845,7 @@ public static bool TryCopyTo(this Vector256 vector, Span destination) [MethodImpl(MethodImplOptions.AggressiveInlining)] public static (Vector256 Lower, Vector256 Upper) Widen(Vector256 source) => (WidenLower(source), WidenUpper(source)); - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -2824,7 +2861,7 @@ public static Vector256 WidenLower(Vector256 source) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -2839,7 +2876,7 @@ public static Vector256 WidenLower(Vector256 source) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -2854,7 +2891,7 @@ public static Vector256 WidenLower(Vector256 source) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -2869,7 +2906,7 @@ public static Vector256 WidenLower(Vector256 source) Vector128.WidenUpper(lower) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -2884,7 +2921,7 @@ public static Vector256 WidenLower(Vector256 source) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256_1.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256_1.cs index caa8fe308a2ea..56e19827b31b4 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256_1.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256_1.cs @@ -4,7 +4,6 @@ using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.Globalization; -using System.Numerics; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Text; @@ -197,15 +196,10 @@ public T this[int index] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector256 operator /(Vector256 left, T right) { - Unsafe.SkipInit(out Vector256 result); - - for (int index = 0; index < Count; index++) - { - T value = Scalar.Divide(left.GetElementUnsafe(index), right); - result.SetElementUnsafe(index, value); - } - - return result; + return Vector256.Create( + left._lower / right, + left._upper / right + ); } /// Compares two vectors to determine if all elements are equal. @@ -257,15 +251,10 @@ public T this[int index] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector256 operator <<(Vector256 value, int shiftCount) { - Unsafe.SkipInit(out Vector256 result); - - for (int index = 0; index < Count; index++) - { - T element = Scalar.ShiftLeft(value.GetElementUnsafe(index), shiftCount); - result.SetElementUnsafe(index, element); - } - - return result; + return Vector256.Create( + value._lower << shiftCount, + value._upper << shiftCount + ); } /// Multiplies two vectors to compute their element-wise product. @@ -329,15 +318,10 @@ public T this[int index] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector256 operator >>(Vector256 value, int shiftCount) { - Unsafe.SkipInit(out Vector256 result); - - for (int index = 0; index < Count; index++) - { - T element = Scalar.ShiftRightArithmetic(value.GetElementUnsafe(index), shiftCount); - result.SetElementUnsafe(index, element); - } - - return result; + return Vector256.Create( + value._lower >> shiftCount, + value._upper >> shiftCount + ); } /// Subtracts two vectors to compute their difference. @@ -389,15 +373,10 @@ public static Vector256 operator >>(Vector256 value, int shiftCount) [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector256 operator >>>(Vector256 value, int shiftCount) { - Unsafe.SkipInit(out Vector256 result); - - for (int index = 0; index < Count; index++) - { - T element = Scalar.ShiftRightLogical(value.GetElementUnsafe(index), shiftCount); - result.SetElementUnsafe(index, element); - } - - return result; + return Vector256.Create( + value._lower >>> shiftCount, + value._upper >>> shiftCount + ); } /// Determines whether the specified object is equal to the current instance. diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs new file mode 100644 index 0000000000000..9b7be1d777fb6 --- /dev/null +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs @@ -0,0 +1,3167 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; +using System.Numerics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics.X86; + +namespace System.Runtime.Intrinsics +{ + // We mark certain methods with AggressiveInlining to ensure that the JIT will + // inline them. The JIT would otherwise not inline the method since it, at the + // point it tries to determine inline profability, currently cannot determine + // that most of the code-paths will be optimized away as "dead code". + // + // We then manually inline cases (such as certain intrinsic code-paths) that + // will generate code small enough to make the AgressiveInlining profitable. The + // other cases (such as the software fallback) are placed in their own method. + // This ensures we get good codegen for the "fast-path" and allows the JIT to + // determine inline profitability of the other paths as it would normally. + + // Many of the instance methods were moved to be extension methods as it results + // in overall better codegen. This is because instance methods require the C# compiler + // to generate extra locals as the `this` parameter has to be passed by reference. + // Having them be extension methods means that the `this` parameter can be passed by + // value instead, thus reducing the number of locals and helping prevent us from hitting + // the internal inlining limits of the JIT. + + /// Provides a collection of static methods for creating, manipulating, and otherwise operting on 512-bit vectors. + public static unsafe class Vector512 + { + internal const int Size = 64; + +#if TARGET_ARM + internal const int Alignment = 8; +#elif TARGET_ARM64 + internal const int Alignment = 16; +#else + internal const int Alignment = 64; +#endif + + /// Gets a value that indicates whether 512-bit vector operations are subject to hardware acceleration through JIT intrinsic support. + /// if 512-bit vector operations are subject to hardware acceleration; otherwise, . + /// 512-bit vector operations are subject to hardware acceleration on systems that support Single Instruction, Multiple Data (SIMD) instructions for 512-bit vectors and the RyuJIT just-in-time compiler is used to compile managed code. + public static bool IsHardwareAccelerated + { + [Intrinsic] + get => IsHardwareAccelerated; + } + + /// Computes the absolute value of each element in a vector. + /// The type of the elements in the vector. + /// The vector that will have its absolute value computed. + /// A vector whose elements are the absolute value of the elements in . + /// The type of () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Abs(Vector512 vector) + where T : struct + { + return Create( + Vector256.Abs(vector._lower), + Vector256.Abs(vector._upper) + ); + } + + /// Adds two vectors to compute their sum. + /// The type of the elements in the vector. + /// The vector to add with . + /// The vector to add with . + /// The sum of and . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Add(Vector512 left, Vector512 right) + where T : struct => left + right; + + /// Computes the bitwise-and of a given vector and the ones complement of another vector. + /// The type of the elements in the vector. + /// The vector to bitwise-and with . + /// The vector to that is ones-complemented before being bitwise-and with . + /// The bitwise-and of and the ones-complement of . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 AndNot(Vector512 left, Vector512 right) + where T : struct + { + return Create( + Vector256.AndNot(left._lower, right._lower), + Vector256.AndNot(left._upper, right._upper) + ); + } + + /// Reinterprets a as a new . + /// The type of the elements in the input vector. + /// The type of the elements in the output vector. + /// The vector to reinterpret. + /// reinterpreted as a new . + /// The type of () or the type of the target () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 As(this Vector512 vector) + where TFrom : struct + where TTo : struct + { + ThrowHelper.ThrowForUnsupportedIntrinsicsVector512BaseType(); + ThrowHelper.ThrowForUnsupportedIntrinsicsVector512BaseType(); + + return Unsafe.As, Vector512>(ref vector); + } + + /// Reinterprets a as a new . + /// The type of the elements in the vector. + /// The vector to reinterpret. + /// reinterpreted as a new . + /// The type of () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 AsByte(this Vector512 vector) + where T : struct => vector.As(); + + /// Reinterprets a as a new . + /// The type of the elements in the vector. + /// The vector to reinterpret. + /// reinterpreted as a new . + /// The type of () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 AsDouble(this Vector512 vector) + where T : struct => vector.As(); + + /// Reinterprets a as a new . + /// The type of the elements in the vector. + /// The vector to reinterpret. + /// reinterpreted as a new . + /// The type of () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 AsInt16(this Vector512 vector) + where T : struct => vector.As(); + + /// Reinterprets a as a new . + /// The type of the elements in the vector. + /// The vector to reinterpret. + /// reinterpreted as a new . + /// The type of () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 AsInt32(this Vector512 vector) + where T : struct => vector.As(); + + /// Reinterprets a as a new . + /// The type of the elements in the vector. + /// The vector to reinterpret. + /// reinterpreted as a new . + /// The type of () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 AsInt64(this Vector512 vector) + where T : struct => vector.As(); + + /// Reinterprets a as a new . + /// The type of the elements in the vector. + /// The vector to reinterpret. + /// reinterpreted as a new . + /// The type of () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 AsNInt(this Vector512 vector) + where T : struct => vector.As(); + + /// Reinterprets a as a new . + /// The type of the elements in the vector. + /// The vector to reinterpret. + /// reinterpreted as a new . + /// The type of () is not supported. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 AsNUInt(this Vector512 vector) + where T : struct => vector.As(); + + /// Reinterprets a as a new . + /// The type of the elements in the vector. + /// The vector to reinterpret. + /// reinterpreted as a new . + /// The type of () is not supported. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 AsSByte(this Vector512 vector) + where T : struct => vector.As(); + + /// Reinterprets a as a new . + /// The type of the elements in the vector. + /// The vector to reinterpret. + /// reinterpreted as a new . + /// The type of () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 AsSingle(this Vector512 vector) + where T : struct => vector.As(); + + /// Reinterprets a as a new . + /// The type of the elements in the vector. + /// The vector to reinterpret. + /// reinterpreted as a new . + /// The type of () is not supported. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 AsUInt16(this Vector512 vector) + where T : struct => vector.As(); + + /// Reinterprets a as a new . + /// The type of the elements in the vector. + /// The vector to reinterpret. + /// reinterpreted as a new . + /// The type of () is not supported. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 AsUInt32(this Vector512 vector) + where T : struct => vector.As(); + + /// Reinterprets a as a new . + /// The type of the elements in the vector. + /// The vector to reinterpret. + /// reinterpreted as a new . + /// The type of () is not supported. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 AsUInt64(this Vector512 vector) + where T : struct => vector.As(); + + /// Reinterprets a as a new . + /// The type of the elements in the vector. + /// The vector to reinterpret. + /// reinterpreted as a new . + /// The type of () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 AsVector512(this Vector value) + where T : struct + { + Debug.Assert(Vector512.Count >= Vector.Count); + ThrowHelper.ThrowForUnsupportedIntrinsicsVector512BaseType(); + + Vector512 result = default; + Unsafe.WriteUnaligned(ref Unsafe.As, byte>(ref result), value); + return result; + } + + /// Reinterprets a as a new . + /// The type of the elements in the vector. + /// The vector to reinterpret. + /// reinterpreted as a new . + /// The type of () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector AsVector(this Vector512 value) + where T : struct + { + Debug.Assert(Vector512.Count >= Vector.Count); + ThrowHelper.ThrowForUnsupportedIntrinsicsVector512BaseType(); + + ref byte address = ref Unsafe.As, byte>(ref value); + return Unsafe.ReadUnaligned>(ref address); + } + + /// Computes the bitwise-and of two vectors. + /// The type of the elements in the vector. + /// The vector to bitwise-and with . + /// The vector to bitwise-and with . + /// The bitwise-and of and . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 BitwiseAnd(Vector512 left, Vector512 right) + where T : struct => left & right; + + /// Computes the bitwise-or of two vectors. + /// The type of the elements in the vector. + /// The vector to bitwise-or with . + /// The vector to bitwise-or with . + /// The bitwise-or of and . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 BitwiseOr(Vector512 left, Vector512 right) + where T : struct => left | right; + + /// Computes the ceiling of each element in a vector. + /// The vector that will have its ceiling computed. + /// A vector whose elements are the ceiling of the elements in . + /// + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Ceiling(Vector512 vector) + { + return Create( + Vector256.Ceiling(vector._lower), + Vector256.Ceiling(vector._upper) + ); + } + + /// Computes the ceiling of each element in a vector. + /// The vector that will have its ceiling computed. + /// A vector whose elements are the ceiling of the elements in . + /// + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Ceiling(Vector512 vector) + { + return Create( + Vector256.Ceiling(vector._lower), + Vector256.Ceiling(vector._upper) + ); + } + + /// Conditionally selects a value from two vectors on a bitwise basis. + /// The type of the elements in the vector. + /// The mask that is used to select a value from or . + /// The vector that is selected when the corresponding bit in is one. + /// The vector that is selected when the corresponding bit in is zero. + /// A vector whose bits come from or based on the value of . + /// The type of , , and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ConditionalSelect(Vector512 condition, Vector512 left, Vector512 right) + where T : struct + { + return Create( + Vector256.ConditionalSelect(condition._lower, left._lower, right._lower), + Vector256.ConditionalSelect(condition._upper, left._upper, right._upper) + ); + } + + /// Converts a to a . + /// The vector to convert. + /// The converted vector. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ConvertToDouble(Vector512 vector) + { + return Create( + Vector256.ConvertToDouble(vector._lower), + Vector256.ConvertToDouble(vector._upper) + ); + } + + /// Converts a to a . + /// The vector to convert. + /// The converted vector. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ConvertToDouble(Vector512 vector) + { + return Create( + Vector256.ConvertToDouble(vector._lower), + Vector256.ConvertToDouble(vector._upper) + ); + } + + /// Converts a to a . + /// The vector to convert. + /// The converted vector. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ConvertToInt32(Vector512 vector) + { + return Create( + Vector256.ConvertToInt32(vector._lower), + Vector256.ConvertToInt32(vector._upper) + ); + } + + /// Converts a to a . + /// The vector to convert. + /// The converted vector. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ConvertToInt64(Vector512 vector) + { + return Create( + Vector256.ConvertToInt64(vector._lower), + Vector256.ConvertToInt64(vector._upper) + ); + } + + /// Converts a to a . + /// The vector to convert. + /// The converted vector. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ConvertToSingle(Vector512 vector) + { + return Create( + Vector256.ConvertToSingle(vector._lower), + Vector256.ConvertToSingle(vector._upper) + ); + } + + /// Converts a to a . + /// The vector to convert. + /// The converted vector. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ConvertToSingle(Vector512 vector) + { + return Create( + Vector256.ConvertToSingle(vector._lower), + Vector256.ConvertToSingle(vector._upper) + ); + } + + /// Converts a to a . + /// The vector to convert. + /// The converted vector. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ConvertToUInt32(Vector512 vector) + { + return Create( + Vector256.ConvertToUInt32(vector._lower), + Vector256.ConvertToUInt32(vector._upper) + ); + } + + /// Converts a to a . + /// The vector to convert. + /// The converted vector. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ConvertToUInt64(Vector512 vector) + { + return Create( + Vector256.ConvertToUInt64(vector._lower), + Vector256.ConvertToUInt64(vector._upper) + ); + } + + /// Copies a to a given array. + /// The type of the elements in the vector. + /// The vector to be copied. + /// The array to which is copied. + /// The length of is less than . + /// The type of and () is not supported. + /// is null. + public static void CopyTo(this Vector512 vector, T[] destination) + where T : struct + { + // We explicitly don't check for `null` because historically this has thrown `NullReferenceException` for perf reasons + + if (destination.Length < Vector512.Count) + { + ThrowHelper.ThrowArgumentException_DestinationTooShort(); + } + + ref byte address = ref Unsafe.As(ref MemoryMarshal.GetArrayDataReference(destination)); + Unsafe.WriteUnaligned(ref address, vector); + } + + /// Copies a to a given array starting at the specified index. + /// The type of the elements in the vector. + /// The vector to be copied. + /// The array to which is copied. + /// The starting index of which will be copied to. + /// The length of is less than . + /// is negative or greater than the length of . + /// The type of and () is not supported. + /// is null. + public static void CopyTo(this Vector512 vector, T[] destination, int startIndex) + where T : struct + { + // We explicitly don't check for `null` because historically this has thrown `NullReferenceException` for perf reasons + + if ((uint)startIndex >= (uint)destination.Length) + { + ThrowHelper.ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_IndexMustBeLess(); + } + + if ((destination.Length - startIndex) < Vector512.Count) + { + ThrowHelper.ThrowArgumentException_DestinationTooShort(); + } + + ref byte address = ref Unsafe.As(ref MemoryMarshal.GetArrayDataReference(destination)); + Unsafe.WriteUnaligned(ref Unsafe.Add(ref address, startIndex), vector); + } + + /// Copies a to a given span. + /// The type of the elements in the vector. + /// The vector to be copied. + /// The span to which the is copied. + /// The length of is less than . + /// The type of and () is not supported. + public static void CopyTo(this Vector512 vector, Span destination) + where T : struct + { + if ((uint)destination.Length < (uint)Vector512.Count) + { + ThrowHelper.ThrowArgumentException_DestinationTooShort(); + } + + ref byte address = ref Unsafe.As(ref MemoryMarshal.GetReference(destination)); + Unsafe.WriteUnaligned(ref address, vector); + } + + /// Creates a new instance with all elements initialized to the specified value. + /// The type of the elements in the vector. + /// The value that all elements will be initialized to. + /// A new with all elements initialized to . + /// The type of () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(T value) + where T : struct + { + Vector256 vector = Vector256.Create(value); + return Create(vector, vector); + } + + /// Creates a new instance with all elements initialized to the specified value. + /// The value that all elements will be initialized to. + /// A new with all elements initialized to . + /// On x86, this method corresponds to __m512i _mm512_set1_epi8 + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(byte value) => Create(value); + + /// Creates a new instance with all elements initialized to the specified value. + /// The value that all elements will be initialized to. + /// A new with all elements initialized to . + /// On x86, this method corresponds to __m512d _mm512_set1_pd + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(double value) => Create(value); + + /// Creates a new instance with all elements initialized to the specified value. + /// The value that all elements will be initialized to. + /// A new with all elements initialized to . + /// On x86, this method corresponds to __m512i _mm512_set1_epi16 + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(short value) => Create(value); + + /// Creates a new instance with all elements initialized to the specified value. + /// The value that all elements will be initialized to. + /// A new with all elements initialized to . + /// On x86, this method corresponds to __m512i _mm512_set1_epi32 + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(int value) => Create(value); + + /// Creates a new instance with all elements initialized to the specified value. + /// The value that all elements will be initialized to. + /// A new with all elements initialized to . + /// On x86, this method corresponds to __m512i _mm512_set1_epi64x + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(long value) => Create(value); + + /// Creates a new instance with all elements initialized to the specified value. + /// The value that all elements will be initialized to. + /// A new with all elements initialized to . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(nint value) => Create(value); + + /// Creates a new instance with all elements initialized to the specified value. + /// The value that all elements will be initialized to. + /// A new with all elements initialized to . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(nuint value) => Create(value); + + /// Creates a new instance with all elements initialized to the specified value. + /// The value that all elements will be initialized to. + /// A new with all elements initialized to . + /// On x86, this method corresponds to __m512i _mm512_set1_epi8 + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(sbyte value) => Create(value); + + /// Creates a new instance with all elements initialized to the specified value. + /// The value that all elements will be initialized to. + /// A new with all elements initialized to . + /// On x86, this method corresponds to __m512 _mm512_set1_ps + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(float value) => Create(value); + + /// Creates a new instance with all elements initialized to the specified value. + /// The value that all elements will be initialized to. + /// A new with all elements initialized to . + /// On x86, this method corresponds to __m512i _mm512_set1_epi16 + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(ushort value) => Create(value); + + /// Creates a new instance with all elements initialized to the specified value. + /// The value that all elements will be initialized to. + /// A new with all elements initialized to . + /// On x86, this method corresponds to __m512i _mm512_set1_epi32 + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(uint value) => Create(value); + + /// Creates a new instance with all elements initialized to the specified value. + /// The value that all elements will be initialized to. + /// A new with all elements initialized to . + /// On x86, this method corresponds to __m512i _mm512_set1_epi64x + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(ulong value) => Create(value); + + /// Creates a new from a given array. + /// The type of the elements in the vector. + /// The array from which the vector is created. + /// A new with its elements set to the first elements from . + /// The length of is less than . + /// The type of () is not supported. + /// is null. + public static Vector512 Create(T[] values) + where T : struct + { + // We explicitly don't check for `null` because historically this has thrown `NullReferenceException` for perf reasons + + if (values.Length < Vector512.Count) + { + ThrowHelper.ThrowArgumentOutOfRange_IndexMustBeLessOrEqualException(); + } + + ref byte address = ref Unsafe.As(ref MemoryMarshal.GetArrayDataReference(values)); + return Unsafe.ReadUnaligned>(ref address); + } + + /// Creates a new from a given array. + /// The type of the elements in the vector. + /// The array from which the vector is created. + /// The index in at which to being reading elements. + /// A new with its elements set to the first elements from . + /// The length of , starting from , is less than . + /// The type of () is not supported. + /// is null. + public static Vector512 Create(T[] values, int index) + where T : struct + { + // We explicitly don't check for `null` because historically this has thrown `NullReferenceException` for perf reasons + + if ((index < 0) || ((values.Length - index) < Vector512.Count)) + { + ThrowHelper.ThrowArgumentOutOfRange_IndexMustBeLessOrEqualException(); + } + + ref byte address = ref Unsafe.As(ref MemoryMarshal.GetArrayDataReference(values)); + return Unsafe.ReadUnaligned>(ref Unsafe.Add(ref address, index)); + } + + /// Creates a new from a given readonly span. + /// The type of the elements in the vector. + /// The readonly span from which the vector is created. + /// A new with its elements set to the first elements from . + /// The length of is less than . + /// The type of () is not supported. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(ReadOnlySpan values) + where T : struct + { + if (values.Length < Vector512.Count) + { + ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.values); + } + + ref byte address = ref Unsafe.As(ref MemoryMarshal.GetReference(values)); + return Unsafe.ReadUnaligned>(ref address); + } + + /// Creates a new instance with each element initialized to the corresponding specified value. + /// The value that element 0 will be initialized to. + /// The value that element 1 will be initialized to. + /// The value that element 2 will be initialized to. + /// The value that element 3 will be initialized to. + /// The value that element 4 will be initialized to. + /// The value that element 5 will be initialized to. + /// The value that element 6 will be initialized to. + /// The value that element 7 will be initialized to. + /// The value that element 8 will be initialized to. + /// The value that element 9 will be initialized to. + /// The value that element 10 will be initialized to. + /// The value that element 11 will be initialized to. + /// The value that element 12 will be initialized to. + /// The value that element 13 will be initialized to. + /// The value that element 14 will be initialized to. + /// The value that element 15 will be initialized to. + /// The value that element 16 will be initialized to. + /// The value that element 17 will be initialized to. + /// The value that element 18 will be initialized to. + /// The value that element 19 will be initialized to. + /// The value that element 20 will be initialized to. + /// The value that element 21 will be initialized to. + /// The value that element 22 will be initialized to. + /// The value that element 23 will be initialized to. + /// The value that element 24 will be initialized to. + /// The value that element 25 will be initialized to. + /// The value that element 26 will be initialized to. + /// The value that element 27 will be initialized to. + /// The value that element 28 will be initialized to. + /// The value that element 29 will be initialized to. + /// The value that element 30 will be initialized to. + /// The value that element 31 will be initialized to. + /// The value that element 32 will be initialized to. + /// The value that element 33 will be initialized to. + /// The value that element 34 will be initialized to. + /// The value that element 35 will be initialized to. + /// The value that element 36 will be initialized to. + /// The value that element 37 will be initialized to. + /// The value that element 38 will be initialized to. + /// The value that element 39 will be initialized to. + /// The value that element 40 will be initialized to. + /// The value that element 41 will be initialized to. + /// The value that element 42 will be initialized to. + /// The value that element 43 will be initialized to. + /// The value that element 44 will be initialized to. + /// The value that element 45 will be initialized to. + /// The value that element 46 will be initialized to. + /// The value that element 47 will be initialized to. + /// The value that element 48 will be initialized to. + /// The value that element 49 will be initialized to. + /// The value that element 50 will be initialized to. + /// The value that element 51 will be initialized to. + /// The value that element 52 will be initialized to. + /// The value that element 53 will be initialized to. + /// The value that element 54 will be initialized to. + /// The value that element 55 will be initialized to. + /// The value that element 56 will be initialized to. + /// The value that element 57 will be initialized to. + /// The value that element 58 will be initialized to. + /// The value that element 59 will be initialized to. + /// The value that element 60 will be initialized to. + /// The value that element 61 will be initialized to. + /// The value that element 62 will be initialized to. + /// The value that element 63 will be initialized to. + /// A new with each element initialized to corresponding specified value. + /// On x86, this method corresponds to __m512i _mm512_setr_epi8 + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7, byte e8, byte e9, byte e10, byte e11, byte e12, byte e13, byte e14, byte e15, + byte e16, byte e17, byte e18, byte e19, byte e20, byte e21, byte e22, byte e23, byte e24, byte e25, byte e26, byte e27, byte e28, byte e29, byte e30, byte e31, + byte e32, byte e33, byte e34, byte e35, byte e36, byte e37, byte e38, byte e39, byte e40, byte e41, byte e42, byte e43, byte e44, byte e45, byte e46, byte e47, + byte e48, byte e49, byte e50, byte e51, byte e52, byte e53, byte e54, byte e55, byte e56, byte e57, byte e58, byte e59, byte e60, byte e61, byte e62, byte e63) + { + return Create( + Vector256.Create(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31), + Vector256.Create(e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) + ); + } + + /// Creates a new instance with each element initialized to the corresponding specified value. + /// The value that element 0 will be initialized to. + /// The value that element 1 will be initialized to. + /// The value that element 2 will be initialized to. + /// The value that element 3 will be initialized to. + /// The value that element 4 will be initialized to. + /// The value that element 5 will be initialized to. + /// The value that element 6 will be initialized to. + /// The value that element 7 will be initialized to. + /// A new with each element initialized to corresponding specified value. + /// On x86, this method corresponds to __m512d _mm512_setr_pd + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(double e0, double e1, double e2, double e3, double e4, double e5, double e6, double e7) + { + return Create( + Vector256.Create(e0, e1, e2, e3), + Vector256.Create(e4, e5, e6, e7) + ); + } + + /// Creates a new instance with each element initialized to the corresponding specified value. + /// The value that element 0 will be initialized to. + /// The value that element 1 will be initialized to. + /// The value that element 2 will be initialized to. + /// The value that element 3 will be initialized to. + /// The value that element 4 will be initialized to. + /// The value that element 5 will be initialized to. + /// The value that element 6 will be initialized to. + /// The value that element 7 will be initialized to. + /// The value that element 8 will be initialized to. + /// The value that element 9 will be initialized to. + /// The value that element 10 will be initialized to. + /// The value that element 11 will be initialized to. + /// The value that element 12 will be initialized to. + /// The value that element 13 will be initialized to. + /// The value that element 14 will be initialized to. + /// The value that element 15 will be initialized to. + /// The value that element 16 will be initialized to. + /// The value that element 17 will be initialized to. + /// The value that element 18 will be initialized to. + /// The value that element 19 will be initialized to. + /// The value that element 20 will be initialized to. + /// The value that element 21 will be initialized to. + /// The value that element 22 will be initialized to. + /// The value that element 23 will be initialized to. + /// The value that element 24 will be initialized to. + /// The value that element 25 will be initialized to. + /// The value that element 26 will be initialized to. + /// The value that element 27 will be initialized to. + /// The value that element 28 will be initialized to. + /// The value that element 29 will be initialized to. + /// The value that element 30 will be initialized to. + /// The value that element 31 will be initialized to. + /// A new with each element initialized to corresponding specified value. + /// On x86, this method corresponds to __m512i _mm512_setr_epi16 + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(short e0, short e1, short e2, short e3, short e4, short e5, short e6, short e7, short e8, short e9, short e10, short e11, short e12, short e13, short e14, short e15, + short e16, short e17, short e18, short e19, short e20, short e21, short e22, short e23, short e24, short e25, short e26, short e27, short e28, short e29, short e30, short e31) + { + return Create( + Vector256.Create(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15), + Vector256.Create(e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31) + ); + } + + /// Creates a new instance with each element initialized to the corresponding specified value. + /// The value that element 0 will be initialized to. + /// The value that element 1 will be initialized to. + /// The value that element 2 will be initialized to. + /// The value that element 3 will be initialized to. + /// The value that element 4 will be initialized to. + /// The value that element 5 will be initialized to. + /// The value that element 6 will be initialized to. + /// The value that element 7 will be initialized to. + /// The value that element 8 will be initialized to. + /// The value that element 9 will be initialized to. + /// The value that element 10 will be initialized to. + /// The value that element 11 will be initialized to. + /// The value that element 12 will be initialized to. + /// The value that element 13 will be initialized to. + /// The value that element 14 will be initialized to. + /// The value that element 15 will be initialized to. + /// A new with each element initialized to corresponding specified value. + /// On x86, this method corresponds to __m512i _mm512_setr_epi32 + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(int e0, int e1, int e2, int e3, int e4, int e5, int e6, int e7, int e8, int e9, int e10, int e11, int e12, int e13, int e14, int e15) + { + return Create( + Vector256.Create(e0, e1, e2, e3, e4, e5, e6, e7), + Vector256.Create(e8, e9, e10, e11, e12, e13, e14, e15) + ); + } + + /// Creates a new instance with each element initialized to the corresponding specified value. + /// The value that element 0 will be initialized to. + /// The value that element 1 will be initialized to. + /// The value that element 2 will be initialized to. + /// The value that element 3 will be initialized to. + /// The value that element 4 will be initialized to. + /// The value that element 5 will be initialized to. + /// The value that element 6 will be initialized to. + /// The value that element 7 will be initialized to. + /// A new with each element initialized to corresponding specified value. + /// On x86, this method corresponds to __m512i _mm512_setr_epi64x + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(long e0, long e1, long e2, long e3, long e4, long e5, long e6, long e7) + { + return Create( + Vector256.Create(e0, e1, e2, e3), + Vector256.Create(e4, e5, e6, e7) + ); + } + + /// Creates a new instance with each element initialized to the corresponding specified value. + /// The value that element 0 will be initialized to. + /// The value that element 1 will be initialized to. + /// The value that element 2 will be initialized to. + /// The value that element 3 will be initialized to. + /// The value that element 4 will be initialized to. + /// The value that element 5 will be initialized to. + /// The value that element 6 will be initialized to. + /// The value that element 7 will be initialized to. + /// The value that element 8 will be initialized to. + /// The value that element 9 will be initialized to. + /// The value that element 10 will be initialized to. + /// The value that element 11 will be initialized to. + /// The value that element 12 will be initialized to. + /// The value that element 13 will be initialized to. + /// The value that element 14 will be initialized to. + /// The value that element 15 will be initialized to. + /// The value that element 16 will be initialized to. + /// The value that element 17 will be initialized to. + /// The value that element 18 will be initialized to. + /// The value that element 19 will be initialized to. + /// The value that element 20 will be initialized to. + /// The value that element 21 will be initialized to. + /// The value that element 22 will be initialized to. + /// The value that element 23 will be initialized to. + /// The value that element 24 will be initialized to. + /// The value that element 25 will be initialized to. + /// The value that element 26 will be initialized to. + /// The value that element 27 will be initialized to. + /// The value that element 28 will be initialized to. + /// The value that element 29 will be initialized to. + /// The value that element 30 will be initialized to. + /// The value that element 31 will be initialized to. + /// The value that element 32 will be initialized to. + /// The value that element 33 will be initialized to. + /// The value that element 34 will be initialized to. + /// The value that element 35 will be initialized to. + /// The value that element 36 will be initialized to. + /// The value that element 37 will be initialized to. + /// The value that element 38 will be initialized to. + /// The value that element 39 will be initialized to. + /// The value that element 40 will be initialized to. + /// The value that element 41 will be initialized to. + /// The value that element 42 will be initialized to. + /// The value that element 43 will be initialized to. + /// The value that element 44 will be initialized to. + /// The value that element 45 will be initialized to. + /// The value that element 46 will be initialized to. + /// The value that element 47 will be initialized to. + /// The value that element 48 will be initialized to. + /// The value that element 49 will be initialized to. + /// The value that element 50 will be initialized to. + /// The value that element 51 will be initialized to. + /// The value that element 52 will be initialized to. + /// The value that element 53 will be initialized to. + /// The value that element 54 will be initialized to. + /// The value that element 55 will be initialized to. + /// The value that element 56 will be initialized to. + /// The value that element 57 will be initialized to. + /// The value that element 58 will be initialized to. + /// The value that element 59 will be initialized to. + /// The value that element 60 will be initialized to. + /// The value that element 61 will be initialized to. + /// The value that element 62 will be initialized to. + /// The value that element 63 will be initialized to. + /// A new with each element initialized to corresponding specified value. + /// On x86, this method corresponds to __m512i _mm512_setr_epi8 + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, sbyte e4, sbyte e5, sbyte e6, sbyte e7, sbyte e8, sbyte e9, sbyte e10, sbyte e11, sbyte e12, sbyte e13, sbyte e14, sbyte e15, + sbyte e16, sbyte e17, sbyte e18, sbyte e19, sbyte e20, sbyte e21, sbyte e22, sbyte e23, sbyte e24, sbyte e25, sbyte e26, sbyte e27, sbyte e28, sbyte e29, sbyte e30, sbyte e31, + sbyte e32, sbyte e33, sbyte e34, sbyte e35, sbyte e36, sbyte e37, sbyte e38, sbyte e39, sbyte e40, sbyte e41, sbyte e42, sbyte e43, sbyte e44, sbyte e45, sbyte e46, sbyte e47, + sbyte e48, sbyte e49, sbyte e50, sbyte e51, sbyte e52, sbyte e53, sbyte e54, sbyte e55, sbyte e56, sbyte e57, sbyte e58, sbyte e59, sbyte e60, sbyte e61, sbyte e62, sbyte e63) + { + return Create( + Vector256.Create(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31), + Vector256.Create(e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) + ); + } + + /// Creates a new instance with each element initialized to the corresponding specified value. + /// The value that element 0 will be initialized to. + /// The value that element 1 will be initialized to. + /// The value that element 2 will be initialized to. + /// The value that element 3 will be initialized to. + /// The value that element 4 will be initialized to. + /// The value that element 5 will be initialized to. + /// The value that element 6 will be initialized to. + /// The value that element 7 will be initialized to. + /// The value that element 8 will be initialized to. + /// The value that element 9 will be initialized to. + /// The value that element 10 will be initialized to. + /// The value that element 11 will be initialized to. + /// The value that element 12 will be initialized to. + /// The value that element 13 will be initialized to. + /// The value that element 14 will be initialized to. + /// The value that element 15 will be initialized to. + /// A new with each element initialized to corresponding specified value. + /// On x86, this method corresponds to __m512 _mm512_setr_ps + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(float e0, float e1, float e2, float e3, float e4, float e5, float e6, float e7, float e8, float e9, float e10, float e11, float e12, float e13, float e14, float e15) + { + return Create( + Vector256.Create(e0, e1, e2, e3, e4, e5, e6, e7), + Vector256.Create(e8, e9, e10, e11, e12, e13, e14, e15) + ); + } + + /// Creates a new instance with each element initialized to the corresponding specified value. + /// The value that element 0 will be initialized to. + /// The value that element 1 will be initialized to. + /// The value that element 2 will be initialized to. + /// The value that element 3 will be initialized to. + /// The value that element 4 will be initialized to. + /// The value that element 5 will be initialized to. + /// The value that element 6 will be initialized to. + /// The value that element 7 will be initialized to. + /// The value that element 8 will be initialized to. + /// The value that element 9 will be initialized to. + /// The value that element 10 will be initialized to. + /// The value that element 11 will be initialized to. + /// The value that element 12 will be initialized to. + /// The value that element 13 will be initialized to. + /// The value that element 14 will be initialized to. + /// The value that element 15 will be initialized to. + /// The value that element 16 will be initialized to. + /// The value that element 17 will be initialized to. + /// The value that element 18 will be initialized to. + /// The value that element 19 will be initialized to. + /// The value that element 20 will be initialized to. + /// The value that element 21 will be initialized to. + /// The value that element 22 will be initialized to. + /// The value that element 23 will be initialized to. + /// The value that element 24 will be initialized to. + /// The value that element 25 will be initialized to. + /// The value that element 26 will be initialized to. + /// The value that element 27 will be initialized to. + /// The value that element 28 will be initialized to. + /// The value that element 29 will be initialized to. + /// The value that element 30 will be initialized to. + /// The value that element 31 will be initialized to. + /// A new with each element initialized to corresponding specified value. + /// On x86, this method corresponds to __m512i _mm512_setr_epi16 + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(ushort e0, ushort e1, ushort e2, ushort e3, ushort e4, ushort e5, ushort e6, ushort e7, ushort e8, ushort e9, ushort e10, ushort e11, ushort e12, ushort e13, ushort e14, ushort e15, + ushort e16, ushort e17, ushort e18, ushort e19, ushort e20, ushort e21, ushort e22, ushort e23, ushort e24, ushort e25, ushort e26, ushort e27, ushort e28, ushort e29, ushort e30, ushort e31) + { + return Create( + Vector256.Create(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15), + Vector256.Create(e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31) + ); + } + + /// Creates a new instance with each element initialized to the corresponding specified value. + /// The value that element 0 will be initialized to. + /// The value that element 1 will be initialized to. + /// The value that element 2 will be initialized to. + /// The value that element 3 will be initialized to. + /// The value that element 4 will be initialized to. + /// The value that element 5 will be initialized to. + /// The value that element 6 will be initialized to. + /// The value that element 7 will be initialized to. + /// The value that element 8 will be initialized to. + /// The value that element 9 will be initialized to. + /// The value that element 10 will be initialized to. + /// The value that element 11 will be initialized to. + /// The value that element 12 will be initialized to. + /// The value that element 13 will be initialized to. + /// The value that element 14 will be initialized to. + /// The value that element 15 will be initialized to. + /// A new with each element initialized to corresponding specified value. + /// On x86, this method corresponds to __m512i _mm512_setr_epi32 + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(uint e0, uint e1, uint e2, uint e3, uint e4, uint e5, uint e6, uint e7, uint e8, uint e9, uint e10, uint e11, uint e12, uint e13, uint e14, uint e15) + { + return Create( + Vector256.Create(e0, e1, e2, e3, e4, e5, e6, e7), + Vector256.Create(e8, e9, e10, e11, e12, e13, e14, e15) + ); + } + + /// Creates a new instance with each element initialized to the corresponding specified value. + /// The value that element 0 will be initialized to. + /// The value that element 1 will be initialized to. + /// The value that element 2 will be initialized to. + /// The value that element 3 will be initialized to. + /// The value that element 4 will be initialized to. + /// The value that element 5 will be initialized to. + /// The value that element 6 will be initialized to. + /// The value that element 7 will be initialized to. + /// A new with each element initialized to corresponding specified value. + /// On x86, this method corresponds to __m512i _mm512_setr_epi64x + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(ulong e0, ulong e1, ulong e2, ulong e3, ulong e4, ulong e5, ulong e6, ulong e7) + { + return Create( + Vector256.Create(e0, e1, e2, e3), + Vector256.Create(e4, e5, e6, e7) + ); + } + + /// Creates a new instance from two instances. + /// The type of the elements in the vector. + /// The value that the lower 256-bits will be initialized to. + /// The value that the upper 256-bits will be initialized to. + /// A new initialized from and . + /// The type of and () is not supported. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(Vector256 lower, Vector256 upper) + where T : struct + { + ThrowHelper.ThrowForUnsupportedIntrinsicsVector512BaseType(); + Unsafe.SkipInit(out Vector512 result); + + result.SetLowerUnsafe(lower); + result.SetUpperUnsafe(upper); + + return result; + } + + /// Creates a new instance from two instances. + /// The value that the lower 256-bits will be initialized to. + /// The value that the upper 256-bits will be initialized to. + /// A new initialized from and . + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); + + /// Creates a new instance from two instances. + /// The value that the lower 256-bits will be initialized to. + /// The value that the upper 256-bits will be initialized to. + /// A new initialized from and . + /// On x86, this method corresponds to __m512d _mm512_setr_m256d (__m256d lo, __m256d hi) + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); + + /// Creates a new instance from two instances. + /// The value that the lower 256-bits will be initialized to. + /// The value that the upper 256-bits will be initialized to. + /// A new initialized from and . + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); + + /// Creates a new instance from two instances. + /// The value that the lower 256-bits will be initialized to. + /// The value that the upper 256-bits will be initialized to. + /// A new initialized from and . + /// On x86, this method corresponds to __m512i _mm512_setr_m256i (__m256i lo, __m256i hi) + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); + + /// Creates a new instance from two instances. + /// The value that the lower 256-bits will be initialized to. + /// The value that the upper 256-bits will be initialized to. + /// A new initialized from and . + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); + + /// Creates a new instance from two instances. + /// The value that the lower 256-bits will be initialized to. + /// The value that the upper 256-bits will be initialized to. + /// A new initialized from and . + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); + + /// Creates a new instance from two instances. + /// The value that the lower 256-bits will be initialized to. + /// The value that the upper 256-bits will be initialized to. + /// A new initialized from and . + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); + + /// Creates a new instance from two instances. + /// The value that the lower 256-bits will be initialized to. + /// The value that the upper 256-bits will be initialized to. + /// A new initialized from and . + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); + + /// Creates a new instance from two instances. + /// The value that the lower 256-bits will be initialized to. + /// The value that the upper 256-bits will be initialized to. + /// A new initialized from and . + /// On x86, this method corresponds to __m512 _mm512_setr_m256 (__m256 lo, __m256 hi) + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); + + /// Creates a new instance from two instances. + /// The value that the lower 256-bits will be initialized to. + /// The value that the upper 256-bits will be initialized to. + /// A new initialized from and . + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); + + /// Creates a new instance from two instances. + /// The value that the lower 256-bits will be initialized to. + /// The value that the upper 256-bits will be initialized to. + /// A new initialized from and . + /// On x86, this method corresponds to __m512i _mm512_setr_m256i (__m256i lo, __m256i hi) + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); + + /// Creates a new instance from two instances. + /// The value that the lower 256-bits will be initialized to. + /// The value that the upper 256-bits will be initialized to. + /// A new initialized from and . + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// The type of the elements in the vector. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// The type of () is not supported. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalar(T value) + where T : struct => Vector256.CreateScalar(value).ToVector512(); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalar(byte value) => CreateScalar(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalar(double value) => CreateScalar(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalar(short value) => CreateScalar(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalar(int value) => CreateScalar(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalar(long value) => CreateScalar(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalar(nint value) => CreateScalar(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalar(nuint value) => CreateScalar(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalar(sbyte value) => CreateScalar(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalar(float value) => CreateScalar(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalar(ushort value) => CreateScalar(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalar(uint value) => CreateScalar(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalar(ulong value) => CreateScalar(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// The type of the elements in the vector. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// The type of () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalarUnsafe(T value) + where T : struct + { + // This relies on us stripping the "init" flag from the ".locals" + // declaration to let the upper bits be uninitialized. + + ThrowHelper.ThrowForUnsupportedIntrinsicsVector512BaseType(); + Unsafe.SkipInit(out Vector512 result); + + result.SetElementUnsafe(0, value); + return result; + } + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalarUnsafe(byte value) => CreateScalarUnsafe(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalarUnsafe(double value) => CreateScalarUnsafe(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalarUnsafe(short value) => CreateScalarUnsafe(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalarUnsafe(int value) => CreateScalarUnsafe(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalarUnsafe(long value) => CreateScalarUnsafe(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalarUnsafe(nint value) => CreateScalarUnsafe(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalarUnsafe(nuint value) => CreateScalarUnsafe(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalarUnsafe(sbyte value) => CreateScalarUnsafe(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalarUnsafe(float value) => CreateScalarUnsafe(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalarUnsafe(ushort value) => CreateScalarUnsafe(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalarUnsafe(uint value) => CreateScalarUnsafe(value); + + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// The value that element 0 will be initialized to. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 CreateScalarUnsafe(ulong value) => CreateScalarUnsafe(value); + + /// Divides two vectors to compute their quotient. + /// The type of the elements in the vector. + /// The vector that will be divided by . + /// The vector that will divide . + /// The quotient of divided by . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Divide(Vector512 left, Vector512 right) + where T : struct + { + return Create( + Vector256.Divide(left._lower, right._lower), + Vector256.Divide(left._upper, right._upper) + ); + } + + /// Divides a vector by a scalar to compute the per-element quotient. + /// The vector that will be divided by . + /// The scalar that will divide . + /// The type of the elements in the vector. + /// The quotient of divided by . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Divide(Vector512 left, T right) + where T : struct => left / right; + + /// Computes the dot product of two vectors. + /// The type of the elements in the vector. + /// The vector that will be dotted with . + /// The vector that will be dotted with . + /// The dot product of and . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static T Dot(Vector512 left, Vector512 right) + where T : struct + { + // Doing this as Dot(lower) + Dot(upper) is important for floating-point determinism + // This is because the underlying dpps instruction on x86/x64 will do this equivalently + // and otherwise the software vs accelerated implementations may differ in returned result. + + T result = Vector256.Dot(left._lower, right._lower); + result = Scalar.Add(result, Vector256.Dot(left._upper, right._upper)); + return result; + } + + /// Compares two vectors to determine if they are equal on a per-element basis. + /// The type of the elements in the vector. + /// The vector to compare with . + /// The vector to compare with . + /// A vector whose elements are all-bits-set or zero, depending on if the corresponding elements in and were equal. + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Equals(Vector512 left, Vector512 right) + where T : struct + { + return Create( + Vector256.Equals(left._lower, right._lower), + Vector256.Equals(left._upper, right._upper) + ); + } + + /// Compares two vectors to determine if all elements are equal. + /// The vector to compare with . + /// The vector to compare with . + /// The type of the elements in the vector. + /// true if all elements in were equal to the corresponding element in . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool EqualsAll(Vector512 left, Vector512 right) + where T : struct => left == right; + + /// Compares two vectors to determine if any elements are equal. + /// The vector to compare with . + /// The vector to compare with . + /// The type of the elements in the vector. + /// true if any elements in was equal to the corresponding element in . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool EqualsAny(Vector512 left, Vector512 right) + where T : struct + { + return Vector256.EqualsAny(left._lower, right._lower) + || Vector256.EqualsAny(left._upper, right._upper); + } + + /// Extracts the most significant bit from each element in a vector. + /// The vector whose elements should have their most significant bit extracted. + /// The type of the elements in the vector. + /// The packed most significant bits extracted from the elements in . + /// The type of () is not supported. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong ExtractMostSignificantBits(this Vector512 vector) + where T : struct + { + ulong result = vector._lower.ExtractMostSignificantBits(); + result |= (ulong)(vector._upper.ExtractMostSignificantBits()) << Vector256.Count; + return result; + } + + /// Computes the floor of each element in a vector. + /// The vector that will have its floor computed. + /// A vector whose elements are the floor of the elements in . + /// + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Floor(Vector512 vector) + { + return Create( + Vector256.Floor(vector._lower), + Vector256.Floor(vector._upper) + ); + } + + /// Computes the floor of each element in a vector. + /// The vector that will have its floor computed. + /// A vector whose elements are the floor of the elements in . + /// + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Floor(Vector512 vector) + { + return Create( + Vector256.Floor(vector._lower), + Vector256.Floor(vector._upper) + ); + } + + /// Gets the element at the specified index. + /// The type of the input vector. + /// The vector to get the element from. + /// The index of the element to get. + /// The value of the element at . + /// was less than zero or greater than the number of elements. + /// The type of () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static T GetElement(this Vector512 vector, int index) + where T : struct + { + if ((uint)(index) >= (uint)(Vector512.Count)) + { + ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index); + } + + return vector.GetElementUnsafe(index); + } + + /// Gets the value of the lower 256-bits as a new . + /// The type of the input vector. + /// The vector to get the lower 256-bits from. + /// The value of the lower 256-bits as a new . + /// The type of () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector256 GetLower(this Vector512 vector) + where T : struct + { + ThrowHelper.ThrowForUnsupportedIntrinsicsVector512BaseType(); + return vector._lower; + } + + /// Gets the value of the upper 256-bits as a new . + /// The type of the input vector. + /// The vector to get the upper 256-bits from. + /// The value of the upper 256-bits as a new . + /// The type of () is not supported. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector256 GetUpper(this Vector512 vector) + where T : struct + { + ThrowHelper.ThrowForUnsupportedIntrinsicsVector512BaseType(); + return vector._upper; + } + + /// Compares two vectors to determine which is greater on a per-element basis. + /// The type of the elements in the vector. + /// The vector to compare with . + /// The vector to compare with . + /// A vector whose elements are all-bits-set or zero, depending on if which of the corresponding elements in and were greater. + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 GreaterThan(Vector512 left, Vector512 right) + where T : struct + { + return Create( + Vector256.GreaterThan(left._lower, right._lower), + Vector256.GreaterThan(left._upper, right._upper) + ); + } + + /// Compares two vectors to determine if all elements are greater. + /// The type of the elements in the vector. + /// The vector to compare with . + /// The vector to compare with . + /// true if all elements in were greater than the corresponding element in . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool GreaterThanAll(Vector512 left, Vector512 right) + where T : struct + { + return Vector256.GreaterThanAll(left._lower, right._lower) + && Vector256.GreaterThanAll(left._upper, right._upper); + } + + /// Compares two vectors to determine if any elements are greater. + /// The type of the elements in the vector. + /// The vector to compare with . + /// The vector to compare with . + /// true if any elements in was greater than the corresponding element in . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool GreaterThanAny(Vector512 left, Vector512 right) + where T : struct + { + return Vector256.GreaterThanAny(left._lower, right._lower) + || Vector256.GreaterThanAny(left._upper, right._upper); + } + + /// Compares two vectors to determine which is greater or equal on a per-element basis. + /// The type of the elements in the vector. + /// The vector to compare with . + /// The vector to compare with . + /// A vector whose elements are all-bits-set or zero, depending on if which of the corresponding elements in and were greater or equal. + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 GreaterThanOrEqual(Vector512 left, Vector512 right) + where T : struct + { + return Create( + Vector256.GreaterThanOrEqual(left._lower, right._lower), + Vector256.GreaterThanOrEqual(left._upper, right._upper) + ); + } + + /// Compares two vectors to determine if all elements are greater or equal. + /// The type of the elements in the vector. + /// The vector to compare with . + /// The vector to compare with . + /// true if all elements in were greater than or equal to the corresponding element in . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool GreaterThanOrEqualAll(Vector512 left, Vector512 right) + where T : struct + { + return Vector256.GreaterThanOrEqualAll(left._lower, right._lower) + && Vector256.GreaterThanOrEqualAll(left._upper, right._upper); + } + + /// Compares two vectors to determine if any elements are greater or equal. + /// The type of the elements in the vector. + /// The vector to compare with . + /// The vector to compare with . + /// true if any elements in was greater than or equal to the corresponding element in . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool GreaterThanOrEqualAny(Vector512 left, Vector512 right) + where T : struct + { + return Vector256.GreaterThanOrEqualAny(left._lower, right._lower) + || Vector256.GreaterThanOrEqualAny(left._upper, right._upper); + } + + /// Compares two vectors to determine which is less on a per-element basis. + /// The type of the elements in the vector. + /// The vector to compare with . + /// The vector to compare with . + /// A vector whose elements are all-bits-set or zero, depending on if which of the corresponding elements in and were less. + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 LessThan(Vector512 left, Vector512 right) + where T : struct + { + return Create( + Vector256.LessThan(left._lower, right._lower), + Vector256.LessThan(left._upper, right._upper) + ); + } + + /// Compares two vectors to determine if all elements are less. + /// The type of the elements in the vector. + /// The vector to compare with . + /// The vector to compare with . + /// true if all elements in were less than the corresponding element in . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool LessThanAll(Vector512 left, Vector512 right) + where T : struct + { + return Vector256.LessThanAll(left._lower, right._lower) + && Vector256.LessThanAll(left._upper, right._upper); + } + + /// Compares two vectors to determine if any elements are less. + /// The type of the elements in the vector. + /// The vector to compare with . + /// The vector to compare with . + /// true if any elements in was less than the corresponding element in . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool LessThanAny(Vector512 left, Vector512 right) + where T : struct + { + return Vector256.LessThanAny(left._lower, right._lower) + || Vector256.LessThanAny(left._upper, right._upper); + } + + /// Compares two vectors to determine which is less or equal on a per-element basis. + /// The type of the elements in the vector. + /// The vector to compare with . + /// The vector to compare with . + /// A vector whose elements are all-bits-set or zero, depending on if which of the corresponding elements in and were less or equal. + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 LessThanOrEqual(Vector512 left, Vector512 right) + where T : struct + { + return Create( + Vector256.LessThanOrEqual(left._lower, right._lower), + Vector256.LessThanOrEqual(left._upper, right._upper) + ); + } + + /// Compares two vectors to determine if all elements are less or equal. + /// The type of the elements in the vector. + /// The vector to compare with . + /// The vector to compare with . + /// true if all elements in were less than or equal to the corresponding element in . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool LessThanOrEqualAll(Vector512 left, Vector512 right) + where T : struct + { + return Vector256.LessThanOrEqualAll(left._lower, right._lower) + && Vector256.LessThanOrEqualAll(left._upper, right._upper); + } + + /// Compares two vectors to determine if any elements are less or equal. + /// The type of the elements in the vector. + /// The vector to compare with . + /// The vector to compare with . + /// true if any elements in was less than or equal to the corresponding element in . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool LessThanOrEqualAny(Vector512 left, Vector512 right) + where T : struct + { + return Vector256.LessThanOrEqualAny(left._lower, right._lower) + || Vector256.LessThanOrEqualAny(left._upper, right._upper); + } + + /// Loads a vector from the given source. + /// The type of the elements in the vector. + /// The source from which the vector will be loaded. + /// The vector loaded from . + /// The type of () is not supported. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Load(T* source) + where T : unmanaged => LoadUnsafe(ref *source); + + /// Loads a vector from the given aligned source. + /// The type of the elements in the vector. + /// The aligned source from which the vector will be loaded. + /// The vector loaded from . + /// The type of () is not supported. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 LoadAligned(T* source) + where T : unmanaged + { + ThrowHelper.ThrowForUnsupportedIntrinsicsVector512BaseType(); + + if (((nuint)(source) % Alignment) != 0) + { + ThrowHelper.ThrowAccessViolationException(); + } + + return *(Vector512*)(source); + } + + /// Loads a vector from the given aligned source. + /// The type of the elements in the vector. + /// The aligned source from which the vector will be loaded. + /// The vector loaded from . + /// The type of () is not supported. + /// This method may bypass the cache on certain platforms. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 LoadAlignedNonTemporal(T* source) + where T : unmanaged => LoadAligned(source); + + /// Loads a vector from the given source. + /// The type of the elements in the vector. + /// The source from which the vector will be loaded. + /// The vector loaded from . + /// The type of () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 LoadUnsafe(ref T source) + where T : struct + { + ThrowHelper.ThrowForUnsupportedIntrinsicsVector512BaseType(); + ref byte address = ref Unsafe.As(ref source); + return Unsafe.ReadUnaligned>(ref address); + } + + /// Loads a vector from the given source and element offset. + /// The type of the elements in the vector. + /// The source to which will be added before loading the vector. + /// The element offset from from which the vector will be loaded. + /// The vector loaded from plus . + /// The type of () is not supported. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 LoadUnsafe(ref T source, nuint elementOffset) + where T : struct + { + ThrowHelper.ThrowForUnsupportedIntrinsicsVector512BaseType(); + source = ref Unsafe.Add(ref source, (nint)elementOffset); + return Unsafe.ReadUnaligned>(ref Unsafe.As(ref source)); + } + + /// Computes the maximum of two vectors on a per-element basis. + /// The type of the elements in the vector. + /// The vector to compare with . + /// The vector to compare with . + /// A vector whose elements are the maximum of the corresponding elements in and . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Max(Vector512 left, Vector512 right) + where T : struct + { + return Create( + Vector256.Max(left._lower, right._lower), + Vector256.Max(left._upper, right._upper) + ); + } + + /// Computes the minimum of two vectors on a per-element basis. + /// The type of the elements in the vector. + /// The vector to compare with . + /// The vector to compare with . + /// A vector whose elements are the minimum of the corresponding elements in and . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Min(Vector512 left, Vector512 right) + where T : struct + { + return Create( + Vector256.Min(left._lower, right._lower), + Vector256.Min(left._upper, right._upper) + ); + } + + /// Multiplies two vectors to compute their element-wise product. + /// The type of the elements in the vector. + /// The vector to multiply with . + /// The vector to multiply with . + /// The element-wise product of and . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Multiply(Vector512 left, Vector512 right) + where T : struct => left * right; + + /// Multiplies a vector by a scalar to compute their product. + /// The type of the elements in the vector. + /// The vector to multiply with . + /// The scalar to multiply with . + /// The product of and . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Multiply(Vector512 left, T right) + where T : struct => left * right; + + /// Multiplies a vector by a scalar to compute their product. + /// The type of the elements in the vector. + /// The scalar to multiply with . + /// The vector to multiply with . + /// The product of and . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Multiply(T left, Vector512 right) + where T : struct => left * right; + + /// Narrows two instances into one . + /// The vector that will be narrowed to the lower half of the result vector. + /// The vector that will be narrowed to the upper half of the result vector. + /// A containing elements narrowed from and . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Narrow(Vector512 lower, Vector512 upper) + { + return Create( + Vector256.Narrow(lower._lower, lower._upper), + Vector256.Narrow(upper._lower, upper._upper) + ); + } + + /// Narrows two instances into one . + /// The vector that will be narrowed to the lower half of the result vector. + /// The vector that will be narrowed to the upper half of the result vector. + /// A containing elements narrowed from and . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Narrow(Vector512 lower, Vector512 upper) + { + return Create( + Vector256.Narrow(lower._lower, lower._upper), + Vector256.Narrow(upper._lower, upper._upper) + ); + } + + /// Narrows two instances into one . + /// The vector that will be narrowed to the lower half of the result vector. + /// The vector that will be narrowed to the upper half of the result vector. + /// A containing elements narrowed from and . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Narrow(Vector512 lower, Vector512 upper) + { + return Create( + Vector256.Narrow(lower._lower, lower._upper), + Vector256.Narrow(upper._lower, upper._upper) + ); + } + + /// Narrows two instances into one . + /// The vector that will be narrowed to the lower half of the result vector. + /// The vector that will be narrowed to the upper half of the result vector. + /// A containing elements narrowed from and . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Narrow(Vector512 lower, Vector512 upper) + { + return Create( + Vector256.Narrow(lower._lower, lower._upper), + Vector256.Narrow(upper._lower, upper._upper) + ); + } + + /// Narrows two instances into one . + /// The vector that will be narrowed to the lower half of the result vector. + /// The vector that will be narrowed to the upper half of the result vector. + /// A containing elements narrowed from and . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Narrow(Vector512 lower, Vector512 upper) + { + return Create( + Vector256.Narrow(lower._lower, lower._upper), + Vector256.Narrow(upper._lower, upper._upper) + ); + } + + /// Narrows two instances into one . + /// The vector that will be narrowed to the lower half of the result vector. + /// The vector that will be narrowed to the upper half of the result vector. + /// A containing elements narrowed from and . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Narrow(Vector512 lower, Vector512 upper) + { + return Create( + Vector256.Narrow(lower._lower, lower._upper), + Vector256.Narrow(upper._lower, upper._upper) + ); + } + + /// Narrows two instances into one . + /// The vector that will be narrowed to the lower half of the result vector. + /// The vector that will be narrowed to the upper half of the result vector. + /// A containing elements narrowed from and . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Narrow(Vector512 lower, Vector512 upper) + { + return Create( + Vector256.Narrow(lower._lower, lower._upper), + Vector256.Narrow(upper._lower, upper._upper) + ); + } + + /// Negates a vector. + /// The type of the elements in the vector. + /// The vector to negate. + /// A vector whose elements are the negation of the corresponding elements in . + /// The type of () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Negate(Vector512 vector) + where T : struct => -vector; + + /// Computes the ones-complement of a vector. + /// The type of the elements in the vector. + /// The vector whose ones-complement is to be computed. + /// A vector whose elements are the ones-complement of the corresponding elements in . + /// The type of () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 OnesComplement(Vector512 vector) + where T : struct + { + return Create( + Vector256.OnesComplement(vector._lower), + Vector256.OnesComplement(vector._upper) + ); + } + + /// Shifts each element of a vector left by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted left by . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftLeft(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftLeft(vector._lower, shiftCount), + Vector256.ShiftLeft(vector._upper, shiftCount) + ); + } + + /// Shifts each element of a vector left by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted left by . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftLeft(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftLeft(vector._lower, shiftCount), + Vector256.ShiftLeft(vector._upper, shiftCount) + ); + } + + /// Shifts each element of a vector left by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted left by . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftLeft(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftLeft(vector._lower, shiftCount), + Vector256.ShiftLeft(vector._upper, shiftCount) + ); + } + + /// Shifts each element of a vector left by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted left by . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftLeft(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftLeft(vector._lower, shiftCount), + Vector256.ShiftLeft(vector._upper, shiftCount) + ); + } + + /// Shifts each element of a vector left by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted left by . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftLeft(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftLeft(vector._lower, shiftCount), + Vector256.ShiftLeft(vector._upper, shiftCount) + ); + } + + /// Shifts each element of a vector left by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted left by . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftLeft(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftLeft(vector._lower, shiftCount), + Vector256.ShiftLeft(vector._upper, shiftCount) + ); + } + + /// Shifts each element of a vector left by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted left by . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftLeft(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftLeft(vector._lower, shiftCount), + Vector256.ShiftLeft(vector._upper, shiftCount) + ); + } + + /// Shifts each element of a vector left by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted left by . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftLeft(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftLeft(vector._lower, shiftCount), + Vector256.ShiftLeft(vector._upper, shiftCount) + ); + } + + /// Shifts each element of a vector left by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted left by . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftLeft(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftLeft(vector._lower, shiftCount), + Vector256.ShiftLeft(vector._upper, shiftCount) + ); + } + + /// Shifts each element of a vector left by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted left by . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftLeft(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftLeft(vector._lower, shiftCount), + Vector256.ShiftLeft(vector._upper, shiftCount) + ); + } + + /// Shifts (signed) each element of a vector right by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted right by . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftRightArithmetic(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftRightArithmetic(vector._lower, shiftCount), + Vector256.ShiftRightArithmetic(vector._upper, shiftCount) + ); + } + + /// Shifts (signed) each element of a vector right by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted right by . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftRightArithmetic(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftRightArithmetic(vector._lower, shiftCount), + Vector256.ShiftRightArithmetic(vector._upper, shiftCount) + ); + } + + /// Shifts (signed) each element of a vector right by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted right by . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftRightArithmetic(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftRightArithmetic(vector._lower, shiftCount), + Vector256.ShiftRightArithmetic(vector._upper, shiftCount) + ); + } + + /// Shifts (signed) each element of a vector right by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted right by . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftRightArithmetic(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftRightArithmetic(vector._lower, shiftCount), + Vector256.ShiftRightArithmetic(vector._upper, shiftCount) + ); + } + + /// Shifts (signed) each element of a vector right by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted right by . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftRightArithmetic(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftRightArithmetic(vector._lower, shiftCount), + Vector256.ShiftRightArithmetic(vector._upper, shiftCount) + ); + } + + /// Shifts (unsigned) each element of a vector right by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted right by . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftRightLogical(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftRightLogical(vector._lower, shiftCount), + Vector256.ShiftRightLogical(vector._upper, shiftCount) + ); + } + + /// Shifts (unsigned) each element of a vector right by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted right by . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftRightLogical(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftRightLogical(vector._lower, shiftCount), + Vector256.ShiftRightLogical(vector._upper, shiftCount) + ); + } + + /// Shifts (unsigned) each element of a vector right by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted right by . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftRightLogical(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftRightLogical(vector._lower, shiftCount), + Vector256.ShiftRightLogical(vector._upper, shiftCount) + ); + } + + /// Shifts (unsigned) each element of a vector right by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted right by . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftRightLogical(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftRightLogical(vector._lower, shiftCount), + Vector256.ShiftRightLogical(vector._upper, shiftCount) + ); + } + + /// Shifts (unsigned) each element of a vector right by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted right by . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftRightLogical(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftRightLogical(vector._lower, shiftCount), + Vector256.ShiftRightLogical(vector._upper, shiftCount) + ); + } + + /// Shifts (unsigned) each element of a vector right by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted right by . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftRightLogical(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftRightLogical(vector._lower, shiftCount), + Vector256.ShiftRightLogical(vector._upper, shiftCount) + ); + } + + /// Shifts (unsigned) each element of a vector right by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted right by . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftRightLogical(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftRightLogical(vector._lower, shiftCount), + Vector256.ShiftRightLogical(vector._upper, shiftCount) + ); + } + + /// Shifts (unsigned) each element of a vector right by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted right by . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftRightLogical(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftRightLogical(vector._lower, shiftCount), + Vector256.ShiftRightLogical(vector._upper, shiftCount) + ); + } + + /// Shifts (unsigned) each element of a vector right by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted right by . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftRightLogical(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftRightLogical(vector._lower, shiftCount), + Vector256.ShiftRightLogical(vector._upper, shiftCount) + ); + } + + /// Shifts (unsigned) each element of a vector right by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted right by . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 ShiftRightLogical(Vector512 vector, int shiftCount) + { + return Create( + Vector256.ShiftRightLogical(vector._lower, shiftCount), + Vector256.ShiftRightLogical(vector._upper, shiftCount) + ); + } + + /// Creates a new vector by selecting values from an input vector using a set of indices. + /// The input vector from which values are selected. + /// The per-element indices used to select a value from . + /// A new vector containing the values from selected by the given . + [Intrinsic] + public static Vector512 Shuffle(Vector512 vector, Vector512 indices) + { + Unsafe.SkipInit(out Vector512 result); + + for (int index = 0; index < Vector512.Count; index++) + { + byte selectedIndex = indices.GetElementUnsafe(index); + byte selectedValue = 0; + + if (selectedIndex < Vector512.Count) + { + selectedValue = vector.GetElementUnsafe(selectedIndex); + } + result.SetElementUnsafe(index, selectedValue); + } + + return result; + } + + /// Creates a new vector by selecting values from an input vector using a set of indices. + /// The input vector from which values are selected. + /// The per-element indices used to select a value from . + /// A new vector containing the values from selected by the given . + [Intrinsic] + [CLSCompliant(false)] + public static Vector512 Shuffle(Vector512 vector, Vector512 indices) + { + Unsafe.SkipInit(out Vector512 result); + + for (int index = 0; index < Vector512.Count; index++) + { + byte selectedIndex = (byte)indices.GetElementUnsafe(index); + sbyte selectedValue = 0; + + if (selectedIndex < Vector512.Count) + { + selectedValue = vector.GetElementUnsafe(selectedIndex); + } + result.SetElementUnsafe(index, selectedValue); + } + + return result; + } + + /// Creates a new vector by selecting values from an input vector using a set of indices. + /// The input vector from which values are selected. + /// The per-element indices used to select a value from . + /// A new vector containing the values from selected by the given . + [Intrinsic] + public static Vector512 Shuffle(Vector512 vector, Vector512 indices) + { + Unsafe.SkipInit(out Vector512 result); + + for (int index = 0; index < Vector512.Count; index++) + { + ushort selectedIndex = (ushort)indices.GetElementUnsafe(index); + short selectedValue = 0; + + if (selectedIndex < Vector512.Count) + { + selectedValue = vector.GetElementUnsafe(selectedIndex); + } + result.SetElementUnsafe(index, selectedValue); + } + + return result; + } + + /// Creates a new vector by selecting values from an input vector using a set of indices. + /// The input vector from which values are selected. + /// The per-element indices used to select a value from . + /// A new vector containing the values from selected by the given . + [Intrinsic] + [CLSCompliant(false)] + public static Vector512 Shuffle(Vector512 vector, Vector512 indices) + { + Unsafe.SkipInit(out Vector512 result); + + for (int index = 0; index < Vector512.Count; index++) + { + ushort selectedIndex = indices.GetElementUnsafe(index); + ushort selectedValue = 0; + + if (selectedIndex < Vector512.Count) + { + selectedValue = vector.GetElementUnsafe(selectedIndex); + } + result.SetElementUnsafe(index, selectedValue); + } + + return result; + } + + /// Creates a new vector by selecting values from an input vector using a set of indices. + /// The input vector from which values are selected. + /// The per-element indices used to select a value from . + /// A new vector containing the values from selected by the given . + [Intrinsic] + public static Vector512 Shuffle(Vector512 vector, Vector512 indices) + { + Unsafe.SkipInit(out Vector512 result); + + for (int index = 0; index < Vector512.Count; index++) + { + uint selectedIndex = (uint)indices.GetElementUnsafe(index); + int selectedValue = 0; + + if (selectedIndex < Vector512.Count) + { + selectedValue = vector.GetElementUnsafe((int)selectedIndex); + } + result.SetElementUnsafe(index, selectedValue); + } + + return result; + } + + /// Creates a new vector by selecting values from an input vector using a set of indices. + /// The input vector from which values are selected. + /// The per-element indices used to select a value from . + /// A new vector containing the values from selected by the given . + [Intrinsic] + [CLSCompliant(false)] + public static Vector512 Shuffle(Vector512 vector, Vector512 indices) + { + Unsafe.SkipInit(out Vector512 result); + + for (int index = 0; index < Vector512.Count; index++) + { + uint selectedIndex = indices.GetElementUnsafe(index); + uint selectedValue = 0; + + if (selectedIndex < Vector512.Count) + { + selectedValue = vector.GetElementUnsafe((int)selectedIndex); + } + result.SetElementUnsafe(index, selectedValue); + } + + return result; + } + + /// Creates a new vector by selecting values from an input vector using a set of indices. + /// The input vector from which values are selected. + /// The per-element indices used to select a value from . + /// A new vector containing the values from selected by the given . + [Intrinsic] + public static Vector512 Shuffle(Vector512 vector, Vector512 indices) + { + Unsafe.SkipInit(out Vector512 result); + + for (int index = 0; index < Vector512.Count; index++) + { + uint selectedIndex = (uint)indices.GetElementUnsafe(index); + float selectedValue = 0; + + if (selectedIndex < Vector512.Count) + { + selectedValue = vector.GetElementUnsafe((int)selectedIndex); + } + result.SetElementUnsafe(index, selectedValue); + } + + return result; + } + + /// Creates a new vector by selecting values from an input vector using a set of indices. + /// The input vector from which values are selected. + /// The per-element indices used to select a value from . + /// A new vector containing the values from selected by the given . + [Intrinsic] + public static Vector512 Shuffle(Vector512 vector, Vector512 indices) + { + Unsafe.SkipInit(out Vector512 result); + + for (int index = 0; index < Vector512.Count; index++) + { + ulong selectedIndex = (ulong)indices.GetElementUnsafe(index); + long selectedValue = 0; + + if (selectedIndex < (uint)Vector512.Count) + { + selectedValue = vector.GetElementUnsafe((int)selectedIndex); + } + result.SetElementUnsafe(index, selectedValue); + } + + return result; + } + + /// Creates a new vector by selecting values from an input vector using a set of indices. + /// The input vector from which values are selected. + /// The per-element indices used to select a value from . + /// A new vector containing the values from selected by the given . + [Intrinsic] + [CLSCompliant(false)] + public static Vector512 Shuffle(Vector512 vector, Vector512 indices) + { + Unsafe.SkipInit(out Vector512 result); + + for (int index = 0; index < Vector512.Count; index++) + { + ulong selectedIndex = indices.GetElementUnsafe(index); + ulong selectedValue = 0; + + if (selectedIndex < (uint)Vector512.Count) + { + selectedValue = vector.GetElementUnsafe((int)selectedIndex); + } + result.SetElementUnsafe(index, selectedValue); + } + + return result; + } + + /// Creates a new vector by selecting values from an input vector using a set of indices. + /// The input vector from which values are selected. + /// The per-element indices used to select a value from . + /// A new vector containing the values from selected by the given . + [Intrinsic] + public static Vector512 Shuffle(Vector512 vector, Vector512 indices) + { + Unsafe.SkipInit(out Vector512 result); + + for (int index = 0; index < Vector512.Count; index++) + { + ulong selectedIndex = (ulong)indices.GetElementUnsafe(index); + double selectedValue = 0; + + if (selectedIndex < (uint)Vector512.Count) + { + selectedValue = vector.GetElementUnsafe((int)selectedIndex); + } + result.SetElementUnsafe(index, selectedValue); + } + + return result; + } + + /// Computes the square root of a vector on a per-element basis. + /// The type of the elements in the vector. + /// The vector whose square root is to be computed. + /// A vector whose elements are the square root of the corresponding elements in . + /// The type of () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Sqrt(Vector512 vector) + where T : struct + { + return Create( + Vector256.Sqrt(vector._lower), + Vector256.Sqrt(vector._upper) + ); + } + + /// Stores a vector at the given destination. + /// The type of the elements in the vector. + /// The vector that will be stored. + /// The destination at which will be stored. + /// The type of and () is not supported. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void Store(this Vector512 source, T* destination) + where T : unmanaged => source.StoreUnsafe(ref *destination); + + /// Stores a vector at the given aligned destination. + /// The type of the elements in the vector. + /// The vector that will be stored. + /// The aligned destination at which will be stored. + /// The type of and () is not supported. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void StoreAligned(this Vector512 source, T* destination) + where T : unmanaged + { + ThrowHelper.ThrowForUnsupportedIntrinsicsVector512BaseType(); + + if (((nuint)(destination) % Alignment) != 0) + { + ThrowHelper.ThrowAccessViolationException(); + } + + *(Vector512*)(destination) = source; + } + + /// Stores a vector at the given aligned destination. + /// The type of the elements in the vector. + /// The vector that will be stored. + /// The aligned destination at which will be stored. + /// The type of and () is not supported. + /// This method may bypass the cache on certain platforms. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void StoreAlignedNonTemporal(this Vector512 source, T* destination) + where T : unmanaged => source.StoreAligned(destination); + + /// Stores a vector at the given destination. + /// The type of the elements in the vector. + /// The vector that will be stored. + /// The destination at which will be stored. + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void StoreUnsafe(this Vector512 source, ref T destination) + where T : struct + { + ThrowHelper.ThrowForUnsupportedIntrinsicsVector512BaseType(); + ref byte address = ref Unsafe.As(ref destination); + Unsafe.WriteUnaligned(ref address, source); + } + + /// Stores a vector at the given destination. + /// The type of the elements in the vector. + /// The vector that will be stored. + /// The destination to which will be added before the vector will be stored. + /// The element offset from from which the vector will be stored. + /// The type of and () is not supported. + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void StoreUnsafe(this Vector512 source, ref T destination, nuint elementOffset) + where T : struct + { + ThrowHelper.ThrowForUnsupportedIntrinsicsVector512BaseType(); + destination = ref Unsafe.Add(ref destination, (nint)elementOffset); + Unsafe.WriteUnaligned(ref Unsafe.As(ref destination), source); + } + + /// Subtracts two vectors to compute their difference. + /// The vector from which will be subtracted. + /// The vector to subtract from . + /// The type of the elements in the vector. + /// The difference of and . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Subtract(Vector512 left, Vector512 right) + where T : struct => left - right; + + /// Computes the sum of all elements in a vector. + /// The vector whose elements will be summed. + /// The type of the elements in the vector. + /// The sum of all elements in . + /// The type of () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static T Sum(Vector512 vector) + where T : struct + { + // Doing this as Sum(lower) + Sum(upper) is important for floating-point determinism + // This is because the underlying dpps instruction on x86/x64 will do this equivalently + // and otherwise the software vs accelerated implementations may differ in returned result. + + T result = Vector256.Sum(vector._lower); + result = Scalar.Add(result, Vector256.Sum(vector._upper)); + return result; + } + + /// Converts the given vector to a scalar containing the value of the first element. + /// The type of the input vector. + /// The vector to get the first element from. + /// A scalar containing the value of the first element. + /// The type of () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static T ToScalar(this Vector512 vector) + where T : struct + { + ThrowHelper.ThrowForUnsupportedIntrinsicsVector512BaseType(); + return vector.GetElementUnsafe(0); + } + + /// Tries to copy a to a given span. + /// The type of the input vector. + /// The vector to copy. + /// The span to which is copied. + /// true if was successfully copied to ; otherwise, false if the length of is less than . + /// The type of and () is not supported. + public static bool TryCopyTo(this Vector512 vector, Span destination) + where T : struct + { + if ((uint)destination.Length < (uint)Vector512.Count) + { + return false; + } + + ref byte address = ref Unsafe.As(ref MemoryMarshal.GetReference(destination)); + Unsafe.WriteUnaligned(ref address, vector); + return true; + } + + /// Widens a into two . + /// The vector whose elements are to be widened. + /// A pair of vectors that contain the widened lower and upper halves of . + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static (Vector512 Lower, Vector512 Upper) Widen(Vector512 source) => (WidenLower(source), WidenUpper(source)); + + /// Widens a into two . + /// The vector whose elements are to be widened. + /// A pair of vectors that contain the widened lower and upper halves of . + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static (Vector512 Lower, Vector512 Upper) Widen(Vector512 source) => (WidenLower(source), WidenUpper(source)); + + /// Widens a into two . + /// The vector whose elements are to be widened. + /// A pair of vectors that contain the widened lower and upper halves of . + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static (Vector512 Lower, Vector512 Upper) Widen(Vector512 source) => (WidenLower(source), WidenUpper(source)); + + /// Widens a into two . + /// The vector whose elements are to be widened. + /// A pair of vectors that contain the widened lower and upper halves of . + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static (Vector512 Lower, Vector512 Upper) Widen(Vector512 source) => (WidenLower(source), WidenUpper(source)); + + /// Widens a into two . + /// The vector whose elements are to be widened. + /// A pair of vectors that contain the widened lower and upper halves of . + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static (Vector512 Lower, Vector512 Upper) Widen(Vector512 source) => (WidenLower(source), WidenUpper(source)); + + /// Widens a into two . + /// The vector whose elements are to be widened. + /// A pair of vectors that contain the widened lower and upper halves of . + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static (Vector512 Lower, Vector512 Upper) Widen(Vector512 source) => (WidenLower(source), WidenUpper(source)); + + /// Widens a into two . + /// The vector whose elements are to be widened. + /// A pair of vectors that contain the widened lower and upper halves of . + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static (Vector512 Lower, Vector512 Upper) Widen(Vector512 source) => (WidenLower(source), WidenUpper(source)); + + /// Widens the lower half of a into a . + /// The vector whose elements are to be widened. + /// A vector that contain the widened lower half of . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 WidenLower(Vector512 source) + { + Vector256 lower = source._lower; + + return Create( + Vector256.WidenLower(lower), + Vector256.WidenUpper(lower) + ); + } + + /// Widens the lower half of a into a . + /// The vector whose elements are to be widened. + /// A vector that contain the widened lower half of . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 WidenLower(Vector512 source) + { + Vector256 lower = source._lower; + + return Create( + Vector256.WidenLower(lower), + Vector256.WidenUpper(lower) + ); + } + + /// Widens the lower half of a into a . + /// The vector whose elements are to be widened. + /// A vector that contain the widened lower half of . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 WidenLower(Vector512 source) + { + Vector256 lower = source._lower; + + return Create( + Vector256.WidenLower(lower), + Vector256.WidenUpper(lower) + ); + } + + /// Widens the lower half of a into a . + /// The vector whose elements are to be widened. + /// A vector that contain the widened lower half of . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 WidenLower(Vector512 source) + { + Vector256 lower = source._lower; + + return Create( + Vector256.WidenLower(lower), + Vector256.WidenUpper(lower) + ); + } + /// Widens the lower half of a into a . + /// The vector whose elements are to be widened. + /// A vector that contain the widened lower half of . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 WidenLower(Vector512 source) + { + Vector256 lower = source._lower; + + return Create( + Vector256.WidenLower(lower), + Vector256.WidenUpper(lower) + ); + } + + /// Widens the lower half of a into a . + /// The vector whose elements are to be widened. + /// A vector that contain the widened lower half of . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 WidenLower(Vector512 source) + { + Vector256 lower = source._lower; + + return Create( + Vector256.WidenLower(lower), + Vector256.WidenUpper(lower) + ); + } + + /// Widens the lower half of a into a . + /// The vector whose elements are to be widened. + /// A vector that contain the widened lower half of . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 WidenLower(Vector512 source) + { + Vector256 lower = source._lower; + + return Create( + Vector256.WidenLower(lower), + Vector256.WidenUpper(lower) + ); + } + + /// Widens the upper half of a into a . + /// The vector whose elements are to be widened. + /// A vector that contain the widened upper half of . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 WidenUpper(Vector512 source) + { + Vector256 upper = source._upper; + + return Create( + Vector256.WidenLower(upper), + Vector256.WidenUpper(upper) + ); + } + + /// Widens the upper half of a into a . + /// The vector whose elements are to be widened. + /// A vector that contain the widened upper half of . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 WidenUpper(Vector512 source) + { + Vector256 upper = source._upper; + + return Create( + Vector256.WidenLower(upper), + Vector256.WidenUpper(upper) + ); + } + + /// Widens the upper half of a into a . + /// The vector whose elements are to be widened. + /// A vector that contain the widened upper half of . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 WidenUpper(Vector512 source) + { + Vector256 upper = source._upper; + + return Create( + Vector256.WidenLower(upper), + Vector256.WidenUpper(upper) + ); + } + + /// Widens the upper half of a into a . + /// The vector whose elements are to be widened. + /// A vector that contain the widened upper half of . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 WidenUpper(Vector512 source) + { + Vector256 upper = source._upper; + + return Create( + Vector256.WidenLower(upper), + Vector256.WidenUpper(upper) + ); + } + + /// Widens the upper half of a into a . + /// The vector whose elements are to be widened. + /// A vector that contain the widened upper half of . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 WidenUpper(Vector512 source) + { + Vector256 upper = source._upper; + + return Create( + Vector256.WidenLower(upper), + Vector256.WidenUpper(upper) + ); + } + + /// Widens the upper half of a into a . + /// The vector whose elements are to be widened. + /// A vector that contain the widened upper half of . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 WidenUpper(Vector512 source) + { + Vector256 upper = source._upper; + + return Create( + Vector256.WidenLower(upper), + Vector256.WidenUpper(upper) + ); + } + + /// Widens the upper half of a into a . + /// The vector whose elements are to be widened. + /// A vector that contain the widened upper half of . + [Intrinsic] + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 WidenUpper(Vector512 source) + { + Vector256 upper = source._upper; + + return Create( + Vector256.WidenLower(upper), + Vector256.WidenUpper(upper) + ); + } + + /// Creates a new with the element at the specified index set to the specified value and the remaining elements set to the same value as that in the given vector. + /// The type of the input vector. + /// The vector to get the remaining elements from. + /// The index of the element to set. + /// The value to set the element to. + /// A with the value of the element at set to and the remaining elements set to the same value as that in . + /// was less than zero or greater than the number of elements. + /// The type of () is not supported. + [Intrinsic] + public static Vector512 WithElement(this Vector512 vector, int index, T value) + where T : struct + { + if ((uint)(index) >= (uint)(Vector512.Count)) + { + ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index); + } + + Vector512 result = vector; + result.SetElementUnsafe(index, value); + return result; + } + + /// Creates a new with the lower 256-bits set to the specified value and the upper 256-bits set to the same value as that in the given vector. + /// The type of the input vector. + /// The vector to get the upper 256-bits from. + /// The value of the lower 256-bits as a . + /// A new with the lower 256-bits set to and the upper 256-bits set to the same value as that in . + /// The type of () is not supported. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 WithLower(this Vector512 vector, Vector256 value) + where T : struct + { + ThrowHelper.ThrowForUnsupportedIntrinsicsVector512BaseType(); + + Vector512 result = vector; + result.SetLowerUnsafe(value); + return result; + } + + /// Creates a new with the upper 256-bits set to the specified value and the upper 256-bits set to the same value as that in the given vector. + /// The type of the input vector. + /// The vector to get the lower 256-bits from. + /// The value of the upper 256-bits as a . + /// A new with the upper 256-bits set to and the lower 256-bits set to the same value as that in . + /// The type of () is not supported. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 WithUpper(this Vector512 vector, Vector256 value) + where T : struct + { + ThrowHelper.ThrowForUnsupportedIntrinsicsVector512BaseType(); + + Vector512 result = vector; + result.SetUpperUnsafe(value); + return result; + } + + /// Computes the exclusive-or of two vectors. + /// The type of the elements in the vector. + /// The vector to exclusive-or with . + /// The vector to exclusive-or with . + /// The exclusive-or of and . + /// The type of and () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 Xor(Vector512 left, Vector512 right) + where T : struct => left ^ right; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static T GetElementUnsafe(in this Vector512 vector, int index) + where T : struct + { + Debug.Assert((index >= 0) && (index < Vector512.Count)); + ref T address = ref Unsafe.As, T>(ref Unsafe.AsRef(in vector)); + return Unsafe.Add(ref address, index); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void SetElementUnsafe(in this Vector512 vector, int index, T value) + where T : struct + { + Debug.Assert((index >= 0) && (index < Vector512.Count)); + ref T address = ref Unsafe.As, T>(ref Unsafe.AsRef(in vector)); + Unsafe.Add(ref address, index) = value; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void SetLowerUnsafe(in this Vector512 vector, Vector256 value) + where T : struct + { + Unsafe.AsRef(in vector._lower) = value; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void SetUpperUnsafe(in this Vector512 vector, Vector256 value) + where T : struct + { + Unsafe.AsRef(in vector._upper) = value; + } + } +} diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512DebugView_1.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512DebugView_1.cs new file mode 100644 index 0000000000000..61e3cef69d88e --- /dev/null +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512DebugView_1.cs @@ -0,0 +1,138 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Runtime.CompilerServices; + +namespace System.Runtime.Intrinsics +{ + internal readonly struct Vector512DebugView + where T : struct + { + private readonly Vector512 _value; + + public Vector512DebugView(Vector512 value) + { + _value = value; + } + + public byte[] ByteView + { + get + { + var items = new byte[Vector512.Count]; + Unsafe.WriteUnaligned(ref items[0], _value); + return items; + } + } + + public double[] DoubleView + { + get + { + var items = new double[Vector512.Count]; + Unsafe.WriteUnaligned(ref Unsafe.As(ref items[0]), _value); + return items; + } + } + + public short[] Int16View + { + get + { + var items = new short[Vector512.Count]; + Unsafe.WriteUnaligned(ref Unsafe.As(ref items[0]), _value); + return items; + } + } + + public int[] Int32View + { + get + { + var items = new int[Vector512.Count]; + Unsafe.WriteUnaligned(ref Unsafe.As(ref items[0]), _value); + return items; + } + } + + public long[] Int64View + { + get + { + var items = new long[Vector512.Count]; + Unsafe.WriteUnaligned(ref Unsafe.As(ref items[0]), _value); + return items; + } + } + + public nint[] NIntView + { + get + { + var items = new nint[Vector512.Count]; + Unsafe.WriteUnaligned(ref Unsafe.As(ref items[0]), _value); + return items; + } + } + + public nuint[] NUIntView + { + get + { + var items = new nuint[Vector512.Count]; + Unsafe.WriteUnaligned(ref Unsafe.As(ref items[0]), _value); + return items; + } + } + + public sbyte[] SByteView + { + get + { + var items = new sbyte[Vector512.Count]; + Unsafe.WriteUnaligned(ref Unsafe.As(ref items[0]), _value); + return items; + } + } + + public float[] SingleView + { + get + { + var items = new float[Vector512.Count]; + Unsafe.WriteUnaligned(ref Unsafe.As(ref items[0]), _value); + return items; + } + } + + public ushort[] UInt16View + { + get + { + var items = new ushort[Vector512.Count]; + Unsafe.WriteUnaligned(ref Unsafe.As(ref items[0]), _value); + return items; + } + } + + public uint[] UInt32View + { + get + { + var items = new uint[Vector512.Count]; + Unsafe.WriteUnaligned(ref Unsafe.As(ref items[0]), _value); + return items; + } + } + + public ulong[] UInt64View + { + get + { + var items = new ulong[Vector512.Count]; + Unsafe.WriteUnaligned(ref Unsafe.As(ref items[0]), _value); + return items; + } + } + } +} diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512_1.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512_1.cs new file mode 100644 index 0000000000000..1edf3894f63d9 --- /dev/null +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512_1.cs @@ -0,0 +1,460 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Globalization; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Text; + +namespace System.Runtime.Intrinsics +{ + // We mark certain methods with AggressiveInlining to ensure that the JIT will + // inline them. The JIT would otherwise not inline the method since it, at the + // point it tries to determine inline profability, currently cannot determine + // that most of the code-paths will be optimized away as "dead code". + // + // We then manually inline cases (such as certain intrinsic code-paths) that + // will generate code small enough to make the AgressiveInlining profitable. The + // other cases (such as the software fallback) are placed in their own method. + // This ensures we get good codegen for the "fast-path" and allows the JIT to + // determine inline profitability of the other paths as it would normally. + + /// Represents a 512-bit vector of a specified numeric type that is suitable for low-level optimization of parallel algorithms. + /// The type of the elements in the vector. + [Intrinsic] + [DebuggerDisplay("{DisplayString,nq}")] + [DebuggerTypeProxy(typeof(Vector512DebugView<>))] + [StructLayout(LayoutKind.Sequential, Size = Vector512.Size)] + public readonly struct Vector512 : IEquatable> + where T : struct + { + internal readonly Vector256 _lower; + internal readonly Vector256 _upper; + + /// Gets a new with all bits set to 1. + /// The type of the vector () is not supported. + public static Vector512 AllBitsSet + { + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + Vector256 vector = Vector256.AllBitsSet; + return Vector512.Create(vector, vector); + } + } + + /// Gets the number of that are in a . + /// The type of the vector () is not supported. + public static int Count + { + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + return Vector256.Count * 2; + } + } + + /// Gets true if is supported; otherwise, false. + /// true if is supported; otherwise, false. + public static bool IsSupported + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + return (typeof(T) == typeof(byte)) + || (typeof(T) == typeof(double)) + || (typeof(T) == typeof(short)) + || (typeof(T) == typeof(int)) + || (typeof(T) == typeof(long)) + || (typeof(T) == typeof(nint)) + || (typeof(T) == typeof(sbyte)) + || (typeof(T) == typeof(float)) + || (typeof(T) == typeof(ushort)) + || (typeof(T) == typeof(uint)) + || (typeof(T) == typeof(ulong)) + || (typeof(T) == typeof(nuint)); + } + } + + /// Gets a new with all elements initialized to one. + /// The type of the current instance () is not supported. + public static Vector512 One + { + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + Vector256 vector = Vector256.One; + return Vector512.Create(vector, vector); + } + } + + /// Gets a new with all elements initialized to zero. + /// The type of the vector () is not supported. + public static Vector512 Zero + { + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ThrowHelper.ThrowForUnsupportedIntrinsicsVector512BaseType(); + return default; + } + } + + internal string DisplayString + { + get + { + return IsSupported ? ToString() : SR.NotSupported_Type; + } + } + + /// Gets the element at the specified index. + /// The index of the element to get. + /// The value of the element at . + /// was less than zero or greater than the number of elements. + /// The type of the vector () is not supported. + public T this[int index] + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + return this.GetElement(index); + } + } + + /// Adds two vectors to compute their sum. + /// The vector to add with . + /// The vector to add with . + /// The sum of and . + /// The type of the vector () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 operator +(Vector512 left, Vector512 right) + { + return Vector512.Create( + left._lower + right._lower, + left._upper + right._upper + ); + } + + /// Computes the bitwise-and of two vectors. + /// The vector to bitwise-and with . + /// The vector to bitwise-and with . + /// The bitwise-and of and . + /// The type of the vector () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 operator &(Vector512 left, Vector512 right) + { + return Vector512.Create( + left._lower & right._lower, + left._upper & right._upper + ); + } + + /// Computes the bitwise-or of two vectors. + /// The vector to bitwise-or with . + /// The vector to bitwise-or with . + /// The bitwise-or of and . + /// The type of the vector () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 operator |(Vector512 left, Vector512 right) + { + return Vector512.Create( + left._lower | right._lower, + left._upper | right._upper + ); + } + + /// Divides two vectors to compute their quotient. + /// The vector that will be divided by . + /// The vector that will divide . + /// The quotient of divided by . + /// The type of the vector () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 operator /(Vector512 left, Vector512 right) + { + return Vector512.Create( + left._lower / right._lower, + left._upper / right._upper + ); + } + + /// Divides a vector by a scalar to compute the per-element quotient. + /// The vector that will be divided by . + /// The scalar that will divide . + /// The quotient of divided by . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 operator /(Vector512 left, T right) + { + return Vector512.Create( + left._lower / right, + left._upper / right + ); + } + + /// Compares two vectors to determine if all elements are equal. + /// The vector to compare with . + /// The vector to compare with . + /// true if all elements in were equal to the corresponding element in . + /// The type of the vector () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool operator ==(Vector512 left, Vector512 right) + { + return (left._lower == right._lower) + && (left._upper == right._upper); + } + + /// Computes the exclusive-or of two vectors. + /// The vector to exclusive-or with . + /// The vector to exclusive-or with . + /// The exclusive-or of and . + /// The type of the vector () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 operator ^(Vector512 left, Vector512 right) + { + return Vector512.Create( + left._lower ^ right._lower, + left._upper ^ right._upper + ); + } + + /// Compares two vectors to determine if any elements are not equal. + /// The vector to compare with . + /// The vector to compare with . + /// true if any elements in was not equal to the corresponding element in . + /// The type of the vector () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool operator !=(Vector512 left, Vector512 right) + { + return (left._lower != right._lower) + || (left._upper != right._upper); + } + + /// Shifts each element of a vector left by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted left by . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 operator <<(Vector512 value, int shiftCount) + { + return Vector512.Create( + value._lower << shiftCount, + value._upper << shiftCount + ); + } + + /// Multiplies two vectors to compute their element-wise product. + /// The vector to multiply with . + /// The vector to multiply with . + /// The element-wise product of and . + /// The type of the vector () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 operator *(Vector512 left, Vector512 right) + { + return Vector512.Create( + left._lower * right._lower, + left._upper * right._upper + ); + } + + /// Multiplies a vector by a scalar to compute their product. + /// The vector to multiply with . + /// The scalar to multiply with . + /// The product of and . + /// The type of the vector () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 operator *(Vector512 left, T right) + { + return Vector512.Create( + left._lower * right, + left._upper * right + ); + } + + /// Multiplies a vector by a scalar to compute their product. + /// The scalar to multiply with . + /// The vector to multiply with . + /// The product of and . + /// The type of the vector () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 operator *(T left, Vector512 right) => right * left; + + /// Computes the ones-complement of a vector. + /// The vector whose ones-complement is to be computed. + /// A vector whose elements are the ones-complement of the corresponding elements in . + /// The type of the vector () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 operator ~(Vector512 vector) + { + return Vector512.Create( + ~vector._lower, + ~vector._upper + ); + } + + /// Shifts (signed) each element of a vector right by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted right by . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 operator >>(Vector512 value, int shiftCount) + { + return Vector512.Create( + value._lower >> shiftCount, + value._upper >> shiftCount + ); + } + + /// Subtracts two vectors to compute their difference. + /// The vector from which will be subtracted. + /// The vector to subtract from . + /// The difference of and . + /// The type of the vector () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 operator -(Vector512 left, Vector512 right) + { + return Vector512.Create( + left._lower - right._lower, + left._upper - right._upper + ); + } + + /// Computes the unary negation of a vector. + /// The vector to negate. + /// A vector whose elements are the unary negation of the corresponding elements in . + /// The type of the vector () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 operator -(Vector512 vector) + { + return Vector512.Create( + -vector._lower, + -vector._upper + ); + } + + /// Returns a given vector unchanged. + /// The vector. + /// + /// The type of the vector () is not supported. + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 operator +(Vector512 value) + { + ThrowHelper.ThrowForUnsupportedIntrinsicsVector512BaseType(); + return value; + } + + /// Shifts (unsigned) each element of a vector right by the specified amount. + /// The vector whose elements are to be shifted. + /// The number of bits by which to shift each element. + /// A vector whose elements where shifted right by . + [Intrinsic] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Vector512 operator >>>(Vector512 value, int shiftCount) + { + return Vector512.Create( + value._lower >>> shiftCount, + value._upper >>> shiftCount + ); + } + + /// Determines whether the specified object is equal to the current instance. + /// The object to compare with the current instance. + /// true if is a and is equal to the current instance; otherwise, false. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override bool Equals([NotNullWhen(true)] object? obj) => (obj is Vector512 other) && Equals(other); + + /// Determines whether the specified is equal to the current instance. + /// The to compare with the current instance. + /// true if is equal to the current instance; otherwise, false. + /// The type of the vector () is not supported. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(Vector512 other) + { + // This function needs to account for floating-point equality around NaN + // and so must behave equivalently to the underlying float/double.Equals + + if (Vector512.IsHardwareAccelerated) + { + if ((typeof(T) == typeof(double)) || (typeof(T) == typeof(float))) + { + Vector512 result = Vector512.Equals(this, other) | ~(Vector512.Equals(this, this) | Vector512.Equals(other, other)); + return result.AsInt32() == Vector512.AllBitsSet; + } + else + { + return this == other; + } + } + else + { + return _lower.Equals(other._lower) + && _upper.Equals(other._upper); + } + } + + /// Gets the hash code for the instance. + /// The hash code for the instance. + /// The type of the vector () is not supported. + public override int GetHashCode() + { + HashCode hashCode = default; + + for (int i = 0; i < Count; i++) + { + T value = this.GetElementUnsafe(i); + hashCode.Add(value); + } + + return hashCode.ToHashCode(); + } + + /// Converts the current instance to an equivalent string representation. + /// An equivalent string representation of the current instance. + /// The type of the vector () is not supported. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() => ToString("G", CultureInfo.InvariantCulture); + + private string ToString([StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format, IFormatProvider? formatProvider) + { + ThrowHelper.ThrowForUnsupportedIntrinsicsVector512BaseType(); + + var sb = new ValueStringBuilder(stackalloc char[64]); + string separator = NumberFormatInfo.GetInstance(formatProvider).NumberGroupSeparator; + + sb.Append('<'); + sb.Append(((IFormattable)this.GetElementUnsafe(0)).ToString(format, formatProvider)); + + for (int i = 1; i < Count; i++) + { + sb.Append(separator); + sb.Append(' '); + sb.Append(((IFormattable)this.GetElementUnsafe(i)).ToString(format, formatProvider)); + } + sb.Append('>'); + + return sb.ToString(); + } + } +} diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs index 42028ce728b02..a4382a4745a07 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs @@ -1100,10 +1100,25 @@ public static T Dot(Vector64 left, Vector64 right) { T result = default; - for (int index = 0; index < Vector64.Count; index++) + // Doing this as pairs is important for floating-point determinism + // This is because the underlying dpps instruction on x86/x64 will do this equivalently + // and otherwise the software vs accelerated implementations may differ in returned result. + + if (Vector64.Count != 1) + { + for (int index = 0; index < Vector64.Count; index += 2) + { + T value = Scalar.Add( + Scalar.Multiply(left.GetElementUnsafe(index + 0), right.GetElementUnsafe(index + 0)), + Scalar.Multiply(left.GetElementUnsafe(index + 1), right.GetElementUnsafe(index + 1)) + ); + + result = Scalar.Add(result, value); + } + } + else { - T value = Scalar.Multiply(left.GetElementUnsafe(index), right.GetElementUnsafe(index)); - result = Scalar.Add(result, value); + result = Scalar.Multiply(left.GetElementUnsafe(0), right.GetElementUnsafe(0)); } return result; diff --git a/src/libraries/System.Private.CoreLib/src/System/ThrowHelper.cs b/src/libraries/System.Private.CoreLib/src/System/ThrowHelper.cs index c9b3e589dcc3b..f44368e52d314 100644 --- a/src/libraries/System.Private.CoreLib/src/System/ThrowHelper.cs +++ b/src/libraries/System.Private.CoreLib/src/System/ThrowHelper.cs @@ -687,6 +687,19 @@ internal static void ThrowForUnsupportedIntrinsicsVector256BaseType() } } + // Throws if 'T' is disallowed in Vector512 in the Intrinsics namespace. + // If 'T' is allowed, no-ops. JIT will elide the method entirely if 'T' + // is supported and we're on an optimized release build. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void ThrowForUnsupportedIntrinsicsVector512BaseType() + where T : struct + { + if (!Vector512.IsSupported) + { + ThrowNotSupportedException(ExceptionResource.Arg_TypeNotSupported); + } + } + #if false // Reflection-based implementation does not work for NativeAOT // This function will convert an ExceptionArgument enum value to the argument name string. [MethodImpl(MethodImplOptions.NoInlining)] diff --git a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs index c85b6a35cb93b..fec48c2c5c1be 100644 --- a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs +++ b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs @@ -585,6 +585,8 @@ public static void CopyTo(this System.Runtime.Intrinsics.Vector256 vector, public static System.Runtime.Intrinsics.Vector256 Subtract(System.Runtime.Intrinsics.Vector256 left, System.Runtime.Intrinsics.Vector256 right) where T : struct { throw null; } public static T Sum(System.Runtime.Intrinsics.Vector256 vector) where T : struct { throw null; } public static T ToScalar(this System.Runtime.Intrinsics.Vector256 vector) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 ToVector512Unsafe(this System.Runtime.Intrinsics.Vector256 vector) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 ToVector512(this System.Runtime.Intrinsics.Vector256 vector) where T : struct { throw null; } public static bool TryCopyTo(this System.Runtime.Intrinsics.Vector256 vector, System.Span destination) where T : struct { throw null; } [System.CLSCompliantAttribute(false)] public static (System.Runtime.Intrinsics.Vector256 Lower, System.Runtime.Intrinsics.Vector256 Upper) Widen(System.Runtime.Intrinsics.Vector256 source) { throw null; } @@ -656,6 +658,327 @@ public static void CopyTo(this System.Runtime.Intrinsics.Vector256 vector, public static System.Runtime.Intrinsics.Vector256 operator >>>(System.Runtime.Intrinsics.Vector256 value, int shiftCount) { throw null; } public override string ToString() { throw null; } } + public static partial class Vector512 + { + public static bool IsHardwareAccelerated { get { throw null; } } + public static System.Runtime.Intrinsics.Vector512 Abs(System.Runtime.Intrinsics.Vector512 vector) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 Add(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 AndNot(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 AsByte(this System.Runtime.Intrinsics.Vector512 vector) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 AsDouble(this System.Runtime.Intrinsics.Vector512 vector) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 AsInt16(this System.Runtime.Intrinsics.Vector512 vector) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 AsInt32(this System.Runtime.Intrinsics.Vector512 vector) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 AsInt64(this System.Runtime.Intrinsics.Vector512 vector) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 AsNInt(this System.Runtime.Intrinsics.Vector512 vector) where T : struct { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 AsNUInt(this System.Runtime.Intrinsics.Vector512 vector) where T : struct { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 AsSByte(this System.Runtime.Intrinsics.Vector512 vector) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 AsSingle(this System.Runtime.Intrinsics.Vector512 vector) where T : struct { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 AsUInt16(this System.Runtime.Intrinsics.Vector512 vector) where T : struct { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 AsUInt32(this System.Runtime.Intrinsics.Vector512 vector) where T : struct { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 AsUInt64(this System.Runtime.Intrinsics.Vector512 vector) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 AsVector512(this System.Numerics.Vector value) where T : struct { throw null; } + public static System.Numerics.Vector AsVector(this System.Runtime.Intrinsics.Vector512 value) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 As(this System.Runtime.Intrinsics.Vector512 vector) where TFrom : struct where TTo : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 BitwiseAnd(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 BitwiseOr(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 Ceiling(System.Runtime.Intrinsics.Vector512 vector) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Ceiling(System.Runtime.Intrinsics.Vector512 vector) { throw null; } + public static System.Runtime.Intrinsics.Vector512 ConditionalSelect(System.Runtime.Intrinsics.Vector512 condition, System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 ConvertToDouble(System.Runtime.Intrinsics.Vector512 vector) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 ConvertToDouble(System.Runtime.Intrinsics.Vector512 vector) { throw null; } + public static System.Runtime.Intrinsics.Vector512 ConvertToInt32(System.Runtime.Intrinsics.Vector512 vector) { throw null; } + public static System.Runtime.Intrinsics.Vector512 ConvertToInt64(System.Runtime.Intrinsics.Vector512 vector) { throw null; } + public static System.Runtime.Intrinsics.Vector512 ConvertToSingle(System.Runtime.Intrinsics.Vector512 vector) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 ConvertToSingle(System.Runtime.Intrinsics.Vector512 vector) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 ConvertToUInt32(System.Runtime.Intrinsics.Vector512 vector) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 ConvertToUInt64(System.Runtime.Intrinsics.Vector512 vector) { throw null; } + public static void CopyTo(this System.Runtime.Intrinsics.Vector512 vector, System.Span destination) where T : struct { } + public static void CopyTo(this System.Runtime.Intrinsics.Vector512 vector, T[] destination) where T : struct { } + public static void CopyTo(this System.Runtime.Intrinsics.Vector512 vector, T[] destination, int startIndex) where T : struct { } + public static System.Runtime.Intrinsics.Vector512 Create(byte value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7, byte e8, byte e9, byte e10, byte e11, byte e12, byte e13, byte e14, byte e15, byte e16, byte e17, byte e18, byte e19, byte e20, byte e21, byte e22, byte e23, byte e24, byte e25, byte e26, byte e27, byte e28, byte e29, byte e30, byte e31, byte e32, byte e33, byte e34, byte e35, byte e36, byte e37, byte e38, byte e39, byte e40, byte e41, byte e42, byte e43, byte e44, byte e45, byte e46, byte e47, byte e48, byte e49, byte e50, byte e51, byte e52, byte e53, byte e54, byte e55, byte e56, byte e57, byte e58, byte e59, byte e60, byte e61, byte e62, byte e63) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(double value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(double e0, double e1, double e2, double e3, double e4, double e5, double e6, double e7) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(short value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(short e0, short e1, short e2, short e3, short e4, short e5, short e6, short e7, short e8, short e9, short e10, short e11, short e12, short e13, short e14, short e15, short e16, short e17, short e18, short e19, short e20, short e21, short e22, short e23, short e24, short e25, short e26, short e27, short e28, short e29, short e30, short e31) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(int value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(int e0, int e1, int e2, int e3, int e4, int e5, int e6, int e7, int e8, int e9, int e10, int e11, int e12, int e13, int e14, int e15) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(long value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(long e0, long e1, long e2, long e3, long e4, long e5, long e6, long e7) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(nint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Create(nuint value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(System.Runtime.Intrinsics.Vector256 lower, System.Runtime.Intrinsics.Vector256 upper) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(System.Runtime.Intrinsics.Vector256 lower, System.Runtime.Intrinsics.Vector256 upper) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(System.Runtime.Intrinsics.Vector256 lower, System.Runtime.Intrinsics.Vector256 upper) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(System.Runtime.Intrinsics.Vector256 lower, System.Runtime.Intrinsics.Vector256 upper) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(System.Runtime.Intrinsics.Vector256 lower, System.Runtime.Intrinsics.Vector256 upper) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(System.Runtime.Intrinsics.Vector256 lower, System.Runtime.Intrinsics.Vector256 upper) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Create(System.Runtime.Intrinsics.Vector256 lower, System.Runtime.Intrinsics.Vector256 upper) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Create(System.Runtime.Intrinsics.Vector256 lower, System.Runtime.Intrinsics.Vector256 upper) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(System.Runtime.Intrinsics.Vector256 lower, System.Runtime.Intrinsics.Vector256 upper) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Create(System.Runtime.Intrinsics.Vector256 lower, System.Runtime.Intrinsics.Vector256 upper) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Create(System.Runtime.Intrinsics.Vector256 lower, System.Runtime.Intrinsics.Vector256 upper) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Create(System.Runtime.Intrinsics.Vector256 lower, System.Runtime.Intrinsics.Vector256 upper) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Create(sbyte value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, sbyte e4, sbyte e5, sbyte e6, sbyte e7, sbyte e8, sbyte e9, sbyte e10, sbyte e11, sbyte e12, sbyte e13, sbyte e14, sbyte e15, sbyte e16, sbyte e17, sbyte e18, sbyte e19, sbyte e20, sbyte e21, sbyte e22, sbyte e23, sbyte e24, sbyte e25, sbyte e26, sbyte e27, sbyte e28, sbyte e29, sbyte e30, sbyte e31, sbyte e32, sbyte e33, sbyte e34, sbyte e35, sbyte e36, sbyte e37, sbyte e38, sbyte e39, sbyte e40, sbyte e41, sbyte e42, sbyte e43, sbyte e44, sbyte e45, sbyte e46, sbyte e47, sbyte e48, sbyte e49, sbyte e50, sbyte e51, sbyte e52, sbyte e53, sbyte e54, sbyte e55, sbyte e56, sbyte e57, sbyte e58, sbyte e59, sbyte e60, sbyte e61, sbyte e62, sbyte e63) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(float value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(float e0, float e1, float e2, float e3, float e4, float e5, float e6, float e7, float e8, float e9, float e10, float e11, float e12, float e13, float e14, float e15) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Create(ushort value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Create(ushort e0, ushort e1, ushort e2, ushort e3, ushort e4, ushort e5, ushort e6, ushort e7, ushort e8, ushort e9, ushort e10, ushort e11, ushort e12, ushort e13, ushort e14, ushort e15, ushort e16, ushort e17, ushort e18, ushort e19, ushort e20, ushort e21, ushort e22, ushort e23, ushort e24, ushort e25, ushort e26, ushort e27, ushort e28, ushort e29, ushort e30, ushort e31) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Create(uint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Create(uint e0, uint e1, uint e2, uint e3, uint e4, uint e5, uint e6, uint e7, uint e8, uint e9, uint e10, uint e11, uint e12, uint e13, uint e14, uint e15) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Create(ulong value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Create(ulong e0, ulong e1, ulong e2, ulong e3, ulong e4, ulong e5, ulong e6, ulong e7) { throw null; } + public static System.Runtime.Intrinsics.Vector512 CreateScalar(byte value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 CreateScalar(double value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 CreateScalar(short value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 CreateScalar(int value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 CreateScalar(long value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 CreateScalar(nint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 CreateScalar(nuint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 CreateScalar(sbyte value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 CreateScalar(float value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 CreateScalar(ushort value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 CreateScalar(uint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 CreateScalar(ulong value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 CreateScalar(T value) where T: struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 CreateScalarUnsafe(byte value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 CreateScalarUnsafe(double value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 CreateScalarUnsafe(short value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 CreateScalarUnsafe(int value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 CreateScalarUnsafe(long value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 CreateScalarUnsafe(nint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 CreateScalarUnsafe(nuint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 CreateScalarUnsafe(sbyte value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 CreateScalarUnsafe(float value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 CreateScalarUnsafe(ushort value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 CreateScalarUnsafe(uint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 CreateScalarUnsafe(ulong value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 CreateScalarUnsafe(T value) where T: struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(System.ReadOnlySpan values) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(System.Runtime.Intrinsics.Vector256 lower, System.Runtime.Intrinsics.Vector256 upper) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(T value) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(T[] values) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 Create(T[] values, int index) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 Divide(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 Divide(System.Runtime.Intrinsics.Vector512 left, T right) where T : struct { throw null; } + public static T Dot(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static bool EqualsAll(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static bool EqualsAny(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 Equals(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + [System.CLSCompliantAttribute(false)] + public static ulong ExtractMostSignificantBits(this System.Runtime.Intrinsics.Vector512 vector) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 Floor(System.Runtime.Intrinsics.Vector512 vector) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Floor(System.Runtime.Intrinsics.Vector512 vector) { throw null; } + public static T GetElement(this System.Runtime.Intrinsics.Vector512 vector, int index) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector256 GetLower(this System.Runtime.Intrinsics.Vector512 vector) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector256 GetUpper(this System.Runtime.Intrinsics.Vector512 vector) where T : struct { throw null; } + public static bool GreaterThanAll(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static bool GreaterThanAny(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static bool GreaterThanOrEqualAll(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static bool GreaterThanOrEqualAny(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 GreaterThanOrEqual(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 GreaterThan(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static bool LessThanAll(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static bool LessThanAny(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static bool LessThanOrEqualAll(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static bool LessThanOrEqualAny(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 LessThanOrEqual(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 LessThan(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + [System.CLSCompliantAttribute(false)] + public static unsafe System.Runtime.Intrinsics.Vector512 Load(T* source) where T : unmanaged { throw null; } + [System.CLSCompliantAttribute(false)] + public static unsafe System.Runtime.Intrinsics.Vector512 LoadAligned(T* source) where T : unmanaged { throw null; } + [System.CLSCompliantAttribute(false)] + public static unsafe System.Runtime.Intrinsics.Vector512 LoadAlignedNonTemporal(T* source) where T : unmanaged { throw null; } + public static System.Runtime.Intrinsics.Vector512 LoadUnsafe(ref T source) where T : struct { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 LoadUnsafe(ref T source, nuint elementOffset) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 Max(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 Min(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 Multiply(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 Multiply(System.Runtime.Intrinsics.Vector512 left, T right) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 Multiply(T left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 Narrow(System.Runtime.Intrinsics.Vector512 lower, System.Runtime.Intrinsics.Vector512 upper) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Narrow(System.Runtime.Intrinsics.Vector512 lower, System.Runtime.Intrinsics.Vector512 upper) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Narrow(System.Runtime.Intrinsics.Vector512 lower, System.Runtime.Intrinsics.Vector512 upper) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Narrow(System.Runtime.Intrinsics.Vector512 lower, System.Runtime.Intrinsics.Vector512 upper) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Narrow(System.Runtime.Intrinsics.Vector512 lower, System.Runtime.Intrinsics.Vector512 upper) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Narrow(System.Runtime.Intrinsics.Vector512 lower, System.Runtime.Intrinsics.Vector512 upper) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Narrow(System.Runtime.Intrinsics.Vector512 lower, System.Runtime.Intrinsics.Vector512 upper) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Negate(System.Runtime.Intrinsics.Vector512 vector) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 OnesComplement(System.Runtime.Intrinsics.Vector512 vector) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 ShiftLeft(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + public static System.Runtime.Intrinsics.Vector512 ShiftLeft(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + public static System.Runtime.Intrinsics.Vector512 ShiftLeft(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + public static System.Runtime.Intrinsics.Vector512 ShiftLeft(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + public static System.Runtime.Intrinsics.Vector512 ShiftLeft(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 ShiftLeft(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 ShiftLeft(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 ShiftLeft(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 ShiftLeft(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 ShiftLeft(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + public static System.Runtime.Intrinsics.Vector512 ShiftRightArithmetic(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + public static System.Runtime.Intrinsics.Vector512 ShiftRightArithmetic(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + public static System.Runtime.Intrinsics.Vector512 ShiftRightArithmetic(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + public static System.Runtime.Intrinsics.Vector512 ShiftRightArithmetic(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 ShiftRightArithmetic(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + public static System.Runtime.Intrinsics.Vector512 ShiftRightLogical(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + public static System.Runtime.Intrinsics.Vector512 ShiftRightLogical(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + public static System.Runtime.Intrinsics.Vector512 ShiftRightLogical(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + public static System.Runtime.Intrinsics.Vector512 ShiftRightLogical(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + public static System.Runtime.Intrinsics.Vector512 ShiftRightLogical(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 ShiftRightLogical(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 ShiftRightLogical(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 ShiftRightLogical(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 ShiftRightLogical(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 ShiftRightLogical(System.Runtime.Intrinsics.Vector512 vector, int shiftCount) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Shuffle(System.Runtime.Intrinsics.Vector512 vector, System.Runtime.Intrinsics.Vector512 indices) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Shuffle(System.Runtime.Intrinsics.Vector512 vector, System.Runtime.Intrinsics.Vector512 indices) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Shuffle(System.Runtime.Intrinsics.Vector512 vector, System.Runtime.Intrinsics.Vector512 indices) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Shuffle(System.Runtime.Intrinsics.Vector512 vector, System.Runtime.Intrinsics.Vector512 indices) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Shuffle(System.Runtime.Intrinsics.Vector512 vector, System.Runtime.Intrinsics.Vector512 indices) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Shuffle(System.Runtime.Intrinsics.Vector512 vector, System.Runtime.Intrinsics.Vector512 indices) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Shuffle(System.Runtime.Intrinsics.Vector512 vector, System.Runtime.Intrinsics.Vector512 indices) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Shuffle(System.Runtime.Intrinsics.Vector512 vector, System.Runtime.Intrinsics.Vector512 indices) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 Shuffle(System.Runtime.Intrinsics.Vector512 vector, System.Runtime.Intrinsics.Vector512 indices) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Shuffle(System.Runtime.Intrinsics.Vector512 vector, System.Runtime.Intrinsics.Vector512 indices) { throw null; } + public static System.Runtime.Intrinsics.Vector512 Sqrt(System.Runtime.Intrinsics.Vector512 vector) where T : struct { throw null; } + [System.CLSCompliantAttribute(false)] + public static unsafe void Store(this System.Runtime.Intrinsics.Vector512 source, T* destination) where T : unmanaged { throw null; } + [System.CLSCompliantAttribute(false)] + public static unsafe void StoreAligned(this System.Runtime.Intrinsics.Vector512 source, T* destination) where T : unmanaged { throw null; } + [System.CLSCompliantAttribute(false)] + public static unsafe void StoreAlignedNonTemporal(this System.Runtime.Intrinsics.Vector512 source, T* destination) where T : unmanaged { throw null; } + public static void StoreUnsafe(this System.Runtime.Intrinsics.Vector512 source, ref T destination) where T : struct { throw null; } + [System.CLSCompliantAttribute(false)] + public static void StoreUnsafe(this System.Runtime.Intrinsics.Vector512 source, ref T destination, nuint elementOffset) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 Subtract(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + public static T Sum(System.Runtime.Intrinsics.Vector512 vector) where T : struct { throw null; } + public static T ToScalar(this System.Runtime.Intrinsics.Vector512 vector) where T : struct { throw null; } + public static bool TryCopyTo(this System.Runtime.Intrinsics.Vector512 vector, System.Span destination) where T : struct { throw null; } + [System.CLSCompliantAttribute(false)] + public static (System.Runtime.Intrinsics.Vector512 Lower, System.Runtime.Intrinsics.Vector512 Upper) Widen(System.Runtime.Intrinsics.Vector512 source) { throw null; } + public static (System.Runtime.Intrinsics.Vector512 Lower, System.Runtime.Intrinsics.Vector512 Upper) Widen(System.Runtime.Intrinsics.Vector512 source) { throw null; } + public static (System.Runtime.Intrinsics.Vector512 Lower, System.Runtime.Intrinsics.Vector512 Upper) Widen(System.Runtime.Intrinsics.Vector512 source) { throw null; } + [System.CLSCompliantAttribute(false)] + public static (System.Runtime.Intrinsics.Vector512 Lower, System.Runtime.Intrinsics.Vector512 Upper) Widen(System.Runtime.Intrinsics.Vector512 source) { throw null; } + public static (System.Runtime.Intrinsics.Vector512 Lower, System.Runtime.Intrinsics.Vector512 Upper) Widen(System.Runtime.Intrinsics.Vector512 source) { throw null; } + [System.CLSCompliantAttribute(false)] + public static (System.Runtime.Intrinsics.Vector512 Lower, System.Runtime.Intrinsics.Vector512 Upper) Widen(System.Runtime.Intrinsics.Vector512 source) { throw null; } + [System.CLSCompliantAttribute(false)] + public static (System.Runtime.Intrinsics.Vector512 Lower, System.Runtime.Intrinsics.Vector512 Upper) Widen(System.Runtime.Intrinsics.Vector512 source) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 WidenLower(System.Runtime.Intrinsics.Vector512 source) { throw null; } + public static System.Runtime.Intrinsics.Vector512 WidenLower(System.Runtime.Intrinsics.Vector512 source) { throw null; } + public static System.Runtime.Intrinsics.Vector512 WidenLower(System.Runtime.Intrinsics.Vector512 source) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 WidenLower(System.Runtime.Intrinsics.Vector512 source) { throw null; } + public static System.Runtime.Intrinsics.Vector512 WidenLower(System.Runtime.Intrinsics.Vector512 source) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 WidenLower(System.Runtime.Intrinsics.Vector512 source) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 WidenLower(System.Runtime.Intrinsics.Vector512 source) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 WidenUpper(System.Runtime.Intrinsics.Vector512 source) { throw null; } + public static System.Runtime.Intrinsics.Vector512 WidenUpper(System.Runtime.Intrinsics.Vector512 source) { throw null; } + public static System.Runtime.Intrinsics.Vector512 WidenUpper(System.Runtime.Intrinsics.Vector512 source) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 WidenUpper(System.Runtime.Intrinsics.Vector512 source) { throw null; } + public static System.Runtime.Intrinsics.Vector512 WidenUpper(System.Runtime.Intrinsics.Vector512 source) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 WidenUpper(System.Runtime.Intrinsics.Vector512 source) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.Runtime.Intrinsics.Vector512 WidenUpper(System.Runtime.Intrinsics.Vector512 source) { throw null; } + public static System.Runtime.Intrinsics.Vector512 WithElement(this System.Runtime.Intrinsics.Vector512 vector, int index, T value) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 WithLower(this System.Runtime.Intrinsics.Vector512 vector, System.Runtime.Intrinsics.Vector256 value) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 WithUpper(this System.Runtime.Intrinsics.Vector512 vector, System.Runtime.Intrinsics.Vector256 value) where T : struct { throw null; } + public static System.Runtime.Intrinsics.Vector512 Xor(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) where T : struct { throw null; } + } + public readonly partial struct Vector512 : System.IEquatable> where T : struct + { + private readonly int _dummyPrimitive; + public static System.Runtime.Intrinsics.Vector512 AllBitsSet { get { throw null; } } + public static int Count { get { throw null; } } + public static bool IsSupported { get { throw null; } } + public static System.Runtime.Intrinsics.Vector512 One { get { throw null; } } + public static System.Runtime.Intrinsics.Vector512 Zero { get { throw null; } } + public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? obj) { throw null; } + public bool Equals(System.Runtime.Intrinsics.Vector512 other) { throw null; } + public override int GetHashCode() { throw null; } + public T this[int index] { get { throw null; } } + public static System.Runtime.Intrinsics.Vector512 operator +(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) { throw null; } + public static System.Runtime.Intrinsics.Vector512 operator &(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) { throw null; } + public static System.Runtime.Intrinsics.Vector512 operator |(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) { throw null; } + public static System.Runtime.Intrinsics.Vector512 operator /(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) { throw null; } + public static System.Runtime.Intrinsics.Vector512 operator /(System.Runtime.Intrinsics.Vector512 left, T right) { throw null; } + public static bool operator ==(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) { throw null; } + public static System.Runtime.Intrinsics.Vector512 operator ^(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) { throw null; } + public static bool operator !=(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) { throw null; } + public static System.Runtime.Intrinsics.Vector512 operator <<(System.Runtime.Intrinsics.Vector512 value, int shiftCount) { throw null; } + public static System.Runtime.Intrinsics.Vector512 operator *(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) { throw null; } + public static System.Runtime.Intrinsics.Vector512 operator *(System.Runtime.Intrinsics.Vector512 left, T right) { throw null; } + public static System.Runtime.Intrinsics.Vector512 operator *(T left, System.Runtime.Intrinsics.Vector512 right) { throw null; } + public static System.Runtime.Intrinsics.Vector512 operator ~(System.Runtime.Intrinsics.Vector512 vector) { throw null; } + public static System.Runtime.Intrinsics.Vector512 operator >>(System.Runtime.Intrinsics.Vector512 value, int shiftCount) { throw null; } + public static System.Runtime.Intrinsics.Vector512 operator -(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) { throw null; } + public static System.Runtime.Intrinsics.Vector512 operator -(System.Runtime.Intrinsics.Vector512 vector) { throw null; } + public static System.Runtime.Intrinsics.Vector512 operator +(System.Runtime.Intrinsics.Vector512 value) { throw null; } + public static System.Runtime.Intrinsics.Vector512 operator >>>(System.Runtime.Intrinsics.Vector512 value, int shiftCount) { throw null; } + public override string ToString() { throw null; } + } public static partial class Vector64 { public static bool IsHardwareAccelerated { get { throw null; } } diff --git a/src/libraries/System.Runtime.Intrinsics/tests/System.Runtime.Intrinsics.Tests.csproj b/src/libraries/System.Runtime.Intrinsics/tests/System.Runtime.Intrinsics.Tests.csproj index faec945cf5fef..9bd04def26623 100644 --- a/src/libraries/System.Runtime.Intrinsics/tests/System.Runtime.Intrinsics.Tests.csproj +++ b/src/libraries/System.Runtime.Intrinsics/tests/System.Runtime.Intrinsics.Tests.csproj @@ -11,6 +11,7 @@ + diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs new file mode 100644 index 0000000000000..4922cf8cab858 --- /dev/null +++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs @@ -0,0 +1,5088 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Reflection; +using System.Runtime.InteropServices; +using Xunit; + +namespace System.Runtime.Intrinsics.Tests.Vectors +{ + public sealed class Vector512Tests + { + [Fact] + public unsafe void Vector512IsHardwareAcceleratedTest() + { + MethodInfo methodInfo = typeof(Vector512).GetMethod("get_IsHardwareAccelerated"); + Assert.Equal(Vector512.IsHardwareAccelerated, methodInfo.Invoke(null, null)); + } + + [Fact] + public unsafe void Vector512ByteExtractMostSignificantBitsTest() + { + Vector512 vector = Vector512.Create( + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80 + ); + + ulong result = Vector512.ExtractMostSignificantBits(vector); + Assert.Equal(0b10101010_10101010_10101010_10101010_10101010_10101010_10101010_10101010UL, result); + } + + [Fact] + public unsafe void Vector512DoubleExtractMostSignificantBitsTest() + { + Vector512 vector = Vector512.Create( + +1.0, + -0.0, + +1.0, + -0.0, + +1.0, + -0.0, + +1.0, + -0.0 + ); + + ulong result = Vector512.ExtractMostSignificantBits(vector); + Assert.Equal(0b10101010UL, result); + } + + [Fact] + public unsafe void Vector512Int16ExtractMostSignificantBitsTest() + { + Vector512 vector = Vector512.Create( + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000 + ).AsInt16(); + + ulong result = Vector512.ExtractMostSignificantBits(vector); + Assert.Equal(0b10101010_10101010_10101010_10101010UL, result); + } + + [Fact] + public unsafe void Vector512Int32ExtractMostSignificantBitsTest() + { + Vector512 vector = Vector512.Create( + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U + ).AsInt32(); + + ulong result = Vector512.ExtractMostSignificantBits(vector); + Assert.Equal(0b10101010_10101010UL, result); + } + + [Fact] + public unsafe void Vector512Int64ExtractMostSignificantBitsTest() + { + Vector512 vector = Vector512.Create( + 0x0000000000000001UL, + 0x8000000000000000UL, + 0x0000000000000001UL, + 0x8000000000000000UL, + 0x0000000000000001UL, + 0x8000000000000000UL, + 0x0000000000000001UL, + 0x8000000000000000UL + ).AsInt64(); + + ulong result = Vector512.ExtractMostSignificantBits(vector); + Assert.Equal(0b1010_1010UL, result); + } + + [Fact] + public unsafe void Vector512NIntExtractMostSignificantBitsTest() + { + if (Environment.Is64BitProcess) + { + Vector512 vector = Vector512.Create( + 0x0000000000000001UL, + 0x8000000000000000UL, + 0x0000000000000001UL, + 0x8000000000000000UL, + 0x0000000000000001UL, + 0x8000000000000000UL, + 0x0000000000000001UL, + 0x8000000000000000UL + ).AsNInt(); + + ulong result = Vector512.ExtractMostSignificantBits(vector); + Assert.Equal(0b10101010UL, result); + } + else + { + Vector512 vector = Vector512.Create( + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U + ).AsNInt(); + + ulong result = Vector512.ExtractMostSignificantBits(vector); + Assert.Equal(0b10101010_10101010UL, result); + } + } + + [Fact] + public unsafe void Vector512NUIntExtractMostSignificantBitsTest() + { + if (Environment.Is64BitProcess) + { + Vector512 vector = Vector512.Create( + 0x0000000000000001UL, + 0x8000000000000000UL, + 0x0000000000000001UL, + 0x8000000000000000UL, + 0x0000000000000001UL, + 0x8000000000000000UL, + 0x0000000000000001UL, + 0x8000000000000000UL + ).AsNUInt(); + + ulong result = Vector512.ExtractMostSignificantBits(vector); + Assert.Equal(0b10101010UL, result); + } + else + { + Vector512 vector = Vector512.Create( + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U + ).AsNUInt(); + + ulong result = Vector512.ExtractMostSignificantBits(vector); + Assert.Equal(0b10101010_10101010UL, result); + } + } + + [Fact] + public unsafe void Vector512SByteExtractMostSignificantBitsTest() + { + Vector512 vector = Vector512.Create( + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80, + 0x01, + 0x80 + ).AsSByte(); + + ulong result = Vector512.ExtractMostSignificantBits(vector); + Assert.Equal(0b10101010_10101010_10101010_10101010_10101010_10101010_10101010_10101010UL, result); + } + + [Fact] + public unsafe void Vector512SingleExtractMostSignificantBitsTest() + { + Vector512 vector = Vector512.Create( + +1.0f, + -0.0f, + +1.0f, + -0.0f, + +1.0f, + -0.0f, + +1.0f, + -0.0f, + +1.0f, + -0.0f, + +1.0f, + -0.0f, + +1.0f, + -0.0f, + +1.0f, + -0.0f + ); + + ulong result = Vector512.ExtractMostSignificantBits(vector); + Assert.Equal(0b10101010_10101010UL, result); + } + + [Fact] + public unsafe void Vector512UInt16ExtractMostSignificantBitsTest() + { + Vector512 vector = Vector512.Create( + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000, + 0x0001, + 0x8000 + ); + + ulong result = Vector512.ExtractMostSignificantBits(vector); + Assert.Equal(0b10101010_10101010_10101010_10101010UL, result); + } + + [Fact] + public unsafe void Vector512UInt32ExtractMostSignificantBitsTest() + { + Vector512 vector = Vector512.Create( + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U, + 0x00000001U, + 0x80000000U + ); + + ulong result = Vector512.ExtractMostSignificantBits(vector); + Assert.Equal(0b10101010_10101010UL, result); + } + + [Fact] + public unsafe void Vector512UInt64ExtractMostSignificantBitsTest() + { + Vector512 vector = Vector512.Create( + 0x0000000000000001UL, + 0x8000000000000000UL, + 0x0000000000000001UL, + 0x8000000000000000UL, + 0x0000000000000001UL, + 0x8000000000000000UL, + 0x0000000000000001UL, + 0x8000000000000000UL + ); + + ulong result = Vector512.ExtractMostSignificantBits(vector); + Assert.Equal(0b10101010UL, result); + } + + [Fact] + public unsafe void Vector512ByteLoadTest() + { + byte* value = stackalloc byte[64]; + + for (int index = 0; index < 64; index++) + { + value[index] = (byte)(index); + } + + Vector512 vector = Vector512.Load(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((byte)index, vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512DoubleLoadTest() + { + double* value = stackalloc double[8]; + + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.Load(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((double)index, vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512Int16LoadTest() + { + short* value = stackalloc short[32]; + + for (int index = 0; index < 32; index++) + { + value[index] = (short)(index); + } + + Vector512 vector = Vector512.Load(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((short)index, vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512Int32LoadTest() + { + int* value = stackalloc int[16]; + + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.Load(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((int)index, vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512Int64LoadTest() + { + long* value = stackalloc long[8]; + + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.Load(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((long)index, vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512NIntLoadTest() + { + if (Environment.Is64BitProcess) + { + nint* value = stackalloc nint[8]; + + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.Load(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nint)index, vector.GetElement(index)); + } + } + else + { + nint* value = stackalloc nint[16]; + + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.Load(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nint)index, vector.GetElement(index)); + } + } + } + + [Fact] + public unsafe void Vector512NUIntLoadTest() + { + if (Environment.Is64BitProcess) + { + nuint* value = stackalloc nuint[8]; + + for (int index = 0; index < 8; index++) + { + value[index] = (nuint)(index); + } + + Vector512 vector = Vector512.Load(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nuint)index, vector.GetElement(index)); + } + } + else + { + nuint* value = stackalloc nuint[16]; + + for (int index = 0; index < 16; index++) + { + value[index] = (nuint)(index); + } + + Vector512 vector = Vector512.Load(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nuint)index, vector.GetElement(index)); + } + } + } + + [Fact] + public unsafe void Vector512SByteLoadTest() + { + sbyte* value = stackalloc sbyte[64]; + + for (int index = 0; index < 64; index++) + { + value[index] = (sbyte)(index); + } + + Vector512 vector = Vector512.Load(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((sbyte)index, vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512SingleLoadTest() + { + float* value = stackalloc float[16]; + + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.Load(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((float)index, vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512UInt16LoadTest() + { + ushort* value = stackalloc ushort[32]; + + for (int index = 0; index < 32; index++) + { + value[index] = (ushort)(index); + } + + Vector512 vector = Vector512.Load(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ushort)index, vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512UInt32LoadTest() + { + uint* value = stackalloc uint[16]; + + for (int index = 0; index < 16; index++) + { + value[index] = (uint)(index); + } + + Vector512 vector = Vector512.Load(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((uint)index, vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512UInt64LoadTest() + { + ulong* value = stackalloc ulong[8]; + + for (int index = 0; index < 8; index++) + { + value[index] = (ulong)(index); + } + + Vector512 vector = Vector512.Load(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ulong)index, vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512ByteLoadAlignedTest() + { + byte* value = null; + + try + { + value = (byte*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 64; index++) + { + value[index] = (byte)(index); + } + + Vector512 vector = Vector512.LoadAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((byte)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512DoubleLoadAlignedTest() + { + double* value = null; + + try + { + value = (double*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.LoadAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((double)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512Int16LoadAlignedTest() + { + short* value = null; + + try + { + value = (short*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 32; index++) + { + value[index] = (short)(index); + } + + Vector512 vector = Vector512.LoadAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((short)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512Int32LoadAlignedTest() + { + int* value = null; + + try + { + value = (int*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.LoadAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((int)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512Int64LoadAlignedTest() + { + long* value = null; + + try + { + value = (long*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.LoadAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((long)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512NIntLoadAlignedTest() + { + nint* value = null; + + try + { + value = (nint*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + if (Environment.Is64BitProcess) + { + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + } + else + { + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + } + + Vector512 vector = Vector512.LoadAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nint)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512NUIntLoadAlignedTest() + { + nuint* value = null; + + try + { + value = (nuint*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + if (Environment.Is64BitProcess) + { + for (int index = 0; index < 8; index++) + { + value[index] = (nuint)(index); + } + } + else + { + for (int index = 0; index < 16; index++) + { + value[index] = (nuint)(index); + } + } + + Vector512 vector = Vector512.LoadAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nuint)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512SByteLoadAlignedTest() + { + sbyte* value = null; + + try + { + value = (sbyte*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 64; index++) + { + value[index] = (sbyte)(index); + } + + Vector512 vector = Vector512.LoadAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((sbyte)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512SingleLoadAlignedTest() + { + float* value = null; + + try + { + value = (float*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.LoadAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((float)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512UInt16LoadAlignedTest() + { + ushort* value = null; + + try + { + value = (ushort*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 32; index++) + { + value[index] = (ushort)(index); + } + + Vector512 vector = Vector512.LoadAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ushort)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512UInt32LoadAlignedTest() + { + uint* value = null; + + try + { + value = (uint*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 16; index++) + { + value[index] = (uint)(index); + } + + Vector512 vector = Vector512.LoadAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((uint)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512UInt64LoadAlignedTest() + { + ulong* value = null; + + try + { + value = (ulong*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 8; index++) + { + value[index] = (ulong)(index); + } + + Vector512 vector = Vector512.LoadAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ulong)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512ByteLoadAlignedNonTemporalTest() + { + byte* value = null; + + try + { + value = (byte*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 64; index++) + { + value[index] = (byte)(index); + } + + Vector512 vector = Vector512.LoadAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((byte)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512DoubleLoadAlignedNonTemporalTest() + { + double* value = null; + + try + { + value = (double*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.LoadAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((double)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512Int16LoadAlignedNonTemporalTest() + { + short* value = null; + + try + { + value = (short*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 32; index++) + { + value[index] = (short)(index); + } + + Vector512 vector = Vector512.LoadAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((short)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512Int32LoadAlignedNonTemporalTest() + { + int* value = null; + + try + { + value = (int*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.LoadAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((int)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512Int64LoadAlignedNonTemporalTest() + { + long* value = null; + + try + { + value = (long*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.LoadAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((long)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512NIntLoadAlignedNonTemporalTest() + { + nint* value = null; + + try + { + value = (nint*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + if (Environment.Is64BitProcess) + { + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + } + else + { + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + } + + Vector512 vector = Vector512.LoadAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nint)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512NUIntLoadAlignedNonTemporalTest() + { + nuint* value = null; + + try + { + value = (nuint*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + if (Environment.Is64BitProcess) + { + for (int index = 0; index < 8; index++) + { + value[index] = (nuint)(index); + } + } + else + { + for (int index = 0; index < 16; index++) + { + value[index] = (nuint)(index); + } + } + + Vector512 vector = Vector512.LoadAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nuint)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512SByteLoadAlignedNonTemporalTest() + { + sbyte* value = null; + + try + { + value = (sbyte*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 64; index++) + { + value[index] = (sbyte)(index); + } + + Vector512 vector = Vector512.LoadAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((sbyte)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512SingleLoadAlignedNonTemporalTest() + { + float* value = null; + + try + { + value = (float*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.LoadAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((float)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512UInt16LoadAlignedNonTemporalTest() + { + ushort* value = null; + + try + { + value = (ushort*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 32; index++) + { + value[index] = (ushort)(index); + } + + Vector512 vector = Vector512.LoadAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ushort)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512UInt32LoadAlignedNonTemporalTest() + { + uint* value = null; + + try + { + value = (uint*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 16; index++) + { + value[index] = (uint)(index); + } + + Vector512 vector = Vector512.LoadAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((uint)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512UInt64LoadAlignedNonTemporalTest() + { + ulong* value = null; + + try + { + value = (ulong*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 8; index++) + { + value[index] = (ulong)(index); + } + + Vector512 vector = Vector512.LoadAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ulong)index, vector.GetElement(index)); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512ByteLoadUnsafeTest() + { + byte* value = stackalloc byte[64]; + + for (int index = 0; index < 64; index++) + { + value[index] = (byte)(index); + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((byte)index, vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512DoubleLoadUnsafeTest() + { + double* value = stackalloc double[8]; + + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((double)index, vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512Int16LoadUnsafeTest() + { + short* value = stackalloc short[32]; + + for (int index = 0; index < 32; index++) + { + value[index] = (short)(index); + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((short)index, vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512Int32LoadUnsafeTest() + { + int* value = stackalloc int[16]; + + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((int)index, vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512Int64LoadUnsafeTest() + { + long* value = stackalloc long[8]; + + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((long)index, vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512NIntLoadUnsafeTest() + { + if (Environment.Is64BitProcess) + { + nint* value = stackalloc nint[8]; + + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nint)index, vector.GetElement(index)); + } + } + else + { + nint* value = stackalloc nint[16]; + + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nint)index, vector.GetElement(index)); + } + } + } + + [Fact] + public unsafe void Vector512NUIntLoadUnsafeTest() + { + if (Environment.Is64BitProcess) + { + nuint* value = stackalloc nuint[8]; + + for (int index = 0; index < 8; index++) + { + value[index] = (nuint)(index); + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nuint)index, vector.GetElement(index)); + } + } + else + { + nuint* value = stackalloc nuint[16]; + + for (int index = 0; index < 16; index++) + { + value[index] = (nuint)(index); + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nuint)index, vector.GetElement(index)); + } + } + } + + [Fact] + public unsafe void Vector512SByteLoadUnsafeTest() + { + sbyte* value = stackalloc sbyte[64]; + + for (int index = 0; index < 64; index++) + { + value[index] = (sbyte)(index); + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((sbyte)index, vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512SingleLoadUnsafeTest() + { + float* value = stackalloc float[16]; + + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((float)index, vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512UInt16LoadUnsafeTest() + { + ushort* value = stackalloc ushort[32]; + + for (int index = 0; index < 32; index++) + { + value[index] = (ushort)(index); + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ushort)index, vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512UInt32LoadUnsafeTest() + { + uint* value = stackalloc uint[16]; + + for (int index = 0; index < 16; index++) + { + value[index] = (uint)(index); + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((uint)index, vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512UInt64LoadUnsafeTest() + { + ulong* value = stackalloc ulong[8]; + + for (int index = 0; index < 8; index++) + { + value[index] = (ulong)(index); + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ulong)index, vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512ByteLoadUnsafeIndexTest() + { + byte* value = stackalloc byte[64 + 1]; + + for (int index = 0; index < 64 + 1; index++) + { + value[index] = (byte)(index); + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((byte)(index + 1), vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512DoubleLoadUnsafeIndexTest() + { + double* value = stackalloc double[8 + 1]; + + for (int index = 0; index < 8 + 1; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((double)(index + 1), vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512Int16LoadUnsafeIndexTest() + { + short* value = stackalloc short[32 + 1]; + + for (int index = 0; index < 32 + 1; index++) + { + value[index] = (short)(index); + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((short)(index + 1), vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512Int32LoadUnsafeIndexTest() + { + int* value = stackalloc int[16 + 1]; + + for (int index = 0; index < 16 + 1; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((int)(index + 1), vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512Int64LoadUnsafeIndexTest() + { + long* value = stackalloc long[8 + 1]; + + for (int index = 0; index < 8 + 1; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((long)(index + 1), vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512NIntLoadUnsafeIndexTest() + { + if (Environment.Is64BitProcess) + { + nint* value = stackalloc nint[8 + 1]; + + for (int index = 0; index < 8 + 1; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nint)(index + 1), vector.GetElement(index)); + } + } + else + { + nint* value = stackalloc nint[16 + 1]; + + for (int index = 0; index < 16 + 1; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nint)(index + 1), vector.GetElement(index)); + } + } + } + + [Fact] + public unsafe void Vector512NUIntLoadUnsafeIndexTest() + { + if (Environment.Is64BitProcess) + { + nuint* value = stackalloc nuint[8 + 1]; + + for (int index = 0; index < 8 + 1; index++) + { + value[index] = (nuint)(index); + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nuint)(index + 1), vector.GetElement(index)); + } + } + else + { + nuint* value = stackalloc nuint[16 + 1]; + + for (int index = 0; index < 16 + 1; index++) + { + value[index] = (nuint)(index); + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nuint)(index + 1), vector.GetElement(index)); + } + } + } + + [Fact] + public unsafe void Vector512SByteLoadUnsafeIndexTest() + { + sbyte* value = stackalloc sbyte[64 + 1]; + + for (int index = 0; index < 64 + 1; index++) + { + value[index] = (sbyte)(index); + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((sbyte)(index + 1), vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512SingleLoadUnsafeIndexTest() + { + float* value = stackalloc float[16 + 1]; + + for (int index = 0; index < 16 + 1; index++) + { + value[index] = index; + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((float)(index + 1), vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512UInt16LoadUnsafeIndexTest() + { + ushort* value = stackalloc ushort[32 + 1]; + + for (int index = 0; index < 32 + 1; index++) + { + value[index] = (ushort)(index); + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ushort)(index + 1), vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512UInt32LoadUnsafeIndexTest() + { + uint* value = stackalloc uint[16 + 1]; + + for (int index = 0; index < 16 + 1; index++) + { + value[index] = (uint)(index); + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((uint)(index + 1), vector.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512UInt64LoadUnsafeIndexTest() + { + ulong* value = stackalloc ulong[8 + 1]; + + for (int index = 0; index < 8 + 1; index++) + { + value[index] = (ulong)(index); + } + + Vector512 vector = Vector512.LoadUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ulong)(index + 1), vector.GetElement(index)); + } + } + + [Fact] + public void Vector512ByteShiftLeftTest() + { + Vector512 vector = Vector512.Create((byte)0x01); + vector = Vector512.ShiftLeft(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((byte)0x10, vector.GetElement(index)); + } + } + + [Fact] + public void Vector512Int16ShiftLeftTest() + { + Vector512 vector = Vector512.Create((short)0x01); + vector = Vector512.ShiftLeft(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((short)0x10, vector.GetElement(index)); + } + } + + [Fact] + public void Vector512Int32ShiftLeftTest() + { + Vector512 vector = Vector512.Create((int)0x01); + vector = Vector512.ShiftLeft(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((int)0x10, vector.GetElement(index)); + } + } + + [Fact] + public void Vector512Int64ShiftLeftTest() + { + Vector512 vector = Vector512.Create((long)0x01); + vector = Vector512.ShiftLeft(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((long)0x10, vector.GetElement(index)); + } + } + + [Fact] + public void Vector512NIntShiftLeftTest() + { + Vector512 vector = Vector512.Create((nint)0x01); + vector = Vector512.ShiftLeft(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nint)0x10, vector.GetElement(index)); + } + } + + [Fact] + public void Vector512NUIntShiftLeftTest() + { + Vector512 vector = Vector512.Create((nuint)0x01); + vector = Vector512.ShiftLeft(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nuint)0x10, vector.GetElement(index)); + } + } + + [Fact] + public void Vector512SByteShiftLeftTest() + { + Vector512 vector = Vector512.Create((sbyte)0x01); + vector = Vector512.ShiftLeft(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((sbyte)0x10, vector.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt16ShiftLeftTest() + { + Vector512 vector = Vector512.Create((ushort)0x01); + vector = Vector512.ShiftLeft(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ushort)0x10, vector.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt32ShiftLeftTest() + { + Vector512 vector = Vector512.Create((uint)0x01); + vector = Vector512.ShiftLeft(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((uint)0x10, vector.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt64ShiftLeftTest() + { + Vector512 vector = Vector512.Create((ulong)0x01); + vector = Vector512.ShiftLeft(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ulong)0x10, vector.GetElement(index)); + } + } + + [Fact] + public void Vector512Int16ShiftRightArithmeticTest() + { + Vector512 vector = Vector512.Create(unchecked((short)0x8000)); + vector = Vector512.ShiftRightArithmetic(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal(unchecked((short)0xF800), vector.GetElement(index)); + } + } + + [Fact] + public void Vector512Int32ShiftRightArithmeticTest() + { + Vector512 vector = Vector512.Create(unchecked((int)0x80000000)); + vector = Vector512.ShiftRightArithmetic(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal(unchecked((int)0xF8000000), vector.GetElement(index)); + } + } + + [Fact] + public void Vector512Int64ShiftRightArithmeticTest() + { + Vector512 vector = Vector512.Create(unchecked((long)0x8000000000000000)); + vector = Vector512.ShiftRightArithmetic(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal(unchecked((long)0xF800000000000000), vector.GetElement(index)); + } + } + + [Fact] + public void Vector512NIntShiftRightArithmeticTest() + { + if (Environment.Is64BitProcess) + { + Vector512 vector = Vector512.Create(unchecked((nint)0x8000000000000000)); + vector = Vector512.ShiftRightArithmetic(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal(unchecked((nint)0xF800000000000000), vector.GetElement(index)); + } + } + else + { + Vector512 vector = Vector512.Create(unchecked((nint)0x80000000)); + vector = Vector512.ShiftRightArithmetic(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal(unchecked((nint)0xF8000000), vector.GetElement(index)); + } + } + } + + [Fact] + public void Vector512SByteShiftRightArithmeticTest() + { + Vector512 vector = Vector512.Create(unchecked((sbyte)0x80)); + vector = Vector512.ShiftRightArithmetic(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal(unchecked((sbyte)0xF8), vector.GetElement(index)); + } + } + + [Fact] + public void Vector512ByteShiftRightLogicalTest() + { + Vector512 vector = Vector512.Create((byte)0x80); + vector = Vector512.ShiftRightLogical(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((byte)0x08, vector.GetElement(index)); + } + } + + [Fact] + public void Vector512Int16ShiftRightLogicalTest() + { + Vector512 vector = Vector512.Create(unchecked((short)0x8000)); + vector = Vector512.ShiftRightLogical(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((short)0x0800, vector.GetElement(index)); + } + } + + [Fact] + public void Vector512Int32ShiftRightLogicalTest() + { + Vector512 vector = Vector512.Create(unchecked((int)0x80000000)); + vector = Vector512.ShiftRightLogical(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((int)0x08000000, vector.GetElement(index)); + } + } + + [Fact] + public void Vector512Int64ShiftRightLogicalTest() + { + Vector512 vector = Vector512.Create(unchecked((long)0x8000000000000000)); + vector = Vector512.ShiftRightLogical(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((long)0x0800000000000000, vector.GetElement(index)); + } + } + + [Fact] + public void Vector512NIntShiftRightLogicalTest() + { + if (Environment.Is64BitProcess) + { + Vector512 vector = Vector512.Create(unchecked((nint)0x8000000000000000)); + vector = Vector512.ShiftRightLogical(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal(unchecked((nint)0x0800000000000000), vector.GetElement(index)); + } + } + else + { + Vector512 vector = Vector512.Create(unchecked((nint)0x80000000)); + vector = Vector512.ShiftRightLogical(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal(unchecked((nint)0x08000000), vector.GetElement(index)); + } + } + } + + [Fact] + public void Vector512NUIntShiftRightLogicalTest() + { + if (Environment.Is64BitProcess) + { + Vector512 vector = Vector512.Create(unchecked((nuint)0x8000000000000000)); + vector = Vector512.ShiftRightLogical(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal(unchecked((nuint)0x0800000000000000), vector.GetElement(index)); + } + } + else + { + Vector512 vector = Vector512.Create(unchecked((nuint)0x80000000)); + vector = Vector512.ShiftRightLogical(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal(unchecked((nuint)0x08000000), vector.GetElement(index)); + } + } + } + + [Fact] + public void Vector512SByteShiftRightLogicalTest() + { + Vector512 vector = Vector512.Create(unchecked((sbyte)0x80)); + vector = Vector512.ShiftRightLogical(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((sbyte)0x08, vector.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt16ShiftRightLogicalTest() + { + Vector512 vector = Vector512.Create(unchecked((ushort)0x8000)); + vector = Vector512.ShiftRightLogical(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ushort)0x0800, vector.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt32ShiftRightLogicalTest() + { + Vector512 vector = Vector512.Create(0x80000000); + vector = Vector512.ShiftRightLogical(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((uint)0x08000000, vector.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt64ShiftRightLogicalTest() + { + Vector512 vector = Vector512.Create(0x8000000000000000); + vector = Vector512.ShiftRightLogical(vector, 4); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ulong)0x0800000000000000, vector.GetElement(index)); + } + } + + [Fact] + public void Vector512ByteShuffleOneInputTest() + { + Vector512 vector = Vector512.Create((byte)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64); + Vector512 result = Vector512.Shuffle(vector, Vector512.Create((byte)63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((byte)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512DoubleShuffleOneInputTest() + { + Vector512 vector = Vector512.Create((double)1, 2, 3, 4, 5, 6, 7, 8); + Vector512 result = Vector512.Shuffle(vector, Vector512.Create((long)7, 6, 5, 4, 3, 2, 1, 0)); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((double)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512Int16ShuffleOneInputTest() + { + Vector512 vector = Vector512.Create((short)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32); + Vector512 result = Vector512.Shuffle(vector, Vector512.Create((short)31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((short)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512Int32ShuffleOneInputTest() + { + Vector512 vector = Vector512.Create((int)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); + Vector512 result = Vector512.Shuffle(vector, Vector512.Create((int)15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((int)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512Int64ShuffleOneInputTest() + { + Vector512 vector = Vector512.Create((long)1, 2, 3, 4, 5, 6, 7, 8); + Vector512 result = Vector512.Shuffle(vector, Vector512.Create((long)7, 6, 5, 4, 3, 2, 1, 0)); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((long)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512SByteShuffleOneInputTest() + { + Vector512 vector = Vector512.Create((sbyte)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64); + Vector512 result = Vector512.Shuffle(vector, Vector512.Create((sbyte)63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((sbyte)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512SingleShuffleOneInputTest() + { + Vector512 vector = Vector512.Create((float)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); + Vector512 result = Vector512.Shuffle(vector, Vector512.Create((int)15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((float)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt16ShuffleOneInputTest() + { + Vector512 vector = Vector512.Create((ushort)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32); + Vector512 result = Vector512.Shuffle(vector, Vector512.Create((ushort)31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ushort)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt32ShuffleOneInputTest() + { + Vector512 vector = Vector512.Create((uint)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); + Vector512 result = Vector512.Shuffle(vector, Vector512.Create((uint)15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((uint)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt64ShuffleOneInputTest() + { + Vector512 vector = Vector512.Create((ulong)1, 2, 3, 4, 5, 6, 7, 8); + Vector512 result = Vector512.Shuffle(vector, Vector512.Create((ulong)7, 6, 5, 4, 3, 2, 1, 0)); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ulong)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512ByteShuffleOneInputWithDirectVectorTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((byte)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64), + Vector512.Create((byte)63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0) + ); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((byte)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512DoubleShuffleOneInputWithDirectVectorTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((double)1, 2, 3, 4, 5, 6, 7, 8), + Vector512.Create((long)7, 6, 5, 4, 3, 2, 1, 0) + ); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((double)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512Int16ShuffleOneInputWithDirectVectorTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((short)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32), + Vector512.Create((short)31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0) + ); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((short)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512Int32ShuffleOneInputWithDirectVectorTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((int)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), + Vector512.Create((int)15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0) + ); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((int)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512Int64ShuffleOneInputWithDirectVectorTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((long)1, 2, 3, 4, 5, 6, 7, 8), + Vector512.Create((long)7, 6, 5, 4, 3, 2, 1, 0) + ); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((long)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512SByteShuffleOneInputWithDirectVectorTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((sbyte)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64), + Vector512.Create((sbyte)63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0) + ); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((sbyte)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512SingleShuffleOneInputWithDirectVectorTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((float)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), + Vector512.Create((int)15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0) + ); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((float)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt16ShuffleOneInputWithDirectVectorTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((ushort)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32), + Vector512.Create((ushort)31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0) + ); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ushort)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt32ShuffleOneInputWithDirectVectorTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((uint)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), + Vector512.Create((uint)15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0) + ); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((uint)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt64ShuffleOneInputWithDirectVectorTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((ulong)1, 2, 3, 4, 5, 6, 7, 8), + Vector512.Create((ulong)7, 6, 5, 4, 3, 2, 1, 0) + ); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ulong)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512ByteShuffleOneInputWithDirectVectorAndNoCross128BitLaneTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((byte)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64), + Vector512.Create((byte)15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48) + ); + + for (int index = 0; index < Vector128.Count; index++) + { + Assert.Equal((byte)(Vector128.Count - index), result.GetElement(index)); + } + + for (int index = Vector128.Count; index < Vector256.Count; index++) + { + Assert.Equal((byte)(Vector256.Count - (index - Vector128.Count)), result.GetElement(index)); + } + + for (int index = Vector256.Count; index < Vector512.Count - Vector128.Count; index++) + { + Assert.Equal((byte)(Vector512.Count - Vector128.Count - (index - Vector256.Count)), result.GetElement(index)); + } + + for (int index = Vector256.Count + Vector128.Count; index < Vector512.Count; index++) + { + Assert.Equal((byte)(Vector512.Count - (index - Vector256.Count - Vector128.Count)), result.GetElement(index)); + } + } + + [Fact] + public void Vector512DoubleShuffleOneInputWithDirectVectorAndNoCross128BitLaneTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((double)1, 2, 3, 4, 5, 6, 7, 8), + Vector512.Create((long)1, 0, 3, 2, 5, 4, 7, 6) + ); + + for (int index = 0; index < Vector128.Count; index++) + { + Assert.Equal((double)(Vector128.Count - index), result.GetElement(index)); + } + + for (int index = Vector128.Count; index < Vector256.Count; index++) + { + Assert.Equal((double)(Vector256.Count - (index - Vector128.Count)), result.GetElement(index)); + } + + for (int index = Vector256.Count; index < Vector512.Count - Vector128.Count; index++) + { + Assert.Equal((double)(Vector512.Count - Vector128.Count - (index - Vector256.Count)), result.GetElement(index)); + } + + for (int index = Vector256.Count + Vector128.Count; index < Vector512.Count; index++) + { + Assert.Equal((double)(Vector512.Count - (index - Vector256.Count - Vector128.Count)), result.GetElement(index)); + } + } + + [Fact] + public void Vector512Int16ShuffleOneInputWithDirectVectorAndNoCross128BitLaneTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((short)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32), + Vector512.Create((short)7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8, 23, 22, 21, 20, 19, 18, 17, 16, 31, 30, 29, 28, 27, 26, 25, 24) + ); + + for (int index = 0; index < Vector128.Count; index++) + { + Assert.Equal((short)(Vector128.Count - index), result.GetElement(index)); + } + + for (int index = Vector128.Count; index < Vector256.Count; index++) + { + Assert.Equal((short)(Vector256.Count - (index - Vector128.Count)), result.GetElement(index)); + } + + for (int index = Vector256.Count; index < Vector512.Count - Vector128.Count; index++) + { + Assert.Equal((short)(Vector512.Count - Vector128.Count - (index - Vector256.Count)), result.GetElement(index)); + } + + for (int index = Vector256.Count + Vector128.Count; index < Vector512.Count; index++) + { + Assert.Equal((short)(Vector512.Count - (index - Vector256.Count - Vector128.Count)), result.GetElement(index)); + } + } + + [Fact] + public void Vector512Int32ShuffleOneInputWithDirectVectorAndNoCross128BitLaneTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((int)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), + Vector512.Create((int)3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12) + ); + + for (int index = 0; index < Vector128.Count; index++) + { + Assert.Equal((int)(Vector128.Count - index), result.GetElement(index)); + } + + for (int index = Vector128.Count; index < Vector256.Count; index++) + { + Assert.Equal((int)(Vector256.Count - (index - Vector128.Count)), result.GetElement(index)); + } + + for (int index = Vector256.Count; index < Vector512.Count - Vector128.Count; index++) + { + Assert.Equal((int)(Vector512.Count - Vector128.Count - (index - Vector256.Count)), result.GetElement(index)); + } + + for (int index = Vector256.Count + Vector128.Count; index < Vector512.Count; index++) + { + Assert.Equal((int)(Vector512.Count - (index - Vector256.Count - Vector128.Count)), result.GetElement(index)); + } + } + + [Fact] + public void Vector512Int64ShuffleOneInputWithDirectVectorAndNoCross128BitLaneTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((long)1, 2, 3, 4, 5, 6, 7, 8), + Vector512.Create((long)1, 0, 3, 2, 5, 4, 7, 6) + ); + + for (int index = 0; index < Vector128.Count; index++) + { + Assert.Equal((long)(Vector128.Count - index), result.GetElement(index)); + } + + for (int index = Vector128.Count; index < Vector256.Count; index++) + { + Assert.Equal((long)(Vector256.Count - (index - Vector128.Count)), result.GetElement(index)); + } + + for (int index = Vector256.Count; index < Vector512.Count - Vector128.Count; index++) + { + Assert.Equal((long)(Vector512.Count - Vector128.Count - (index - Vector256.Count)), result.GetElement(index)); + } + + for (int index = Vector256.Count + Vector128.Count; index < Vector512.Count; index++) + { + Assert.Equal((long)(Vector512.Count - (index - Vector256.Count - Vector128.Count)), result.GetElement(index)); + } + } + + [Fact] + public void Vector512SByteShuffleOneInputWithDirectVectorAndNoCross128BitLaneTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((sbyte)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64), + Vector512.Create((sbyte)15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48) + ); + + for (int index = 0; index < Vector128.Count; index++) + { + Assert.Equal((sbyte)(Vector128.Count - index), result.GetElement(index)); + } + + for (int index = Vector128.Count; index < Vector256.Count; index++) + { + Assert.Equal((sbyte)(Vector256.Count - (index - Vector128.Count)), result.GetElement(index)); + } + + for (int index = Vector256.Count; index < Vector512.Count - Vector128.Count; index++) + { + Assert.Equal((sbyte)(Vector512.Count - Vector128.Count - (index - Vector256.Count)), result.GetElement(index)); + } + + for (int index = Vector256.Count + Vector128.Count; index < Vector512.Count; index++) + { + Assert.Equal((sbyte)(Vector512.Count - (index - Vector256.Count - Vector128.Count)), result.GetElement(index)); + } + } + + [Fact] + public void Vector512SingleShuffleOneInputWithDirectVectorAndNoCross128BitLaneTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((float)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), + Vector512.Create((int)3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12) + ); + + for (int index = 0; index < Vector128.Count; index++) + { + Assert.Equal((float)(Vector128.Count - index), result.GetElement(index)); + } + + for (int index = Vector128.Count; index < Vector256.Count; index++) + { + Assert.Equal((float)(Vector256.Count - (index - Vector128.Count)), result.GetElement(index)); + } + + for (int index = Vector256.Count; index < Vector512.Count - Vector128.Count; index++) + { + Assert.Equal((float)(Vector512.Count - Vector128.Count - (index - Vector256.Count)), result.GetElement(index)); + } + + for (int index = Vector256.Count + Vector128.Count; index < Vector512.Count; index++) + { + Assert.Equal((float)(Vector512.Count - (index - Vector256.Count - Vector128.Count)), result.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt16ShuffleOneInputWithDirectVectorAndNoCross128BitLaneTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((ushort)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32), + Vector512.Create((ushort)7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8, 23, 22, 21, 20, 19, 18, 17, 16, 31, 30, 29, 28, 27, 26, 25, 24) + ); + + for (int index = 0; index < Vector128.Count; index++) + { + Assert.Equal((ushort)(Vector128.Count - index), result.GetElement(index)); + } + + for (int index = Vector128.Count; index < Vector256.Count; index++) + { + Assert.Equal((ushort)(Vector256.Count - (index - Vector128.Count)), result.GetElement(index)); + } + + for (int index = Vector256.Count; index < Vector512.Count - Vector128.Count; index++) + { + Assert.Equal((ushort)(Vector512.Count - Vector128.Count - (index - Vector256.Count)), result.GetElement(index)); + } + + for (int index = Vector256.Count + Vector128.Count; index < Vector512.Count; index++) + { + Assert.Equal((ushort)(Vector512.Count - (index - Vector256.Count - Vector128.Count)), result.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt32ShuffleOneInputWithDirectVectorAndNoCross128BitLaneTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((uint)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), + Vector512.Create((uint)3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12) + ); + + for (int index = 0; index < Vector128.Count; index++) + { + Assert.Equal((uint)(Vector128.Count - index), result.GetElement(index)); + } + + for (int index = Vector128.Count; index < Vector256.Count; index++) + { + Assert.Equal((uint)(Vector256.Count - (index - Vector128.Count)), result.GetElement(index)); + } + + for (int index = Vector256.Count; index < Vector512.Count - Vector128.Count; index++) + { + Assert.Equal((uint)(Vector512.Count - Vector128.Count - (index - Vector256.Count)), result.GetElement(index)); + } + + for (int index = Vector256.Count + Vector128.Count; index < Vector512.Count; index++) + { + Assert.Equal((uint)(Vector512.Count - (index - Vector256.Count - Vector128.Count)), result.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt64ShuffleOneInputWithDirectVectorAndNoCross128BitLaneTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((ulong)1, 2, 3, 4, 5, 6, 7, 8), + Vector512.Create((ulong)1, 0, 3, 2, 5, 4, 7, 6) + ); + + for (int index = 0; index < Vector128.Count; index++) + { + Assert.Equal((ulong)(Vector128.Count - index), result.GetElement(index)); + } + + for (int index = Vector128.Count; index < Vector256.Count; index++) + { + Assert.Equal((ulong)(Vector256.Count - (index - Vector128.Count)), result.GetElement(index)); + } + + for (int index = Vector256.Count; index < Vector512.Count - Vector128.Count; index++) + { + Assert.Equal((ulong)(Vector512.Count - Vector128.Count - (index - Vector256.Count)), result.GetElement(index)); + } + + for (int index = Vector256.Count + Vector128.Count; index < Vector512.Count; index++) + { + Assert.Equal((ulong)(Vector512.Count - (index - Vector256.Count - Vector128.Count)), result.GetElement(index)); + } + } + + [Fact] + public void Vector512ByteShuffleOneInputWithDirectVectorAndNoCross256BitLaneTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((byte)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64), + Vector512.Create((byte)31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32) + ); + + for (int index = 0; index < Vector256.Count; index++) + { + Assert.Equal((byte)(Vector256.Count - index), result.GetElement(index)); + } + + for (int index = Vector256.Count; index < Vector512.Count; index++) + { + Assert.Equal((byte)(Vector512.Count - (index - Vector256.Count)), result.GetElement(index)); + } + } + + [Fact] + public void Vector512DoubleShuffleOneInputWithDirectVectorAndNoCross256BitLaneTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((double)1, 2, 3, 4, 5, 6, 7, 8), + Vector512.Create((long)3, 2, 1, 0, 7, 6, 5, 4) + ); + + for (int index = 0; index < Vector256.Count; index++) + { + Assert.Equal((double)(Vector256.Count - index), result.GetElement(index)); + } + + for (int index = Vector256.Count; index < Vector512.Count; index++) + { + Assert.Equal((double)(Vector512.Count - (index - Vector256.Count)), result.GetElement(index)); + } + } + + [Fact] + public void Vector512Int16ShuffleOneInputWithDirectVectorAndNoCross256BitLaneTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((short)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32), + Vector512.Create((short)15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16) + ); + + for (int index = 0; index < Vector256.Count; index++) + { + Assert.Equal((short)(Vector256.Count - index), result.GetElement(index)); + } + + for (int index = Vector256.Count; index < Vector512.Count; index++) + { + Assert.Equal((short)(Vector512.Count - (index - Vector256.Count)), result.GetElement(index)); + } + } + + [Fact] + public void Vector512Int32ShuffleOneInputWithDirectVectorAndNoCross256BitLaneTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((int)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), + Vector512.Create((int)7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8) + ); + + for (int index = 0; index < Vector256.Count; index++) + { + Assert.Equal((int)(Vector256.Count - index), result.GetElement(index)); + } + + for (int index = Vector256.Count; index < Vector512.Count; index++) + { + Assert.Equal((int)(Vector512.Count - (index - Vector256.Count)), result.GetElement(index)); + } + } + + [Fact] + public void Vector512Int64ShuffleOneInputWithDirectVectorAndNoCross256BitLaneTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((long)1, 2, 3, 4, 5, 6, 7, 8), + Vector512.Create((long)3, 2, 1, 0, 7, 6, 5, 4) + ); + + for (int index = 0; index < Vector256.Count; index++) + { + Assert.Equal((long)(Vector256.Count - index), result.GetElement(index)); + } + + for (int index = Vector256.Count; index < Vector512.Count; index++) + { + Assert.Equal((long)(Vector512.Count - (index - Vector256.Count)), result.GetElement(index)); + } + } + + [Fact] + public void Vector512SByteShuffleOneInputWithDirectVectorAndNoCross256BitLaneTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((sbyte)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64), + Vector512.Create((sbyte)31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32) + ); + + for (int index = 0; index < Vector256.Count; index++) + { + Assert.Equal((sbyte)(Vector256.Count - index), result.GetElement(index)); + } + + for (int index = Vector256.Count; index < Vector512.Count; index++) + { + Assert.Equal((sbyte)(Vector512.Count - (index - Vector256.Count)), result.GetElement(index)); + } + } + + [Fact] + public void Vector512SingleShuffleOneInputWithDirectVectorAndNoCross256BitLaneTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((float)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), + Vector512.Create((int)7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8) + ); + + for (int index = 0; index < Vector256.Count; index++) + { + Assert.Equal((float)(Vector256.Count - index), result.GetElement(index)); + } + + for (int index = Vector256.Count; index < Vector512.Count; index++) + { + Assert.Equal((float)(Vector512.Count - (index - Vector256.Count)), result.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt16ShuffleOneInputWithDirectVectorAndNoCross256BitLaneTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((ushort)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32), + Vector512.Create((ushort)15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16) + ); + + for (int index = 0; index < Vector256.Count; index++) + { + Assert.Equal((ushort)(Vector256.Count - index), result.GetElement(index)); + } + + for (int index = Vector256.Count; index < Vector512.Count; index++) + { + Assert.Equal((ushort)(Vector512.Count - (index - Vector256.Count)), result.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt32ShuffleOneInputWithDirectVectorAndNoCross256BitLaneTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((uint)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), + Vector512.Create((uint)7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8) + ); + + for (int index = 0; index < Vector256.Count; index++) + { + Assert.Equal((uint)(Vector256.Count - index), result.GetElement(index)); + } + + for (int index = Vector256.Count; index < Vector512.Count; index++) + { + Assert.Equal((uint)(Vector512.Count - (index - Vector256.Count)), result.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt64ShuffleOneInputWithDirectVectorAndNoCross256BitLaneTest() + { + Vector512 result = Vector512.Shuffle( + Vector512.Create((ulong)1, 2, 3, 4, 5, 6, 7, 8), + Vector512.Create((ulong)3, 2, 1, 0, 7, 6, 5, 4) + ); + + for (int index = 0; index < Vector256.Count; index++) + { + Assert.Equal((ulong)(Vector256.Count - index), result.GetElement(index)); + } + + for (int index = Vector256.Count; index < Vector512.Count; index++) + { + Assert.Equal((ulong)(Vector512.Count - (index - Vector256.Count)), result.GetElement(index)); + } + } + + [Fact] + public void Vector512ByteShuffleOneInputWithLocalIndicesTest() + { + Vector512 vector = Vector512.Create((byte)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64); + Vector512 indices = Vector512.Create((byte)63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); + Vector512 result = Vector512.Shuffle(vector, indices); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((byte)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512DoubleShuffleOneInputWithLocalIndicesTest() + { + Vector512 vector = Vector512.Create((double)1, 2, 3, 4, 5, 6, 7, 8); + Vector512 indices = Vector512.Create((long)7, 6, 5, 4, 3, 2, 1, 0); + Vector512 result = Vector512.Shuffle(vector, indices); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((double)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512Int16ShuffleOneInputWithLocalIndicesTest() + { + Vector512 vector = Vector512.Create((short)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32); + Vector512 indices = Vector512.Create((short)31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); + Vector512 result = Vector512.Shuffle(vector, indices); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((short)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512Int32ShuffleOneInputWithLocalIndicesTest() + { + Vector512 vector = Vector512.Create((int)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); + Vector512 indices = Vector512.Create((int)15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); + Vector512 result = Vector512.Shuffle(vector, indices); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((int)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512Int64ShuffleOneInputWithLocalIndicesTest() + { + Vector512 vector = Vector512.Create((long)1, 2, 3, 4, 5, 6, 7, 8); + Vector512 indices = Vector512.Create((long)7, 6, 5, 4, 3, 2, 1, 0); + Vector512 result = Vector512.Shuffle(vector, indices); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((long)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512SByteShuffleOneInputWithLocalIndicesTest() + { + Vector512 vector = Vector512.Create((sbyte)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64); + Vector512 indices = Vector512.Create((sbyte)63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); + Vector512 result = Vector512.Shuffle(vector, indices); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((sbyte)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512SingleShuffleOneInputWithLocalIndicesTest() + { + Vector512 vector = Vector512.Create((float)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); + Vector512 indices = Vector512.Create((int)15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); + Vector512 result = Vector512.Shuffle(vector, indices); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((float)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt16ShuffleOneInputWithLocalIndicesTest() + { + Vector512 vector = Vector512.Create((ushort)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32); + Vector512 indices = Vector512.Create((ushort)31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); + Vector512 result = Vector512.Shuffle(vector, indices); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ushort)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt32ShuffleOneInputWithLocalIndicesTest() + { + Vector512 vector = Vector512.Create((uint)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); + Vector512 indices = Vector512.Create((uint)15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); + Vector512 result = Vector512.Shuffle(vector, indices); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((uint)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt64ShuffleOneInputWithLocalIndicesTest() + { + Vector512 vector = Vector512.Create((ulong)1, 2, 3, 4, 5, 6, 7, 8); + Vector512 indices = Vector512.Create((ulong)7, 6, 5, 4, 3, 2, 1, 0); + Vector512 result = Vector512.Shuffle(vector, indices); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ulong)(Vector512.Count - index), result.GetElement(index)); + } + } + + [Fact] + public void Vector512ByteShuffleOneInputWithAllBitsSetIndicesTest() + { + Vector512 vector = Vector512.Create((byte)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64); + Vector512 result = Vector512.Shuffle(vector, Vector512.AllBitsSet); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((byte)0, result.GetElement(index)); + } + } + + [Fact] + public void Vector512DoubleShuffleOneInputWithAllBitsSetIndicesTest() + { + Vector512 vector = Vector512.Create((double)1, 2, 3, 4, 5, 6, 7, 8); + Vector512 result = Vector512.Shuffle(vector, Vector512.AllBitsSet); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((double)0, result.GetElement(index)); + } + } + + [Fact] + public void Vector512Int16ShuffleOneInputWithAllBitsSetIndicesTest() + { + Vector512 vector = Vector512.Create((short)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32); + Vector512 result = Vector512.Shuffle(vector, Vector512.AllBitsSet); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((short)0, result.GetElement(index)); + } + } + + [Fact] + public void Vector512Int32ShuffleOneInputWithAllBitsSetIndicesTest() + { + Vector512 vector = Vector512.Create((int)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); + Vector512 result = Vector512.Shuffle(vector, Vector512.AllBitsSet); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((int)0, result.GetElement(index)); + } + } + + [Fact] + public void Vector512Int64ShuffleOneInputWithAllBitsSetIndicesTest() + { + Vector512 vector = Vector512.Create((long)1, 2, 3, 4, 5, 6, 7, 8); + Vector512 result = Vector512.Shuffle(vector, Vector512.AllBitsSet); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((long)0, result.GetElement(index)); + } + } + + [Fact] + public void Vector512SByteShuffleOneInputWithAllBitsSetIndicesTest() + { + Vector512 vector = Vector512.Create((sbyte)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64); + Vector512 result = Vector512.Shuffle(vector, Vector512.AllBitsSet); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((sbyte)0, result.GetElement(index)); + } + } + + [Fact] + public void Vector512SingleShuffleOneInputWithAllBitsSetIndicesTest() + { + Vector512 vector = Vector512.Create((float)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); + Vector512 result = Vector512.Shuffle(vector, Vector512.AllBitsSet); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((float)0, result.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt16ShuffleOneInputWithAllBitsSetIndicesTest() + { + Vector512 vector = Vector512.Create((ushort)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32); + Vector512 result = Vector512.Shuffle(vector, Vector512.AllBitsSet); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ushort)0, result.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt32ShuffleOneInputWithAllBitsSetIndicesTest() + { + Vector512 vector = Vector512.Create((uint)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); + Vector512 result = Vector512.Shuffle(vector, Vector512.AllBitsSet); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((uint)0, result.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt64ShuffleOneInputWithAllBitsSetIndicesTest() + { + Vector512 vector = Vector512.Create((ulong)1, 2, 3, 4, 5, 6, 7, 8); + Vector512 result = Vector512.Shuffle(vector, Vector512.AllBitsSet); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ulong)0, result.GetElement(index)); + } + } + + [Fact] + public void Vector512ByteShuffleOneInputWithZeroIndicesTest() + { + Vector512 vector = Vector512.Create((byte)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64); + Vector512 result = Vector512.Shuffle(vector, Vector512.Zero); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((byte)1, result.GetElement(index)); + } + } + + [Fact] + public void Vector512DoubleShuffleOneInputWithZeroIndicesTest() + { + Vector512 vector = Vector512.Create((double)1, 2, 3, 4, 5, 6, 7, 8); + Vector512 result = Vector512.Shuffle(vector, Vector512.Zero); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((double)1, result.GetElement(index)); + } + } + + [Fact] + public void Vector512Int16ShuffleOneInputWithZeroIndicesTest() + { + Vector512 vector = Vector512.Create((short)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32); + Vector512 result = Vector512.Shuffle(vector, Vector512.Zero); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((short)1, result.GetElement(index)); + } + } + + [Fact] + public void Vector512Int32ShuffleOneInputWithZeroIndicesTest() + { + Vector512 vector = Vector512.Create((int)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); + Vector512 result = Vector512.Shuffle(vector, Vector512.Zero); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((int)1, result.GetElement(index)); + } + } + + [Fact] + public void Vector512Int64ShuffleOneInputWithZeroIndicesTest() + { + Vector512 vector = Vector512.Create((long)1, 2, 3, 4, 5, 6, 7, 8); + Vector512 result = Vector512.Shuffle(vector, Vector512.Zero); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((long)1, result.GetElement(index)); + } + } + + [Fact] + public void Vector512SByteShuffleOneInputWithZeroIndicesTest() + { + Vector512 vector = Vector512.Create((sbyte)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64); + Vector512 result = Vector512.Shuffle(vector, Vector512.Zero); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((sbyte)1, result.GetElement(index)); + } + } + + [Fact] + public void Vector512SingleShuffleOneInputWithZeroIndicesTest() + { + Vector512 vector = Vector512.Create((float)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); + Vector512 result = Vector512.Shuffle(vector, Vector512.Zero); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((float)1, result.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt16ShuffleOneInputWithZeroIndicesTest() + { + Vector512 vector = Vector512.Create((ushort)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32); + Vector512 result = Vector512.Shuffle(vector, Vector512.Zero); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ushort)1, result.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt32ShuffleOneInputWithZeroIndicesTest() + { + Vector512 vector = Vector512.Create((uint)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); + Vector512 result = Vector512.Shuffle(vector, Vector512.Zero); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((uint)1, result.GetElement(index)); + } + } + + [Fact] + public void Vector512UInt64ShuffleOneInputWithZeroIndicesTest() + { + Vector512 vector = Vector512.Create((ulong)1, 2, 3, 4, 5, 6, 7, 8); + Vector512 result = Vector512.Shuffle(vector, Vector512.Zero); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ulong)1, result.GetElement(index)); + } + } + + [Fact] + public unsafe void Vector512ByteStoreTest() + { + byte* value = stackalloc byte[64]; + + for (int index = 0; index < 64; index++) + { + value[index] = (byte)(index); + } + + Vector512.Create((byte)0x1).Store(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((byte)0x1, value[index]); + } + } + + [Fact] + public unsafe void Vector512DoubleStoreTest() + { + double* value = stackalloc double[8]; + + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + + Vector512.Create((double)0x1).Store(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((double)0x1, value[index]); + } + } + + [Fact] + public unsafe void Vector512Int16StoreTest() + { + short* value = stackalloc short[32]; + + for (int index = 0; index < 32; index++) + { + value[index] = (short)(index); + } + + Vector512.Create((short)0x1).Store(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((short)0x1, value[index]); + } + } + + [Fact] + public unsafe void Vector512Int32StoreTest() + { + int* value = stackalloc int[16]; + + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + + Vector512.Create((int)0x1).Store(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((int)0x1, value[index]); + } + } + + [Fact] + public unsafe void Vector512Int64StoreTest() + { + long* value = stackalloc long[8]; + + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + + Vector512.Create((long)0x1).Store(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((long)0x1, value[index]); + } + } + + [Fact] + public unsafe void Vector512NIntStoreTest() + { + if (Environment.Is64BitProcess) + { + nint* value = stackalloc nint[8]; + + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + + Vector512.Create((nint)0x1).Store(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nint)0x1, value[index]); + } + } + else + { + nint* value = stackalloc nint[16]; + + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + + Vector512.Create((nint)0x1).Store(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nint)0x1, value[index]); + } + } + } + + [Fact] + public unsafe void Vector512NUIntStoreTest() + { + if (Environment.Is64BitProcess) + { + nuint* value = stackalloc nuint[8]; + + for (int index = 0; index < 8; index++) + { + value[index] = (nuint)(index); + } + + Vector512.Create((nuint)0x1).Store(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nuint)0x1, value[index]); + } + } + else + { + nuint* value = stackalloc nuint[16]; + + for (int index = 0; index < 16; index++) + { + value[index] = (nuint)(index); + } + + Vector512.Create((nuint)0x1).Store(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nuint)0x1, value[index]); + } + } + } + + [Fact] + public unsafe void Vector512SByteStoreTest() + { + sbyte* value = stackalloc sbyte[64]; + + for (int index = 0; index < 64; index++) + { + value[index] = (sbyte)(index); + } + + Vector512.Create((sbyte)0x1).Store(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((sbyte)0x1, value[index]); + } + } + + [Fact] + public unsafe void Vector512SingleStoreTest() + { + float* value = stackalloc float[16]; + + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + + Vector512.Create((float)0x1).Store(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((float)0x1, value[index]); + } + } + + [Fact] + public unsafe void Vector512UInt16StoreTest() + { + ushort* value = stackalloc ushort[32]; + + for (int index = 0; index < 32; index++) + { + value[index] = (ushort)(index); + } + + Vector512.Create((ushort)0x1).Store(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ushort)0x1, value[index]); + } + } + + [Fact] + public unsafe void Vector512UInt32StoreTest() + { + uint* value = stackalloc uint[16]; + + for (int index = 0; index < 16; index++) + { + value[index] = (uint)(index); + } + + Vector512.Create((uint)0x1).Store(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((uint)0x1, value[index]); + } + } + + [Fact] + public unsafe void Vector512UInt64StoreTest() + { + ulong* value = stackalloc ulong[8]; + + for (int index = 0; index < 8; index++) + { + value[index] = (ulong)(index); + } + + Vector512.Create((ulong)0x1).Store(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ulong)0x1, value[index]); + } + } + + [Fact] + public unsafe void Vector512ByteStoreAlignedTest() + { + byte* value = null; + + try + { + value = (byte*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 64; index++) + { + value[index] = (byte)(index); + } + + Vector512.Create((byte)0x1).StoreAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((byte)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512DoubleStoreAlignedTest() + { + double* value = null; + + try + { + value = (double*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + + Vector512.Create((double)0x1).StoreAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((double)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512Int16StoreAlignedTest() + { + short* value = null; + + try + { + value = (short*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 32; index++) + { + value[index] = (short)(index); + } + + Vector512.Create((short)0x1).StoreAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((short)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512Int32StoreAlignedTest() + { + int* value = null; + + try + { + value = (int*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + + Vector512.Create((int)0x1).StoreAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((int)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512Int64StoreAlignedTest() + { + long* value = null; + + try + { + value = (long*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + + Vector512.Create((long)0x1).StoreAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((long)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512NIntStoreAlignedTest() + { + nint* value = null; + + try + { + value = (nint*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + if (Environment.Is64BitProcess) + { + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + } + else + { + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + } + + Vector512.Create((nint)0x1).StoreAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nint)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512NUIntStoreAlignedTest() + { + nuint* value = null; + + try + { + value = (nuint*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + if (Environment.Is64BitProcess) + { + for (int index = 0; index < 8; index++) + { + value[index] = (nuint)(index); + } + } + else + { + for (int index = 0; index < 16; index++) + { + value[index] = (nuint)(index); + } + } + + Vector512.Create((nuint)0x1).StoreAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nuint)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512SByteStoreAlignedTest() + { + sbyte* value = null; + + try + { + value = (sbyte*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 64; index++) + { + value[index] = (sbyte)(index); + } + + Vector512.Create((sbyte)0x1).StoreAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((sbyte)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512SingleStoreAlignedTest() + { + float* value = null; + + try + { + value = (float*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + + Vector512.Create((float)0x1).StoreAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((float)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512UInt16StoreAlignedTest() + { + ushort* value = null; + + try + { + value = (ushort*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 32; index++) + { + value[index] = (ushort)(index); + } + + Vector512.Create((ushort)0x1).StoreAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ushort)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512UInt32StoreAlignedTest() + { + uint* value = null; + + try + { + value = (uint*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 16; index++) + { + value[index] = (uint)(index); + } + + Vector512.Create((uint)0x1).StoreAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((uint)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512UInt64StoreAlignedTest() + { + ulong* value = null; + + try + { + value = (ulong*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 8; index++) + { + value[index] = (ulong)(index); + } + + Vector512.Create((ulong)0x1).StoreAligned(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ulong)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512ByteStoreAlignedNonTemporalTest() + { + byte* value = null; + + try + { + value = (byte*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 64; index++) + { + value[index] = (byte)(index); + } + + Vector512.Create((byte)0x1).StoreAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((byte)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512DoubleStoreAlignedNonTemporalTest() + { + double* value = null; + + try + { + value = (double*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + + Vector512.Create((double)0x1).StoreAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((double)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512Int16StoreAlignedNonTemporalTest() + { + short* value = null; + + try + { + value = (short*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 32; index++) + { + value[index] = (short)(index); + } + + Vector512.Create((short)0x1).StoreAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((short)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512Int32StoreAlignedNonTemporalTest() + { + int* value = null; + + try + { + value = (int*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + + Vector512.Create((int)0x1).StoreAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((int)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512Int64StoreAlignedNonTemporalTest() + { + long* value = null; + + try + { + value = (long*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + + Vector512.Create((long)0x1).StoreAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((long)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512NIntStoreAlignedNonTemporalTest() + { + nint* value = null; + + try + { + value = (nint*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + if (Environment.Is64BitProcess) + { + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + } + else + { + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + } + + Vector512.Create((nint)0x1).StoreAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nint)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512NUIntStoreAlignedNonTemporalTest() + { + nuint* value = null; + + try + { + value = (nuint*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + if (Environment.Is64BitProcess) + { + for (int index = 0; index < 8; index++) + { + value[index] = (nuint)(index); + } + } + else + { + for (int index = 0; index < 16; index++) + { + value[index] = (nuint)(index); + } + } + + Vector512.Create((nuint)0x1).StoreAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nuint)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512SByteStoreAlignedNonTemporalTest() + { + sbyte* value = null; + + try + { + value = (sbyte*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 64; index++) + { + value[index] = (sbyte)(index); + } + + Vector512.Create((sbyte)0x1).StoreAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((sbyte)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512SingleStoreAlignedNonTemporalTest() + { + float* value = null; + + try + { + value = (float*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + + Vector512.Create((float)0x1).StoreAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((float)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512UInt16StoreAlignedNonTemporalTest() + { + ushort* value = null; + + try + { + value = (ushort*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 32; index++) + { + value[index] = (ushort)(index); + } + + Vector512.Create((ushort)0x1).StoreAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ushort)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512UInt32StoreAlignedNonTemporalTest() + { + uint* value = null; + + try + { + value = (uint*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 16; index++) + { + value[index] = (uint)(index); + } + + Vector512.Create((uint)0x1).StoreAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((uint)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512UInt64StoreAlignedNonTemporalTest() + { + ulong* value = null; + + try + { + value = (ulong*)NativeMemory.AlignedAlloc(byteCount: 64, alignment: 64); + + for (int index = 0; index < 8; index++) + { + value[index] = (ulong)(index); + } + + Vector512.Create((ulong)0x1).StoreAlignedNonTemporal(value); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ulong)0x1, value[index]); + } + } + finally + { + NativeMemory.AlignedFree(value); + } + } + + [Fact] + public unsafe void Vector512ByteStoreUnsafeTest() + { + byte* value = stackalloc byte[64]; + + for (int index = 0; index < 64; index++) + { + value[index] = (byte)(index); + } + + Vector512.Create((byte)0x1).StoreUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((byte)0x1, value[index]); + } + } + + [Fact] + public unsafe void Vector512DoubleStoreUnsafeTest() + { + double* value = stackalloc double[8]; + + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + + Vector512.Create((double)0x1).StoreUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((double)0x1, value[index]); + } + } + + [Fact] + public unsafe void Vector512Int16StoreUnsafeTest() + { + short* value = stackalloc short[32]; + + for (int index = 0; index < 32; index++) + { + value[index] = (short)(index); + } + + Vector512.Create((short)0x1).StoreUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((short)0x1, value[index]); + } + } + + [Fact] + public unsafe void Vector512Int32StoreUnsafeTest() + { + int* value = stackalloc int[16]; + + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + + Vector512.Create((int)0x1).StoreUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((int)0x1, value[index]); + } + } + + [Fact] + public unsafe void Vector512Int64StoreUnsafeTest() + { + long* value = stackalloc long[8]; + + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + + Vector512.Create((long)0x1).StoreUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((long)0x1, value[index]); + } + } + + [Fact] + public unsafe void Vector512NIntStoreUnsafeTest() + { + if (Environment.Is64BitProcess) + { + nint* value = stackalloc nint[8]; + + for (int index = 0; index < 8; index++) + { + value[index] = index; + } + + Vector512.Create((nint)0x1).StoreUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nint)0x1, value[index]); + } + } + else + { + nint* value = stackalloc nint[16]; + + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + + Vector512.Create((nint)0x1).StoreUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nint)0x1, value[index]); + } + } + } + + [Fact] + public unsafe void Vector512NUIntStoreUnsafeTest() + { + if (Environment.Is64BitProcess) + { + nuint* value = stackalloc nuint[8]; + + for (int index = 0; index < 8; index++) + { + value[index] = (nuint)(index); + } + + Vector512.Create((nuint)0x1).StoreUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nuint)0x1, value[index]); + } + } + else + { + nuint* value = stackalloc nuint[16]; + + for (int index = 0; index < 16; index++) + { + value[index] = (nuint)(index); + } + + Vector512.Create((nuint)0x1).StoreUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nuint)0x1, value[index]); + } + } + } + + [Fact] + public unsafe void Vector512SByteStoreUnsafeTest() + { + sbyte* value = stackalloc sbyte[64]; + + for (int index = 0; index < 64; index++) + { + value[index] = (sbyte)(index); + } + + Vector512.Create((sbyte)0x1).StoreUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((sbyte)0x1, value[index]); + } + } + + [Fact] + public unsafe void Vector512SingleStoreUnsafeTest() + { + float* value = stackalloc float[16]; + + for (int index = 0; index < 16; index++) + { + value[index] = index; + } + + Vector512.Create((float)0x1).StoreUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((float)0x1, value[index]); + } + } + + [Fact] + public unsafe void Vector512UInt16StoreUnsafeTest() + { + ushort* value = stackalloc ushort[32]; + + for (int index = 0; index < 32; index++) + { + value[index] = (ushort)(index); + } + + Vector512.Create((ushort)0x1).StoreUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ushort)0x1, value[index]); + } + } + + [Fact] + public unsafe void Vector512UInt32StoreUnsafeTest() + { + uint* value = stackalloc uint[16]; + + for (int index = 0; index < 16; index++) + { + value[index] = (uint)(index); + } + + Vector512.Create((uint)0x1).StoreUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((uint)0x1, value[index]); + } + } + + [Fact] + public unsafe void Vector512UInt64StoreUnsafeTest() + { + ulong* value = stackalloc ulong[8]; + + for (int index = 0; index < 8; index++) + { + value[index] = (ulong)(index); + } + + Vector512.Create((ulong)0x1).StoreUnsafe(ref value[0]); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ulong)0x1, value[index]); + } + } + + [Fact] + public unsafe void Vector512ByteStoreUnsafeIndexTest() + { + byte* value = stackalloc byte[64 + 1]; + + for (int index = 0; index < 64 + 1; index++) + { + value[index] = (byte)(index); + } + + Vector512.Create((byte)0x1).StoreUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((byte)0x1, value[index + 1]); + } + } + + [Fact] + public unsafe void Vector512DoubleStoreUnsafeIndexTest() + { + double* value = stackalloc double[8 + 1]; + + for (int index = 0; index < 8 + 1; index++) + { + value[index] = index; + } + + Vector512.Create((double)0x1).StoreUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((double)0x1, value[index + 1]); + } + } + + [Fact] + public unsafe void Vector512Int16StoreUnsafeIndexTest() + { + short* value = stackalloc short[32 + 1]; + + for (int index = 0; index < 32 + 1; index++) + { + value[index] = (short)(index); + } + + Vector512.Create((short)0x1).StoreUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((short)0x1, value[index + 1]); + } + } + + [Fact] + public unsafe void Vector512Int32StoreUnsafeIndexTest() + { + int* value = stackalloc int[16 + 1]; + + for (int index = 0; index < 16 + 1; index++) + { + value[index] = index; + } + + Vector512.Create((int)0x1).StoreUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((int)0x1, value[index + 1]); + } + } + + [Fact] + public unsafe void Vector512Int64StoreUnsafeIndexTest() + { + long* value = stackalloc long[8 + 1]; + + for (int index = 0; index < 8 + 1; index++) + { + value[index] = index; + } + + Vector512.Create((long)0x1).StoreUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((long)0x1, value[index + 1]); + } + } + + [Fact] + public unsafe void Vector512NIntStoreUnsafeIndexTest() + { + if (Environment.Is64BitProcess) + { + nint* value = stackalloc nint[8 + 1]; + + for (int index = 0; index < 8 + 1; index++) + { + value[index] = index; + } + + Vector512.Create((nint)0x1).StoreUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nint)0x1, value[index + 1]); + } + } + else + { + nint* value = stackalloc nint[16 + 1]; + + for (int index = 0; index < 16 + 1; index++) + { + value[index] = index; + } + + Vector512.Create((nint)0x1).StoreUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nint)0x1, value[index + 1]); + } + } + } + + [Fact] + public unsafe void Vector512NUIntStoreUnsafeIndexTest() + { + if (Environment.Is64BitProcess) + { + nuint* value = stackalloc nuint[8 + 1]; + + for (int index = 0; index < 8 + 1; index++) + { + value[index] = (nuint)(index); + } + + Vector512.Create((nuint)0x1).StoreUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nuint)0x1, value[index + 1]); + } + } + else + { + nuint* value = stackalloc nuint[16 + 1]; + + for (int index = 0; index < 16 + 1; index++) + { + value[index] = (nuint)(index); + } + + Vector512.Create((nuint)0x1).StoreUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((nuint)0x1, value[index + 1]); + } + } + } + + [Fact] + public unsafe void Vector512SByteStoreUnsafeIndexTest() + { + sbyte* value = stackalloc sbyte[64 + 1]; + + for (int index = 0; index < 64 + 1; index++) + { + value[index] = (sbyte)(index); + } + + Vector512.Create((sbyte)0x1).StoreUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((sbyte)0x1, value[index + 1]); + } + } + + [Fact] + public unsafe void Vector512SingleStoreUnsafeIndexTest() + { + float* value = stackalloc float[16 + 1]; + + for (int index = 0; index < 16 + 1; index++) + { + value[index] = index; + } + + Vector512.Create((float)0x1).StoreUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((float)0x1, value[index + 1]); + } + } + + [Fact] + public unsafe void Vector512UInt16StoreUnsafeIndexTest() + { + ushort* value = stackalloc ushort[32 + 1]; + + for (int index = 0; index < 32 + 1; index++) + { + value[index] = (ushort)(index); + } + + Vector512.Create((ushort)0x1).StoreUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ushort)0x1, value[index + 1]); + } + } + + [Fact] + public unsafe void Vector512UInt32StoreUnsafeIndexTest() + { + uint* value = stackalloc uint[16 + 1]; + + for (int index = 0; index < 16 + 1; index++) + { + value[index] = (uint)(index); + } + + Vector512.Create((uint)0x1).StoreUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((uint)0x1, value[index + 1]); + } + } + + [Fact] + public unsafe void Vector512UInt64StoreUnsafeIndexTest() + { + ulong* value = stackalloc ulong[8 + 1]; + + for (int index = 0; index < 8 + 1; index++) + { + value[index] = (ulong)(index); + } + + Vector512.Create((ulong)0x1).StoreUnsafe(ref value[0], 1); + + for (int index = 0; index < Vector512.Count; index++) + { + Assert.Equal((ulong)0x1, value[index + 1]); + } + } + + [Fact] + public void Vector512ByteSumTest() + { + Vector512 vector = Vector512.Create((byte)0x01); + Assert.Equal((byte)64, Vector512.Sum(vector)); + } + + [Fact] + public void Vector512DoubleSumTest() + { + Vector512 vector = Vector512.Create((double)0x01); + Assert.Equal(8.0, Vector512.Sum(vector)); + } + + [Fact] + public void Vector512Int16SumTest() + { + Vector512 vector = Vector512.Create((short)0x01); + Assert.Equal((short)32, Vector512.Sum(vector)); + } + + [Fact] + public void Vector512Int32SumTest() + { + Vector512 vector = Vector512.Create((int)0x01); + Assert.Equal((int)16, Vector512.Sum(vector)); + } + + [Fact] + public void Vector512Int64SumTest() + { + Vector512 vector = Vector512.Create((long)0x01); + Assert.Equal((long)8, Vector512.Sum(vector)); + } + + [Fact] + public void Vector512NIntSumTest() + { + Vector512 vector = Vector512.Create((nint)0x01); + + if (Environment.Is64BitProcess) + { + Assert.Equal((nint)8, Vector512.Sum(vector)); + } + else + { + Assert.Equal((nint)16, Vector512.Sum(vector)); + } + } + + [Fact] + public void Vector512NUIntSumTest() + { + Vector512 vector = Vector512.Create((nuint)0x01); + + if (Environment.Is64BitProcess) + { + Assert.Equal((nuint)8, Vector512.Sum(vector)); + } + else + { + Assert.Equal((nuint)16, Vector512.Sum(vector)); + } + } + + [Fact] + public void Vector512SByteSumTest() + { + Vector512 vector = Vector512.Create((sbyte)0x01); + Assert.Equal((sbyte)64, Vector512.Sum(vector)); + } + + [Fact] + public void Vector512SingleSumTest() + { + Vector512 vector = Vector512.Create((float)0x01); + Assert.Equal(16.0f, Vector512.Sum(vector)); + } + + [Fact] + public void Vector512UInt16SumTest() + { + Vector512 vector = Vector512.Create((ushort)0x01); + Assert.Equal((ushort)32, Vector512.Sum(vector)); + } + + [Fact] + public void Vector512UInt32SumTest() + { + Vector512 vector = Vector512.Create((uint)0x01); + Assert.Equal((uint)16, Vector512.Sum(vector)); + } + + [Fact] + public void Vector512UInt64SumTest() + { + Vector512 vector = Vector512.Create((ulong)0x01); + Assert.Equal((ulong)8, Vector512.Sum(vector)); + } + + [Theory] + [InlineData(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)] + [InlineData(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)] + [InlineData(-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1)] + [InlineData(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)] + [InlineData(0, 0, 50, 430, -64, 0, int.MaxValue, int.MinValue, 0, 0, 50, 430, -64, 0, int.MaxValue, int.MinValue)] + public void Vector512Int32IndexerTest(params int[] values) + { + var vector = Vector512.Create(values); + + Assert.Equal(vector[0], values[0]); + Assert.Equal(vector[1], values[1]); + Assert.Equal(vector[2], values[2]); + Assert.Equal(vector[3], values[3]); + Assert.Equal(vector[4], values[4]); + Assert.Equal(vector[5], values[5]); + Assert.Equal(vector[6], values[6]); + Assert.Equal(vector[7], values[7]); + } + + [Theory] + [InlineData(0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L)] + [InlineData(1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L)] + [InlineData(0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L)] + [InlineData(0L, 0L, 50L, 430L, -64L, 0L, long.MaxValue, long.MinValue)] + public void Vector512Int64IndexerTest(params long[] values) + { + var vector = Vector512.Create(values); + + Assert.Equal(vector[0], values[0]); + Assert.Equal(vector[1], values[1]); + Assert.Equal(vector[2], values[2]); + Assert.Equal(vector[3], values[3]); + } + + [Fact] + public void Vector512DoubleEqualsNaNTest() + { + Vector512 nan = Vector512.Create(double.NaN); + Assert.True(nan.Equals(nan)); + } + + [Fact] + public void Vector512SingleEqualsNaNTest() + { + Vector512 nan = Vector512.Create(float.NaN); + Assert.True(nan.Equals(nan)); + } + + [Fact] + public void Vector512DoubleEqualsNonCanonicalNaNTest() + { + // max 8 bit exponent, just under half max mantissa + var snan = BitConverter.UInt64BitsToDouble(0x7FF7_FFFF_FFFF_FFFF); + var nans = new double[] + { + double.CopySign(double.NaN, -0.0), // -qnan same as double.NaN + double.CopySign(double.NaN, +0.0), // +qnan + double.CopySign(snan, -0.0), // -snan + double.CopySign(snan, +0.0), // +snan + }; + + // all Vector NaNs .Equals compare the same, but == compare as different + foreach(var i in nans) + { + foreach(var j in nans) + { + Assert.True(Vector512.Create(i).Equals(Vector512.Create(j))); + Assert.False(Vector512.Create(i) == Vector512.Create(j)); + } + } + } + + [Fact] + public void Vector512SingleEqualsNonCanonicalNaNTest() + { + // max 11 bit exponent, just under half max mantissa + var snan = BitConverter.UInt32BitsToSingle(0x7FBF_FFFF); + var nans = new float[] + { + float.CopySign(float.NaN, -0.0f), // -qnan same as float.NaN + float.CopySign(float.NaN, +0.0f), // +qnan + float.CopySign(snan, -0.0f), // -snan + float.CopySign(snan, +0.0f), // +snan + }; + + // all Vector NaNs .Equals compare the same, but == compare as different + foreach(var i in nans) + { + foreach(var j in nans) + { + Assert.True(Vector512.Create(i).Equals(Vector512.Create(j))); + Assert.False(Vector512.Create(i) == Vector512.Create(j)); + } + } + } + + [Fact] + public void IsSupportedByte() => TestIsSupported(); + + [Fact] + public void IsSupportedDouble() => TestIsSupported(); + + [Fact] + public void IsSupportedInt16() => TestIsSupported(); + + [Fact] + public void IsSupportedInt32() => TestIsSupported(); + + [Fact] + public void IsSupportedInt64() => TestIsSupported(); + + [Fact] + public void IsSupportedIntPtr() => TestIsSupported(); + + [Fact] + public void IsSupportedSByte() => TestIsSupported(); + + [Fact] + public void IsSupportedSingle() => TestIsSupported(); + + [Fact] + public void IsSupportedUInt16() => TestIsSupported(); + + [Fact] + public void IsSupportedUInt32() => TestIsSupported(); + + [Fact] + public void IsSupportedUInt64() => TestIsSupported(); + + [Fact] + public void IsSupportedUIntPtr() => TestIsSupported(); + + private static void TestIsSupported() + where T : struct + { + Assert.True(Vector512.IsSupported); + + MethodInfo methodInfo = typeof(Vector512).GetProperty("IsSupported", BindingFlags.Public | BindingFlags.Static).GetMethod; + Assert.True((bool)methodInfo.Invoke(null, null)); + } + + [Fact] + public void IsNotSupportedBoolean() => TestIsNotSupported(); + + [Fact] + public void IsNotSupportedChar() => TestIsNotSupported(); + + [Fact] + public void IsNotSupportedHalf() => TestIsNotSupported(); + + [Fact] + public void IsNotSupportedInt128() => TestIsNotSupported(); + + [Fact] + public void IsNotSupportedUInt128() => TestIsNotSupported(); + + private static void TestIsNotSupported() + where T : struct + { + Assert.False(Vector512.IsSupported); + + MethodInfo methodInfo = typeof(Vector512).GetProperty("IsSupported", BindingFlags.Public | BindingFlags.Static).GetMethod; + Assert.False((bool)methodInfo.Invoke(null, null)); + } + } +} diff --git a/src/mono/mono/mini/mini-llvm.c b/src/mono/mono/mini/mini-llvm.c index 1995584833fd0..9201232fc861d 100644 --- a/src/mono/mono/mini/mini-llvm.c +++ b/src/mono/mono/mini/mini-llvm.c @@ -646,7 +646,7 @@ simd_class_to_llvm_type (EmitContext *ctx, MonoClass *klass) return LLVMVectorType (LLVMFloatType (), 4); } else if (!strcmp (klass_name, "Vector4")) { return LLVMVectorType (LLVMFloatType (), 4); - } else if (!strcmp (klass_name, "Vector`1") || !strcmp (klass_name, "Vector64`1") || !strcmp (klass_name, "Vector128`1") || !strcmp (klass_name, "Vector256`1")) { + } else if (!strcmp (klass_name, "Vector`1") || !strcmp (klass_name, "Vector64`1") || !strcmp (klass_name, "Vector128`1") || !strcmp (klass_name, "Vector256`1") || !strcmp (klass_name, "Vector512`1")) { MonoType *etype = mono_class_get_generic_class (klass)->context.class_inst->type_argv [0]; int size = mono_class_value_size (klass, NULL); switch (etype->type) { diff --git a/src/mono/mono/mini/mini-runtime.c b/src/mono/mono/mini/mini-runtime.c index 74d5208ec19ff..4972e1b139151 100644 --- a/src/mono/mono/mini/mini-runtime.c +++ b/src/mono/mono/mini/mini-runtime.c @@ -4349,7 +4349,7 @@ init_class (MonoClass *klass) #endif if (m_class_is_ginst (klass)) { - if (!strcmp (name, "Vector`1") || !strcmp (name, "Vector64`1") || !strcmp (name, "Vector128`1") || !strcmp (name, "Vector256`1")) { + if (!strcmp (name, "Vector`1") || !strcmp (name, "Vector64`1") || !strcmp (name, "Vector128`1") || !strcmp (name, "Vector256`1") || !strcmp (name, "Vector512`1")) { MonoGenericClass *gclass = mono_class_try_get_generic_class (klass); g_assert (gclass); MonoType *etype = gclass->context.class_inst->type_argv [0]; diff --git a/src/mono/mono/mini/simd-intrinsics.c b/src/mono/mono/mini/simd-intrinsics.c index 059e21e5dbbe4..ab15541f19a85 100644 --- a/src/mono/mono/mini/simd-intrinsics.c +++ b/src/mono/mono/mini/simd-intrinsics.c @@ -309,9 +309,6 @@ emit_simd_ins_for_binary_op (MonoCompile *cfg, MonoClass *klass, MonoMethodSigna ins = emit_simd_ins (cfg, klass, OP_XBINOP_BYSCALAR, args [0]->dreg, ins->dreg); ins->inst_c0 = OP_FDIV; return ins; - } else if ((fsig->params [0]->type == MONO_TYPE_GENERICINST) && (fsig->params [1]->type == MONO_TYPE_GENERICINST)) { - instc0 = OP_FDIV; - break; } else { return NULL; } @@ -339,9 +336,6 @@ emit_simd_ins_for_binary_op (MonoCompile *cfg, MonoClass *klass, MonoMethodSigna ins = emit_simd_ins (cfg, klass, OP_XBINOP_BYSCALAR, ins->dreg, args [1]->dreg); ins->inst_c0 = OP_FMUL; return ins; - } else if ((fsig->params [0]->type == MONO_TYPE_GENERICINST) && (fsig->params [1]->type == MONO_TYPE_GENERICINST)) { - instc0 = OP_FMUL; - break; } else { return NULL; } @@ -682,7 +676,7 @@ is_intrinsics_vector_type (MonoType *vector_type) if (vector_type->type != MONO_TYPE_GENERICINST) return FALSE; MonoClass *klass = mono_class_from_mono_type_internal (vector_type); const char *name = m_class_get_name (klass); - return !strcmp (name, "Vector64`1") || !strcmp (name, "Vector128`1") || !strcmp (name, "Vector256`1"); + return !strcmp (name, "Vector64`1") || !strcmp (name, "Vector128`1") || !strcmp (name, "Vector256`1") || !strcmp (name, "Vector512`1"); } static MonoType* @@ -697,7 +691,8 @@ get_vector_t_elem_type (MonoType *vector_type) !strcmp (m_class_get_name (klass), "Vector`1") || !strcmp (m_class_get_name (klass), "Vector64`1") || !strcmp (m_class_get_name (klass), "Vector128`1") || - !strcmp (m_class_get_name (klass), "Vector256`1")); + !strcmp (m_class_get_name (klass), "Vector256`1") || + !strcmp (m_class_get_name (klass), "Vector512`1")); etype = mono_class_get_context (klass)->class_inst->type_argv [0]; return etype; } diff --git a/src/tests/Common/GenerateHWIntrinsicTests/GenerateHWIntrinsicTests_General.cs b/src/tests/Common/GenerateHWIntrinsicTests/GenerateHWIntrinsicTests_General.cs index 52b1c72f067d6..9c04cd193843f 100644 --- a/src/tests/Common/GenerateHWIntrinsicTests/GenerateHWIntrinsicTests_General.cs +++ b/src/tests/Common/GenerateHWIntrinsicTests/GenerateHWIntrinsicTests_General.cs @@ -2013,6 +2013,685 @@ ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector256", ["Method"] = "op_UnaryPlus", ["Opcode"] = "+", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)(+firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(+firstOp[i])" }), }; +(string templateFileName, Dictionary templateData)[] Vector512Inputs = new [] +{ + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Abs", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != firstOp[0]", ["ValidateRemainingResults"] = "result[i] != firstOp[i]" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Abs", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != Math.Abs(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != Math.Abs(firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Abs", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != Math.Abs(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != Math.Abs(firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Abs", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != Math.Abs(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != Math.Abs(firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Abs", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != Math.Abs(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != Math.Abs(firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Abs", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != Math.Abs(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != Math.Abs(firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Abs", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != Math.Abs(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != Math.Abs(firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Abs", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != firstOp[0]", ["ValidateRemainingResults"] = "result[i] != firstOp[i]" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Abs", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != firstOp[0]", ["ValidateRemainingResults"] = "result[i] != firstOp[i]" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Abs", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != firstOp[0]", ["ValidateRemainingResults"] = "result[i] != firstOp[i]" }), + + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Add", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != (byte)(left[0] + right[0])", ["ValidateRemainingResults"] = "result[i] != (byte)(left[i] + right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Add", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (double)(left[0] + right[0])", ["ValidateRemainingResults"] = "result[i] != (double)(left[i] + right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Add", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != (short)(left[0] + right[0])", ["ValidateRemainingResults"] = "result[i] != (short)(left[i] + right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Add", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (int)(left[0] + right[0])", ["ValidateRemainingResults"] = "result[i] != (int)(left[i] + right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Add", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (long)(left[0] + right[0])", ["ValidateRemainingResults"] = "result[i] != (long)(left[i] + right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Add", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != (sbyte)(left[0] + right[0])", ["ValidateRemainingResults"] = "result[i] != (sbyte)(left[i] + right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Add", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (float)(left[0] + right[0])", ["ValidateRemainingResults"] = "result[i] != (float)(left[i] + right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Add", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != (ushort)(left[0] + right[0])", ["ValidateRemainingResults"] = "result[i] != (ushort)(left[i] + right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Add", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)(left[0] + right[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(left[i] + right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Add", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)(left[0] + right[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(left[i] + right[i])" }), + + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "AndNot", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != (byte)(left[0] & ~right[0])", ["ValidateRemainingResults"] = "result[i] != (byte)(left[i] & ~right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "AndNot", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (BitConverter.DoubleToInt64Bits(left[0]) & ~BitConverter.DoubleToInt64Bits(right[0]))", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != (BitConverter.DoubleToInt64Bits(left[i]) & ~BitConverter.DoubleToInt64Bits(right[i]))" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "AndNot", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != (short)(left[0] & ~right[0])", ["ValidateRemainingResults"] = "result[i] != (short)(left[i] & ~right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "AndNot", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (int)(left[0] & ~right[0])", ["ValidateRemainingResults"] = "result[i] != (int)(left[i] & ~right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "AndNot", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (long)(left[0] & ~right[0])", ["ValidateRemainingResults"] = "result[i] != (long)(left[i] & ~right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "AndNot", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != (sbyte)(left[0] & ~right[0])", ["ValidateRemainingResults"] = "result[i] != (sbyte)(left[i] & ~right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "AndNot", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (BitConverter.SingleToInt32Bits(left[0]) & ~BitConverter.SingleToInt32Bits(right[0]))", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != (BitConverter.SingleToInt32Bits(left[i]) & ~BitConverter.SingleToInt32Bits(right[i]))" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "AndNot", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != (ushort)(left[0] & ~right[0])", ["ValidateRemainingResults"] = "result[i] != (ushort)(left[i] & ~right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "AndNot", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)(left[0] & ~right[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(left[i] & ~right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "AndNot", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)(left[0] & ~right[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(left[i] & ~right[i])" }), + + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "BitwiseAnd", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != (byte)(left[0] & right[0])", ["ValidateRemainingResults"] = "result[i] != (byte)(left[i] & right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "BitwiseAnd", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (BitConverter.DoubleToInt64Bits(left[0]) & BitConverter.DoubleToInt64Bits(right[0]))", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != (BitConverter.DoubleToInt64Bits(left[i]) & BitConverter.DoubleToInt64Bits(right[i]))" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "BitwiseAnd", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != (short)(left[0] & right[0])", ["ValidateRemainingResults"] = "result[i] != (short)(left[i] & right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "BitwiseAnd", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (int)(left[0] & right[0])", ["ValidateRemainingResults"] = "result[i] != (int)(left[i] & right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "BitwiseAnd", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (long)(left[0] & right[0])", ["ValidateRemainingResults"] = "result[i] != (long)(left[i] & right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "BitwiseAnd", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != (sbyte)(left[0] & right[0])", ["ValidateRemainingResults"] = "result[i] != (sbyte)(left[i] & right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "BitwiseAnd", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0]))", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != (BitConverter.SingleToInt32Bits(left[i]) & BitConverter.SingleToInt32Bits(right[i]))" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "BitwiseAnd", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != (ushort)(left[0] & right[0])", ["ValidateRemainingResults"] = "result[i] != (ushort)(left[i] & right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "BitwiseAnd", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)(left[0] & right[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(left[i] & right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "BitwiseAnd", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)(left[0] & right[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(left[i] & right[i])" }), + + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "BitwiseOr", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != (byte)(left[0] | right[0])", ["ValidateRemainingResults"] = "result[i] != (byte)(left[i] | right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "BitwiseOr", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (BitConverter.DoubleToInt64Bits(left[0]) | BitConverter.DoubleToInt64Bits(right[0]))", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != (BitConverter.DoubleToInt64Bits(left[i]) | BitConverter.DoubleToInt64Bits(right[i]))" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "BitwiseOr", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != (short)(left[0] | right[0])", ["ValidateRemainingResults"] = "result[i] != (short)(left[i] | right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "BitwiseOr", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (int)(left[0] | right[0])", ["ValidateRemainingResults"] = "result[i] != (int)(left[i] | right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "BitwiseOr", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (long)(left[0] | right[0])", ["ValidateRemainingResults"] = "result[i] != (long)(left[i] | right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "BitwiseOr", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != (sbyte)(left[0] | right[0])", ["ValidateRemainingResults"] = "result[i] != (sbyte)(left[i] | right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "BitwiseOr", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (BitConverter.SingleToInt32Bits(left[0]) | BitConverter.SingleToInt32Bits(right[0]))", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != (BitConverter.SingleToInt32Bits(left[i]) | BitConverter.SingleToInt32Bits(right[i]))" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "BitwiseOr", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != (ushort)(left[0] | right[0])", ["ValidateRemainingResults"] = "result[i] != (ushort)(left[i] | right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "BitwiseOr", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)(left[0] | right[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(left[i] | right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "BitwiseOr", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)(left[0] | right[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(left[i] | right[i])" }), + + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Ceiling", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != Math.Ceiling(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != Math.Ceiling(firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Ceiling", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != MathF.Ceiling(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != MathF.Ceiling(firstOp[i])" }), + + ("VectorTernaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ConditionalSelect", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["Op3VectorType"] = "Vector512", ["Op3BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["NextValueOp3"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != (byte)((secondOp[0] & firstOp[0]) | (thirdOp[0] & ~firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (byte)((secondOp[i] & firstOp[i]) | (thirdOp[i] & ~firstOp[i]))" }), + ("VectorTernaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ConditionalSelect", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["Op3VectorType"] = "Vector512", ["Op3BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp3"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((BitConverter.DoubleToInt64Bits(secondOp[0]) & BitConverter.DoubleToInt64Bits(firstOp[0])) | (BitConverter.DoubleToInt64Bits(thirdOp[0]) & ~BitConverter.DoubleToInt64Bits(firstOp[0])))", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ((BitConverter.DoubleToInt64Bits(secondOp[i]) & BitConverter.DoubleToInt64Bits(firstOp[i])) | (BitConverter.DoubleToInt64Bits(thirdOp[i]) & ~BitConverter.DoubleToInt64Bits(firstOp[i])))" }), + ("VectorTernaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ConditionalSelect", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["Op3VectorType"] = "Vector512", ["Op3BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != (short)((secondOp[0] & firstOp[0]) | (thirdOp[0] & ~firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (short)((secondOp[i] & firstOp[i]) | (thirdOp[i] & ~firstOp[i]))" }), + ("VectorTernaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ConditionalSelect", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["Op3VectorType"] = "Vector512", ["Op3BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (int)((secondOp[0] & firstOp[0]) | (thirdOp[0] & ~firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (int)((secondOp[i] & firstOp[i]) | (thirdOp[i] & ~firstOp[i]))" }), + ("VectorTernaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ConditionalSelect", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["Op3VectorType"] = "Vector512", ["Op3BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (long)((secondOp[0] & firstOp[0]) | (thirdOp[0] & ~firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (long)((secondOp[i] & firstOp[i]) | (thirdOp[i] & ~firstOp[i]))" }), + ("VectorTernaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ConditionalSelect", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["Op3VectorType"] = "Vector512", ["Op3BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp3"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != (sbyte)((secondOp[0] & firstOp[0]) | (thirdOp[0] & ~firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (sbyte)((secondOp[i] & firstOp[i]) | (thirdOp[i] & ~firstOp[i]))" }), + ("VectorTernaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ConditionalSelect", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["Op3VectorType"] = "Vector512", ["Op3BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp3"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((BitConverter.SingleToInt32Bits(secondOp[0]) & BitConverter.SingleToInt32Bits(firstOp[0])) | (BitConverter.SingleToInt32Bits(thirdOp[0]) & ~BitConverter.SingleToInt32Bits(firstOp[0])))", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((BitConverter.SingleToInt32Bits(secondOp[i]) & BitConverter.SingleToInt32Bits(firstOp[i])) | (BitConverter.SingleToInt32Bits(thirdOp[i]) & ~BitConverter.SingleToInt32Bits(firstOp[i])))" }), + ("VectorTernaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ConditionalSelect", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["Op3VectorType"] = "Vector512", ["Op3BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != (ushort)((secondOp[0] & firstOp[0]) | (thirdOp[0] & ~firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (ushort)((secondOp[i] & firstOp[i]) | (thirdOp[i] & ~firstOp[i]))" }), + ("VectorTernaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ConditionalSelect", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["Op3VectorType"] = "Vector512", ["Op3BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)((secondOp[0] & firstOp[0]) | (thirdOp[0] & ~firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (uint)((secondOp[i] & firstOp[i]) | (thirdOp[i] & ~firstOp[i]))" }), + ("VectorTernaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ConditionalSelect", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["Op3VectorType"] = "Vector512", ["Op3BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)((secondOp[0] & firstOp[0]) | (thirdOp[0] & ~firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (ulong)((secondOp[i] & firstOp[i]) | (thirdOp[i] & ~firstOp[i]))" }), + + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ConvertToDouble", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (double)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (double)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ConvertToDouble", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "Math.Min(long.MaxValue, TestLibrary.Generator.GetUInt64())", ["ValidateFirstResult"] = "result[0] != (double)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (double)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ConvertToInt32", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (int)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (int)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ConvertToInt64", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (long)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (long)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ConvertToSingle", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (float)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (float)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ConvertToSingle", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (float)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (float)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ConvertToUInt32", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (uint)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ConvertToUInt64", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (ulong)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(firstOp[i])" }), + + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != expectedValue" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != expectedValue" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != expectedValue" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != expectedValue" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != expectedValue" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != expectedValue" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != expectedValue" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != expectedValue" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != expectedValue" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != expectedValue" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "CreateScalar", ["VectorType"] = "Vector512", ["BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != 0" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "CreateScalar", ["VectorType"] = "Vector512", ["BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != 0" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "CreateScalar", ["VectorType"] = "Vector512", ["BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != 0" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "CreateScalar", ["VectorType"] = "Vector512", ["BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != 0" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "CreateScalar", ["VectorType"] = "Vector512", ["BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != 0" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "CreateScalar", ["VectorType"] = "Vector512", ["BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != 0" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "CreateScalar", ["VectorType"] = "Vector512", ["BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != 0" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "CreateScalar", ["VectorType"] = "Vector512", ["BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != 0" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "CreateScalar", ["VectorType"] = "Vector512", ["BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != 0" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "CreateScalar", ["VectorType"] = "Vector512", ["BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != 0" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "CreateScalarUnsafe", ["VectorType"] = "Vector512", ["BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "false /* value is uninitialized */" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "CreateScalarUnsafe", ["VectorType"] = "Vector512", ["BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "false /* value is uninitialized */" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "CreateScalarUnsafe", ["VectorType"] = "Vector512", ["BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "false /* value is uninitialized */" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "CreateScalarUnsafe", ["VectorType"] = "Vector512", ["BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "false /* value is uninitialized */" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "CreateScalarUnsafe", ["VectorType"] = "Vector512", ["BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "false /* value is uninitialized */" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "CreateScalarUnsafe", ["VectorType"] = "Vector512", ["BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "false /* value is uninitialized */" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "CreateScalarUnsafe", ["VectorType"] = "Vector512", ["BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "false /* value is uninitialized */" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "CreateScalarUnsafe", ["VectorType"] = "Vector512", ["BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "false /* value is uninitialized */" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "CreateScalarUnsafe", ["VectorType"] = "Vector512", ["BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "false /* value is uninitialized */" }), + ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "CreateScalarUnsafe", ["VectorType"] = "Vector512", ["BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "false /* value is uninitialized */" }), + + ("VectorCreateElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetByte()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31], values[32], values[33], values[34], values[35], values[36], values[37], values[38], values[39], values[40], values[41], values[42], values[43], values[44], values[45], values[46], values[47], values[48], values[49], values[50], values[51], values[52], values[53], values[54], values[55], values[56], values[57], values[58], values[59], values[60], values[61], values[62], values[63]" }), + ("VectorCreateElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetDouble()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]" }), + ("VectorCreateElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt16()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31]" }), + ("VectorCreateElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt32()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorCreateElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt64()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]" }), + ("VectorCreateElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSByte()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31], values[32], values[33], values[34], values[35], values[36], values[37], values[38], values[39], values[40], values[41], values[42], values[43], values[44], values[45], values[46], values[47], values[48], values[49], values[50], values[51], values[52], values[53], values[54], values[55], values[56], values[57], values[58], values[59], values[60], values[61], values[62], values[63]" }), + ("VectorCreateElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSingle()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorCreateElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt16()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31]" }), + ("VectorCreateElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt32()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorCreateElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt64()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]" }), + + ("VectorCreateVectorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "Byte", ["OpVectorType"] = "Vector256", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetByte()" }), + ("VectorCreateVectorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "Double", ["OpVectorType"] = "Vector256", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetDouble()" }), + ("VectorCreateVectorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "Int16", ["OpVectorType"] = "Vector256", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt16()" }), + ("VectorCreateVectorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "Int32", ["OpVectorType"] = "Vector256", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt32()" }), + ("VectorCreateVectorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "Int64", ["OpVectorType"] = "Vector256", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt64()" }), + ("VectorCreateVectorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "SByte", ["OpVectorType"] = "Vector256", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSByte()" }), + ("VectorCreateVectorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "Single", ["OpVectorType"] = "Vector256", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSingle()" }), + ("VectorCreateVectorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "UInt16", ["OpVectorType"] = "Vector256", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt16()" }), + ("VectorCreateVectorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "UInt32", ["OpVectorType"] = "Vector256", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt32()" }), + ("VectorCreateVectorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Create", ["VectorType"] = "Vector512", ["BaseType"] = "UInt64", ["OpVectorType"] = "Vector256", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt64()" }), + + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Divide", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "Math.Max((byte)(1), TestLibrary.Generator.GetByte())", ["ValidateFirstResult"] = "result[0] != (byte)(left[0] / right[0])", ["ValidateRemainingResults"] = "result[i] != (byte)(left[i] / right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Divide", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "Math.Max((double)(1), TestLibrary.Generator.GetDouble())", ["ValidateFirstResult"] = "result[0] != (double)(left[0] / right[0])", ["ValidateRemainingResults"] = "result[i] != (double)(left[i] / right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Divide", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "Math.Max((short)(1), TestLibrary.Generator.GetInt16())", ["ValidateFirstResult"] = "result[0] != (short)(left[0] / right[0])", ["ValidateRemainingResults"] = "result[i] != (short)(left[i] / right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Divide", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "Math.Max((int)(1), TestLibrary.Generator.GetInt32())", ["ValidateFirstResult"] = "result[0] != (int)(left[0] / right[0])", ["ValidateRemainingResults"] = "result[i] != (int)(left[i] / right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Divide", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "Math.Max((long)(1), TestLibrary.Generator.GetInt64())", ["ValidateFirstResult"] = "result[0] != (long)(left[0] / right[0])", ["ValidateRemainingResults"] = "result[i] != (long)(left[i] / right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Divide", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "Math.Max((sbyte)(1), TestLibrary.Generator.GetSByte())", ["ValidateFirstResult"] = "result[0] != (sbyte)(left[0] / right[0])", ["ValidateRemainingResults"] = "result[i] != (sbyte)(left[i] / right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Divide", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "Math.Max((float)(1), TestLibrary.Generator.GetSingle())", ["ValidateFirstResult"] = "result[0] != (float)(left[0] / right[0])", ["ValidateRemainingResults"] = "result[i] != (float)(left[i] / right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Divide", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "Math.Max((ushort)(1), TestLibrary.Generator.GetUInt16())", ["ValidateFirstResult"] = "result[0] != (ushort)(left[0] / right[0])", ["ValidateRemainingResults"] = "result[i] != (ushort)(left[i] / right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Divide", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "Math.Max((uint)(1), TestLibrary.Generator.GetUInt32())", ["ValidateFirstResult"] = "result[0] != (uint)(left[0] / right[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(left[i] / right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Divide", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "Math.Max((ulong)(1), TestLibrary.Generator.GetUInt64())", ["ValidateFirstResult"] = "result[0] != (ulong)(left[0] / right[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(left[i] / right[i])" }), + + ("VectorDotTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Dot", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()" }), + ("VectorDotTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Dot", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()" }), + ("VectorDotTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Dot", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()" }), + ("VectorDotTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Dot", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()" }), + ("VectorDotTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Dot", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()" }), + ("VectorDotTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Dot", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()" }), + ("VectorDotTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Dot", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()" }), + ("VectorDotTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Dot", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()" }), + ("VectorDotTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Dot", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()" }), + ("VectorDotTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Dot", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()" }), + + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "EqualsAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "EqualsAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "EqualsAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "EqualsAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "EqualsAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "EqualsAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "EqualsAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "EqualsAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "EqualsAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "EqualsAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "EqualsAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "EqualsAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "EqualsAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "EqualsAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "EqualsAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "EqualsAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "EqualsAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "EqualsAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "EqualsAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "EqualsAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Equals", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? byte.MaxValue : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? byte.MaxValue : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Equals", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] == right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] == right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Equals", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Equals", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Equals", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Equals", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Equals", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] == right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] == right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Equals", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? ushort.MaxValue : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? ushort.MaxValue : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Equals", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? uint.MaxValue : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? uint.MaxValue : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Equals", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? ulong.MaxValue : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? ulong.MaxValue : 0)" }), + + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Floor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != Math.Floor(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != Math.Floor(firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Floor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != MathF.Floor(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != MathF.Floor(firstOp[i])" }), + + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "left[i] > right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "left[i] > right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "left[i] > right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "left[i] > right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "left[i] > right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "left[i] > right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "left[i] > right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "left[i] > right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "left[i] > right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "left[i] > right[i]" }), + + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "left[i] > right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "left[i] > right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "left[i] > right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "left[i] > right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "left[i] > right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "left[i] > right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "left[i] > right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "left[i] > right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "left[i] > right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "left[i] > right[i]" }), + + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThan", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? byte.MaxValue : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? byte.MaxValue : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThan", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] > right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] > right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThan", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThan", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThan", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThan", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThan", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] > right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] > right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThan", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? ushort.MaxValue : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? ushort.MaxValue : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThan", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? uint.MaxValue : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? uint.MaxValue : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThan", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? ulong.MaxValue : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? ulong.MaxValue : 0)" }), + + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqualAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "left[i] >= right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqualAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "left[i] >= right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqualAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "left[i] >= right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqualAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "left[i] >= right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqualAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "left[i] >= right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqualAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "left[i] >= right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqualAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "left[i] >= right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqualAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "left[i] >= right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqualAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "left[i] >= right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqualAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "left[i] >= right[i]" }), + + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqualAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "left[i] >= right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqualAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "left[i] >= right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqualAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "left[i] >= right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqualAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "left[i] >= right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqualAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "left[i] >= right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqualAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "left[i] >= right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqualAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "left[i] >= right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqualAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "left[i] >= right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqualAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "left[i] >= right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqualAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "left[i] >= right[i]" }), + + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqual", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != ((left[0] >= right[0]) ? byte.MaxValue : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] >= right[i]) ? byte.MaxValue : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqual", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] >= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] >= right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqual", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != ((left[0] >= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] >= right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqual", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != ((left[0] >= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] >= right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqual", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != ((left[0] >= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] >= right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqual", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != ((left[0] >= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] >= right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqual", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] >= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] >= right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqual", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != ((left[0] >= right[0]) ? ushort.MaxValue : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] >= right[i]) ? ushort.MaxValue : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqual", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != ((left[0] >= right[0]) ? uint.MaxValue : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] >= right[i]) ? uint.MaxValue : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GreaterThanOrEqual", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != ((left[0] >= right[0]) ? ulong.MaxValue : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] >= right[i]) ? ulong.MaxValue : 0)" }), + + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "left[i] < right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "left[i] < right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "left[i] < right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "left[i] < right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "left[i] < right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "left[i] < right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "left[i] < right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "left[i] < right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "left[i] < right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "left[i] < right[i]" }), + + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "left[i] < right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "left[i] < right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "left[i] < right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "left[i] < right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "left[i] < right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "left[i] < right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "left[i] < right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "left[i] < right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "left[i] < right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "left[i] < right[i]" }), + + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThan", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? byte.MaxValue : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? byte.MaxValue : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThan", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] < right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] < right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThan", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThan", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThan", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThan", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThan", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] < right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] < right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThan", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? ushort.MaxValue : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? ushort.MaxValue : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThan", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? uint.MaxValue : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? uint.MaxValue : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThan", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? ulong.MaxValue : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? ulong.MaxValue : 0)" }), + + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqualAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "left[i] <= right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqualAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "left[i] <= right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqualAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "left[i] <= right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqualAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "left[i] <= right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqualAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "left[i] <= right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqualAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "left[i] <= right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqualAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "left[i] <= right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqualAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "left[i] <= right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqualAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "left[i] <= right[i]" }), + ("VectorBooleanAllBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqualAll", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "left[i] <= right[i]" }), + + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqualAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "left[i] <= right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqualAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "left[i] <= right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqualAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "left[i] <= right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqualAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "left[i] <= right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqualAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "left[i] <= right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqualAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "left[i] <= right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqualAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "left[i] <= right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqualAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "left[i] <= right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqualAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "left[i] <= right[i]" }), + ("VectorBooleanAnyBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqualAny", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "left[i] <= right[i]" }), + + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqual", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != ((left[0] <= right[0]) ? byte.MaxValue : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] <= right[i]) ? byte.MaxValue : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqual", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] <= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] <= right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqual", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != ((left[0] <= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] <= right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqual", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != ((left[0] <= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] <= right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqual", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != ((left[0] <= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] <= right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqual", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != ((left[0] <= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] <= right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqual", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] <= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] <= right[i]) ? -1 : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqual", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != ((left[0] <= right[0]) ? ushort.MaxValue : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] <= right[i]) ? ushort.MaxValue : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqual", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != ((left[0] <= right[0]) ? uint.MaxValue : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] <= right[i]) ? uint.MaxValue : 0)" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "LessThanOrEqual", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != ((left[0] <= right[0]) ? ulong.MaxValue : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] <= right[i]) ? ulong.MaxValue : 0)" }), + + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Max", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? left[0] : right[0])", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? left[i] : right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Max", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? left[0] : right[0])", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? left[i] : right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Max", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? left[0] : right[0])", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? left[i] : right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Max", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? left[0] : right[0])", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? left[i] : right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Max", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? left[0] : right[0])", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? left[i] : right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Max", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? left[0] : right[0])", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? left[i] : right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Max", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? left[0] : right[0])", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? left[i] : right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Max", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? left[0] : right[0])", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? left[i] : right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Max", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? left[0] : right[0])", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? left[i] : right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Max", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? left[0] : right[0])", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? left[i] : right[i])" }), + + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Min", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? left[0] : right[0])", ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? left[i] : right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Min", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? left[0] : right[0])", ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? left[i] : right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Min", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? left[0] : right[0])", ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? left[i] : right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Min", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? left[0] : right[0])", ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? left[i] : right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Min", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? left[0] : right[0])", ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? left[i] : right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Min", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? left[0] : right[0])", ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? left[i] : right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Min", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? left[0] : right[0])", ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? left[i] : right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Min", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? left[0] : right[0])", ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? left[i] : right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Min", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? left[0] : right[0])", ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? left[i] : right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Min", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? left[0] : right[0])", ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? left[i] : right[i])" }), + + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Multiply", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != (byte)(left[0] * right[0])", ["ValidateRemainingResults"] = "result[i] != (byte)(left[i] * right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Multiply", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (double)(left[0] * right[0])", ["ValidateRemainingResults"] = "result[i] != (double)(left[i] * right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Multiply", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != (short)(left[0] * right[0])", ["ValidateRemainingResults"] = "result[i] != (short)(left[i] * right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Multiply", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (int)(left[0] * right[0])", ["ValidateRemainingResults"] = "result[i] != (int)(left[i] * right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Multiply", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (long)(left[0] * right[0])", ["ValidateRemainingResults"] = "result[i] != (long)(left[i] * right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Multiply", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != (sbyte)(left[0] * right[0])", ["ValidateRemainingResults"] = "result[i] != (sbyte)(left[i] * right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Multiply", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (float)(left[0] * right[0])", ["ValidateRemainingResults"] = "result[i] != (float)(left[i] * right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Multiply", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != (ushort)(left[0] * right[0])", ["ValidateRemainingResults"] = "result[i] != (ushort)(left[i] * right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Multiply", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)(left[0] * right[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(left[i] * right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Multiply", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)(left[0] * right[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(left[i] * right[i])" }), + + ("VectorNarrowTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Narrow", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (float)(left[0])", ["ValidateRemainingResults"] = "result[i] != (float)((i < Op1ElementCount) ? left[i] : right[i - Op1ElementCount])" }), + ("VectorNarrowTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Narrow", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != (sbyte)(left[0])", ["ValidateRemainingResults"] = "result[i] != (sbyte)((i < Op1ElementCount) ? left[i] : right[i - Op1ElementCount])" }), + ("VectorNarrowTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Narrow", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (short)(left[0])", ["ValidateRemainingResults"] = "result[i] != (short)((i < Op1ElementCount) ? left[i] : right[i - Op1ElementCount])" }), + ("VectorNarrowTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Narrow", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (int)(left[0])", ["ValidateRemainingResults"] = "result[i] != (int)((i < Op1ElementCount) ? left[i] : right[i - Op1ElementCount])" }), + ("VectorNarrowTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Narrow", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != (byte)(left[0])", ["ValidateRemainingResults"] = "result[i] != (byte)((i < Op1ElementCount) ? left[i] : right[i - Op1ElementCount])" }), + ("VectorNarrowTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Narrow", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (ushort)(left[0])", ["ValidateRemainingResults"] = "result[i] != (ushort)((i < Op1ElementCount) ? left[i] : right[i - Op1ElementCount])" }), + ("VectorNarrowTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Narrow", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (uint)(left[0])", ["ValidateRemainingResults"] = "result[i] != (uint)((i < Op1ElementCount) ? left[i] : right[i - Op1ElementCount])" }), + + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Negate", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != (byte)(0 - firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (byte)(0 - firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Negate", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (double)(0 - firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (double)(0 - firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Negate", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != (short)(0 - firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (short)(0 - firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Negate", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (int)(0 - firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (int)(0 - firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Negate", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (long)(0 - firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (long)(0 - firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Negate", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != (sbyte)(0 - firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (sbyte)(0 - firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Negate", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (float)(0 - firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (float)(0 - firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Negate", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != (ushort)(0 - firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (ushort)(0 - firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Negate", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)(0 - firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(0 - firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Negate", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)(0 - firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(0 - firstOp[i])" }), + + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "OnesComplement", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != (byte)(~firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (byte)(~firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "OnesComplement", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ~BitConverter.DoubleToInt64Bits(firstOp[0])", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ~BitConverter.DoubleToInt64Bits(firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "OnesComplement", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != (short)(~firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (short)(~firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "OnesComplement", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (int)(~firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (int)(~firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "OnesComplement", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (long)(~firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (long)(~firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "OnesComplement", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != (sbyte)(~firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (sbyte)(~firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "OnesComplement", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ~BitConverter.SingleToInt32Bits(firstOp[0])", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ~BitConverter.SingleToInt32Bits(firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "OnesComplement", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != (ushort)(~firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (ushort)(~firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "OnesComplement", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)(~firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(~firstOp[i])" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "OnesComplement", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)(~firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(~firstOp[i])" }), + + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Sqrt", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != (byte)(MathF.Sqrt(firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (byte)(MathF.Sqrt(firstOp[i]))" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Sqrt", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (double)(Math.Sqrt(firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (double)(Math.Sqrt(firstOp[i]))" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Sqrt", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != (short)(MathF.Sqrt(firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (short)(MathF.Sqrt(firstOp[i]))" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Sqrt", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (int)(Math.Sqrt(firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (int)(Math.Sqrt(firstOp[i]))" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Sqrt", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (long)(Math.Sqrt(firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (long)(Math.Sqrt(firstOp[i]))" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Sqrt", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != (sbyte)(MathF.Sqrt(firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (sbyte)(MathF.Sqrt(firstOp[i]))" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Sqrt", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (float)(MathF.Sqrt(firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (float)(MathF.Sqrt(firstOp[i]))" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Sqrt", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != (ushort)(MathF.Sqrt(firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (ushort)(MathF.Sqrt(firstOp[i]))" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Sqrt", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)(Math.Sqrt(firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (uint)(Math.Sqrt(firstOp[i]))" }), + ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Sqrt", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)(Math.Sqrt(firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (ulong)(Math.Sqrt(firstOp[i]))" }), + + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Subtract", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != (byte)(left[0] - right[0])", ["ValidateRemainingResults"] = "result[i] != (byte)(left[i] - right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Subtract", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (double)(left[0] - right[0])", ["ValidateRemainingResults"] = "result[i] != (double)(left[i] - right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Subtract", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != (short)(left[0] - right[0])", ["ValidateRemainingResults"] = "result[i] != (short)(left[i] - right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Subtract", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (int)(left[0] - right[0])", ["ValidateRemainingResults"] = "result[i] != (int)(left[i] - right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Subtract", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (long)(left[0] - right[0])", ["ValidateRemainingResults"] = "result[i] != (long)(left[i] - right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Subtract", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != (sbyte)(left[0] - right[0])", ["ValidateRemainingResults"] = "result[i] != (sbyte)(left[i] - right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Subtract", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (float)(left[0] - right[0])", ["ValidateRemainingResults"] = "result[i] != (float)(left[i] - right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Subtract", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != (ushort)(left[0] - right[0])", ["ValidateRemainingResults"] = "result[i] != (ushort)(left[i] - right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Subtract", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)(left[0] - right[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(left[i] - right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Subtract", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)(left[0] - right[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(left[i] - right[i])" }), + + ("VectorWidenTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Widen", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["ValidateLowerResult"] = "lowerResult[i] != (ushort)(firstOp[i])", ["ValidateUpperResult"] = "upperResult[i] != (ushort)(firstOp[i + RetElementCount])" }), + ("VectorWidenTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Widen", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["ValidateLowerResult"] = "lowerResult[i] != (int)(firstOp[i])", ["ValidateUpperResult"] = "upperResult[i] != (int)(firstOp[i + RetElementCount])" }), + ("VectorWidenTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Widen", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateLowerResult"] = "lowerResult[i] != (long)(firstOp[i])", ["ValidateUpperResult"] = "upperResult[i] != (long)(firstOp[i + RetElementCount])" }), + ("VectorWidenTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Widen", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["ValidateLowerResult"] = "lowerResult[i] != (short)(firstOp[i])", ["ValidateUpperResult"] = "upperResult[i] != (short)(firstOp[i + RetElementCount])" }), + ("VectorWidenTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Widen", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateLowerResult"] = "lowerResult[i] != (double)(firstOp[i])", ["ValidateUpperResult"] = "upperResult[i] != (double)(firstOp[i + RetElementCount])" }), + ("VectorWidenTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Widen", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["ValidateLowerResult"] = "lowerResult[i] != (uint)(firstOp[i])", ["ValidateUpperResult"] = "upperResult[i] != (uint)(firstOp[i + RetElementCount])" }), + ("VectorWidenTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Widen", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateLowerResult"] = "lowerResult[i] != (ulong)(firstOp[i])", ["ValidateUpperResult"] = "upperResult[i] != (ulong)(firstOp[i + RetElementCount])" }), + + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Xor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != (byte)(left[0] ^ right[0])", ["ValidateRemainingResults"] = "result[i] != (byte)(left[i] ^ right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Xor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (BitConverter.DoubleToInt64Bits(left[0]) ^ BitConverter.DoubleToInt64Bits(right[0]))", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != (BitConverter.DoubleToInt64Bits(left[i]) ^ BitConverter.DoubleToInt64Bits(right[i]))" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Xor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != (short)(left[0] ^ right[0])", ["ValidateRemainingResults"] = "result[i] != (short)(left[i] ^ right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Xor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (int)(left[0] ^ right[0])", ["ValidateRemainingResults"] = "result[i] != (int)(left[i] ^ right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Xor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (long)(left[0] ^ right[0])", ["ValidateRemainingResults"] = "result[i] != (long)(left[i] ^ right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Xor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != (sbyte)(left[0] ^ right[0])", ["ValidateRemainingResults"] = "result[i] != (sbyte)(left[i] ^ right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Xor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (BitConverter.SingleToInt32Bits(left[0]) ^ BitConverter.SingleToInt32Bits(right[0]))", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != (BitConverter.SingleToInt32Bits(left[i]) ^ BitConverter.SingleToInt32Bits(right[i]))" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Xor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != (ushort)(left[0] ^ right[0])", ["ValidateRemainingResults"] = "result[i] != (ushort)(left[i] ^ right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Xor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)(left[0] ^ right[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(left[i] ^ right[i])" }), + ("VectorBinaryOpTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "Xor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)(left[0] ^ right[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(left[i] ^ right[i])" }), +}; + +(string templateFileName, Dictionary templateData)[] Vector512_1Inputs = new [] +{ + ("VectorZeroTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "Zero", ["VectorType"] = "Vector512", ["BaseType"] = "Byte", ["LargestVectorSize"] = "64" }), + ("VectorZeroTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "Zero", ["VectorType"] = "Vector512", ["BaseType"] = "Double", ["LargestVectorSize"] = "64" }), + ("VectorZeroTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "Zero", ["VectorType"] = "Vector512", ["BaseType"] = "Int16", ["LargestVectorSize"] = "64" }), + ("VectorZeroTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "Zero", ["VectorType"] = "Vector512", ["BaseType"] = "Int32", ["LargestVectorSize"] = "64" }), + ("VectorZeroTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "Zero", ["VectorType"] = "Vector512", ["BaseType"] = "Int64", ["LargestVectorSize"] = "64" }), + ("VectorZeroTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "Zero", ["VectorType"] = "Vector512", ["BaseType"] = "SByte", ["LargestVectorSize"] = "64" }), + ("VectorZeroTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "Zero", ["VectorType"] = "Vector512", ["BaseType"] = "Single", ["LargestVectorSize"] = "64" }), + ("VectorZeroTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "Zero", ["VectorType"] = "Vector512", ["BaseType"] = "UInt16", ["LargestVectorSize"] = "64" }), + ("VectorZeroTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "Zero", ["VectorType"] = "Vector512", ["BaseType"] = "UInt32", ["LargestVectorSize"] = "64" }), + ("VectorZeroTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "Zero", ["VectorType"] = "Vector512", ["BaseType"] = "UInt64", ["LargestVectorSize"] = "64" }), + + ("VectorAllBitsSetTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "AllBitsSet", ["VectorType"] = "Vector512", ["BaseType"] = "Byte", ["LargestVectorSize"] = "64" }), + ("VectorAllBitsSetTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "AllBitsSet", ["VectorType"] = "Vector512", ["BaseType"] = "Double", ["LargestVectorSize"] = "64" }), + ("VectorAllBitsSetTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "AllBitsSet", ["VectorType"] = "Vector512", ["BaseType"] = "Int16", ["LargestVectorSize"] = "64" }), + ("VectorAllBitsSetTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "AllBitsSet", ["VectorType"] = "Vector512", ["BaseType"] = "Int32", ["LargestVectorSize"] = "64" }), + ("VectorAllBitsSetTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "AllBitsSet", ["VectorType"] = "Vector512", ["BaseType"] = "Int64", ["LargestVectorSize"] = "64" }), + ("VectorAllBitsSetTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "AllBitsSet", ["VectorType"] = "Vector512", ["BaseType"] = "SByte", ["LargestVectorSize"] = "64" }), + ("VectorAllBitsSetTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "AllBitsSet", ["VectorType"] = "Vector512", ["BaseType"] = "Single", ["LargestVectorSize"] = "64" }), + ("VectorAllBitsSetTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "AllBitsSet", ["VectorType"] = "Vector512", ["BaseType"] = "UInt16", ["LargestVectorSize"] = "64" }), + ("VectorAllBitsSetTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "AllBitsSet", ["VectorType"] = "Vector512", ["BaseType"] = "UInt32", ["LargestVectorSize"] = "64" }), + ("VectorAllBitsSetTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "AllBitsSet", ["VectorType"] = "Vector512", ["BaseType"] = "UInt64", ["LargestVectorSize"] = "64" }), + + + ("VectorAsTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "As", ["VectorType"] = "Vector512", ["BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "(byte)TestLibrary.Generator.GetByte()" }), + ("VectorAsTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "As", ["VectorType"] = "Vector512", ["BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp"] = "(double)TestLibrary.Generator.GetDouble()" }), + ("VectorAsTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "As", ["VectorType"] = "Vector512", ["BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "(short)TestLibrary.Generator.GetInt16()" }), + ("VectorAsTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "As", ["VectorType"] = "Vector512", ["BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "(int)TestLibrary.Generator.GetInt32()" }), + ("VectorAsTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "As", ["VectorType"] = "Vector512", ["BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp"] = "(long)TestLibrary.Generator.GetInt64()" }), + ("VectorAsTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "As", ["VectorType"] = "Vector512", ["BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "(sbyte)TestLibrary.Generator.GetSByte()" }), + ("VectorAsTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "As", ["VectorType"] = "Vector512", ["BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp"] = "(float)TestLibrary.Generator.GetSingle()" }), + ("VectorAsTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "As", ["VectorType"] = "Vector512", ["BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "(ushort)TestLibrary.Generator.GetUInt16()" }), + ("VectorAsTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "As", ["VectorType"] = "Vector512", ["BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "(uint)TestLibrary.Generator.GetUInt32()" }), + ("VectorAsTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "As", ["VectorType"] = "Vector512", ["BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp"] = "(ulong)TestLibrary.Generator.GetUInt64()" }), + + ("VectorAsNumericsVectorTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "AsVector", ["VectorType"] = "Vector512", ["BaseType"] = "Byte", ["NumericsType"] = "Vector", ["LargestVectorSize"] = "64", ["NextValueOp"] = "(byte)TestLibrary.Generator.GetByte()" }), + ("VectorAsNumericsVectorTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "AsVector", ["VectorType"] = "Vector512", ["BaseType"] = "Double", ["NumericsType"] = "Vector", ["LargestVectorSize"] = "64", ["NextValueOp"] = "(double)TestLibrary.Generator.GetDouble()" }), + ("VectorAsNumericsVectorTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "AsVector", ["VectorType"] = "Vector512", ["BaseType"] = "Int16", ["NumericsType"] = "Vector", ["LargestVectorSize"] = "64", ["NextValueOp"] = "(short)TestLibrary.Generator.GetInt16()" }), + ("VectorAsNumericsVectorTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "AsVector", ["VectorType"] = "Vector512", ["BaseType"] = "Int32", ["NumericsType"] = "Vector", ["LargestVectorSize"] = "64", ["NextValueOp"] = "(int)TestLibrary.Generator.GetInt32()" }), + ("VectorAsNumericsVectorTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "AsVector", ["VectorType"] = "Vector512", ["BaseType"] = "Int64", ["NumericsType"] = "Vector", ["LargestVectorSize"] = "64", ["NextValueOp"] = "(long)TestLibrary.Generator.GetInt64()" }), + ("VectorAsNumericsVectorTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "AsVector", ["VectorType"] = "Vector512", ["BaseType"] = "SByte", ["NumericsType"] = "Vector", ["LargestVectorSize"] = "64", ["NextValueOp"] = "(sbyte)TestLibrary.Generator.GetSByte()" }), + ("VectorAsNumericsVectorTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "AsVector", ["VectorType"] = "Vector512", ["BaseType"] = "Single", ["NumericsType"] = "Vector", ["LargestVectorSize"] = "64", ["NextValueOp"] = "(float)TestLibrary.Generator.GetSingle()" }), + ("VectorAsNumericsVectorTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "AsVector", ["VectorType"] = "Vector512", ["BaseType"] = "UInt16", ["NumericsType"] = "Vector", ["LargestVectorSize"] = "64", ["NextValueOp"] = "(ushort)TestLibrary.Generator.GetUInt16()" }), + ("VectorAsNumericsVectorTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "AsVector", ["VectorType"] = "Vector512", ["BaseType"] = "UInt32", ["NumericsType"] = "Vector", ["LargestVectorSize"] = "64", ["NextValueOp"] = "(uint)TestLibrary.Generator.GetUInt32()" }), + ("VectorAsNumericsVectorTest.template", new Dictionary { ["Isa"] = "Vector512_1", ["Method"] = "AsVector", ["VectorType"] = "Vector512", ["BaseType"] = "UInt64", ["NumericsType"] = "Vector", ["LargestVectorSize"] = "64", ["NextValueOp"] = "(ulong)TestLibrary.Generator.GetUInt64()" }), + + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetByte()", ["Imm"] = "0", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31], values[32], values[33], values[34], values[35], values[36], values[37], values[38], values[39], values[40], values[41], values[42], values[43], values[44], values[45], values[46], values[47], values[48], values[49], values[50], values[51], values[52], values[53], values[54], values[55], values[56], values[57], values[58], values[59], values[60], values[61], values[62], values[63]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetByte()", ["Imm"] = "7", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31], values[32], values[33], values[34], values[35], values[36], values[37], values[38], values[39], values[40], values[41], values[42], values[43], values[44], values[45], values[46], values[47], values[48], values[49], values[50], values[51], values[52], values[53], values[54], values[55], values[56], values[57], values[58], values[59], values[60], values[61], values[62], values[63]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetByte()", ["Imm"] = "15", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31], values[32], values[33], values[34], values[35], values[36], values[37], values[38], values[39], values[40], values[41], values[42], values[43], values[44], values[45], values[46], values[47], values[48], values[49], values[50], values[51], values[52], values[53], values[54], values[55], values[56], values[57], values[58], values[59], values[60], values[61], values[62], values[63]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetByte()", ["Imm"] = "31", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31], values[32], values[33], values[34], values[35], values[36], values[37], values[38], values[39], values[40], values[41], values[42], values[43], values[44], values[45], values[46], values[47], values[48], values[49], values[50], values[51], values[52], values[53], values[54], values[55], values[56], values[57], values[58], values[59], values[60], values[61], values[62], values[63]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetDouble()", ["Imm"] = "0", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetDouble()", ["Imm"] = "1", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetDouble()", ["Imm"] = "3", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt16()", ["Imm"] = "0", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt16()", ["Imm"] = "3", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt16()", ["Imm"] = "7", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt16()", ["Imm"] = "15", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt32()", ["Imm"] = "0", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt32()", ["Imm"] = "1", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt32()", ["Imm"] = "3", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt32()", ["Imm"] = "7", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt64()", ["Imm"] = "0", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt64()", ["Imm"] = "1", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt64()", ["Imm"] = "3", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSByte()", ["Imm"] = "0", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31], values[32], values[33], values[34], values[35], values[36], values[37], values[38], values[39], values[40], values[41], values[42], values[43], values[44], values[45], values[46], values[47], values[48], values[49], values[50], values[51], values[52], values[53], values[54], values[55], values[56], values[57], values[58], values[59], values[60], values[61], values[62], values[63]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSByte()", ["Imm"] = "7", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31], values[32], values[33], values[34], values[35], values[36], values[37], values[38], values[39], values[40], values[41], values[42], values[43], values[44], values[45], values[46], values[47], values[48], values[49], values[50], values[51], values[52], values[53], values[54], values[55], values[56], values[57], values[58], values[59], values[60], values[61], values[62], values[63]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSByte()", ["Imm"] = "15", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31], values[32], values[33], values[34], values[35], values[36], values[37], values[38], values[39], values[40], values[41], values[42], values[43], values[44], values[45], values[46], values[47], values[48], values[49], values[50], values[51], values[52], values[53], values[54], values[55], values[56], values[57], values[58], values[59], values[60], values[61], values[62], values[63]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSByte()", ["Imm"] = "31", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31], values[32], values[33], values[34], values[35], values[36], values[37], values[38], values[39], values[40], values[41], values[42], values[43], values[44], values[45], values[46], values[47], values[48], values[49], values[50], values[51], values[52], values[53], values[54], values[55], values[56], values[57], values[58], values[59], values[60], values[61], values[62], values[63]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSingle()", ["Imm"] = "0", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSingle()", ["Imm"] = "1", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSingle()", ["Imm"] = "3", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSingle()", ["Imm"] = "7", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt16()", ["Imm"] = "0", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt16()", ["Imm"] = "3", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt16()", ["Imm"] = "7", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt16()", ["Imm"] = "15", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt32()", ["Imm"] = "0", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt32()", ["Imm"] = "1", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt32()", ["Imm"] = "3", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt32()", ["Imm"] = "7", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt64()", ["Imm"] = "0", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt64()", ["Imm"] = "1", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]" }), + ("VectorGetAndWithElementTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithElement", ["VectorType"] = "Vector512", ["BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt64()", ["Imm"] = "3", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]" }), + + ("VectorGetAndWithLowerAndUpperTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithLowerAndUpper", ["VectorType"] = "Vector512", ["BaseType"] = "Byte", ["TgtVectorType"] = "Vector256", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetByte()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31], values[32], values[33], values[34], values[35], values[36], values[37], values[38], values[39], values[40], values[41], values[42], values[43], values[44], values[45], values[46], values[47], values[48], values[49], values[50], values[51], values[52], values[53], values[54], values[55], values[56], values[57], values[58], values[59], values[60], values[61], values[62], values[63]" }), + ("VectorGetAndWithLowerAndUpperTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithLowerAndUpper", ["VectorType"] = "Vector512", ["BaseType"] = "Double", ["TgtVectorType"] = "Vector256", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetDouble()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]" }), + ("VectorGetAndWithLowerAndUpperTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithLowerAndUpper", ["VectorType"] = "Vector512", ["BaseType"] = "Int16", ["TgtVectorType"] = "Vector256", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt16()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31]" }), + ("VectorGetAndWithLowerAndUpperTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithLowerAndUpper", ["VectorType"] = "Vector512", ["BaseType"] = "Int32", ["TgtVectorType"] = "Vector256", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt32()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorGetAndWithLowerAndUpperTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithLowerAndUpper", ["VectorType"] = "Vector512", ["BaseType"] = "Int64", ["TgtVectorType"] = "Vector256", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt64()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]" }), + ("VectorGetAndWithLowerAndUpperTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithLowerAndUpper", ["VectorType"] = "Vector512", ["BaseType"] = "SByte", ["TgtVectorType"] = "Vector256", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSByte()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31], values[32], values[33], values[34], values[35], values[36], values[37], values[38], values[39], values[40], values[41], values[42], values[43], values[44], values[45], values[46], values[47], values[48], values[49], values[50], values[51], values[52], values[53], values[54], values[55], values[56], values[57], values[58], values[59], values[60], values[61], values[62], values[63]" }), + ("VectorGetAndWithLowerAndUpperTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithLowerAndUpper", ["VectorType"] = "Vector512", ["BaseType"] = "Single", ["TgtVectorType"] = "Vector256", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSingle()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorGetAndWithLowerAndUpperTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithLowerAndUpper", ["VectorType"] = "Vector512", ["BaseType"] = "UInt16", ["TgtVectorType"] = "Vector256", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt16()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31]" }), + ("VectorGetAndWithLowerAndUpperTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithLowerAndUpper", ["VectorType"] = "Vector512", ["BaseType"] = "UInt32", ["TgtVectorType"] = "Vector256", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt32()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorGetAndWithLowerAndUpperTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "GetAndWithLowerAndUpper", ["VectorType"] = "Vector512", ["BaseType"] = "UInt64", ["TgtVectorType"] = "Vector256", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt64()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]" }), + + ("VectorToScalarTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ToScalar", ["VectorType"] = "Vector512", ["BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetByte()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31], values[32], values[33], values[34], values[35], values[36], values[37], values[38], values[39], values[40], values[41], values[42], values[43], values[44], values[45], values[46], values[47], values[48], values[49], values[50], values[51], values[52], values[53], values[54], values[55], values[56], values[57], values[58], values[59], values[60], values[61], values[62], values[63]" }), + ("VectorToScalarTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ToScalar", ["VectorType"] = "Vector512", ["BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetDouble()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]" }), + ("VectorToScalarTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ToScalar", ["VectorType"] = "Vector512", ["BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt16()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31]" }), + ("VectorToScalarTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ToScalar", ["VectorType"] = "Vector512", ["BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt32()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorToScalarTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ToScalar", ["VectorType"] = "Vector512", ["BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt64()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]" }), + ("VectorToScalarTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ToScalar", ["VectorType"] = "Vector512", ["BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSByte()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31], values[32], values[33], values[34], values[35], values[36], values[37], values[38], values[39], values[40], values[41], values[42], values[43], values[44], values[45], values[46], values[47], values[48], values[49], values[50], values[51], values[52], values[53], values[54], values[55], values[56], values[57], values[58], values[59], values[60], values[61], values[62], values[63]" }), + ("VectorToScalarTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ToScalar", ["VectorType"] = "Vector512", ["BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSingle()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorToScalarTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ToScalar", ["VectorType"] = "Vector512", ["BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt16()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31]" }), + ("VectorToScalarTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ToScalar", ["VectorType"] = "Vector512", ["BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt32()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorToScalarTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "ToScalar", ["VectorType"] = "Vector512", ["BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt64()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]" }), + + ("VectorToStringTest.template", new Dictionary {["Isa"] = "Vector512", ["Method"] = "ToString", ["VectorType"] = "Vector512", ["BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetByte()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31], values[32], values[33], values[34], values[35], values[36], values[37], values[38], values[39], values[40], values[41], values[42], values[43], values[44], values[45], values[46], values[47], values[48], values[49], values[50], values[51], values[52], values[53], values[54], values[55], values[56], values[57], values[58], values[59], values[60], values[61], values[62], values[63]" }), + ("VectorToStringTest.template", new Dictionary {["Isa"] = "Vector512", ["Method"] = "ToString", ["VectorType"] = "Vector512", ["BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSByte()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31], values[32], values[33], values[34], values[35], values[36], values[37], values[38], values[39], values[40], values[41], values[42], values[43], values[44], values[45], values[46], values[47], values[48], values[49], values[50], values[51], values[52], values[53], values[54], values[55], values[56], values[57], values[58], values[59], values[60], values[61], values[62], values[63]" }), + ("VectorToStringTest.template", new Dictionary {["Isa"] = "Vector512", ["Method"] = "ToString", ["VectorType"] = "Vector512", ["BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt16()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31]" }), + ("VectorToStringTest.template", new Dictionary {["Isa"] = "Vector512", ["Method"] = "ToString", ["VectorType"] = "Vector512", ["BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt16()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31]" }), + ("VectorToStringTest.template", new Dictionary {["Isa"] = "Vector512", ["Method"] = "ToString", ["VectorType"] = "Vector512", ["BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt32()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorToStringTest.template", new Dictionary {["Isa"] = "Vector512", ["Method"] = "ToString", ["VectorType"] = "Vector512", ["BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt32()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorToStringTest.template", new Dictionary {["Isa"] = "Vector512", ["Method"] = "ToString", ["VectorType"] = "Vector512", ["BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetSingle()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]" }), + ("VectorToStringTest.template", new Dictionary {["Isa"] = "Vector512", ["Method"] = "ToString", ["VectorType"] = "Vector512", ["BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetDouble()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]" }), + ("VectorToStringTest.template", new Dictionary {["Isa"] = "Vector512", ["Method"] = "ToString", ["VectorType"] = "Vector512", ["BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetInt64()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]" }), + ("VectorToStringTest.template", new Dictionary {["Isa"] = "Vector512", ["Method"] = "ToString", ["VectorType"] = "Vector512", ["BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp"] = "TestLibrary.Generator.GetUInt64()", ["ConsumeValues"] = "values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]" }), + + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Addition", ["Opcode"] = "+", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != (byte)(left[0] + right[0])", ["ValidateRemainingResults"] = "result[i] != (byte)(left[i] + right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Addition", ["Opcode"] = "+", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (double)(left[0] + right[0])", ["ValidateRemainingResults"] = "result[i] != (double)(left[i] + right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Addition", ["Opcode"] = "+", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != (short)(left[0] + right[0])", ["ValidateRemainingResults"] = "result[i] != (short)(left[i] + right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Addition", ["Opcode"] = "+", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (int)(left[0] + right[0])", ["ValidateRemainingResults"] = "result[i] != (int)(left[i] + right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Addition", ["Opcode"] = "+", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (long)(left[0] + right[0])", ["ValidateRemainingResults"] = "result[i] != (long)(left[i] + right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Addition", ["Opcode"] = "+", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != (sbyte)(left[0] + right[0])", ["ValidateRemainingResults"] = "result[i] != (sbyte)(left[i] + right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Addition", ["Opcode"] = "+", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (float)(left[0] + right[0])", ["ValidateRemainingResults"] = "result[i] != (float)(left[i] + right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Addition", ["Opcode"] = "+", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != (ushort)(left[0] + right[0])", ["ValidateRemainingResults"] = "result[i] != (ushort)(left[i] + right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Addition", ["Opcode"] = "+", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)(left[0] + right[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(left[i] + right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Addition", ["Opcode"] = "+", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)(left[0] + right[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(left[i] + right[i])" }), + + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_BitwiseAnd", ["Opcode"] = "&", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != (byte)(left[0] & right[0])", ["ValidateRemainingResults"] = "result[i] != (byte)(left[i] & right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_BitwiseAnd", ["Opcode"] = "&", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (BitConverter.DoubleToInt64Bits(left[0]) & BitConverter.DoubleToInt64Bits(right[0]))", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != (BitConverter.DoubleToInt64Bits(left[i]) & BitConverter.DoubleToInt64Bits(right[i]))" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_BitwiseAnd", ["Opcode"] = "&", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != (short)(left[0] & right[0])", ["ValidateRemainingResults"] = "result[i] != (short)(left[i] & right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_BitwiseAnd", ["Opcode"] = "&", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (int)(left[0] & right[0])", ["ValidateRemainingResults"] = "result[i] != (int)(left[i] & right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_BitwiseAnd", ["Opcode"] = "&", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (long)(left[0] & right[0])", ["ValidateRemainingResults"] = "result[i] != (long)(left[i] & right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_BitwiseAnd", ["Opcode"] = "&", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != (sbyte)(left[0] & right[0])", ["ValidateRemainingResults"] = "result[i] != (sbyte)(left[i] & right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_BitwiseAnd", ["Opcode"] = "&", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0]))", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != (BitConverter.SingleToInt32Bits(left[i]) & BitConverter.SingleToInt32Bits(right[i]))" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_BitwiseAnd", ["Opcode"] = "&", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != (ushort)(left[0] & right[0])", ["ValidateRemainingResults"] = "result[i] != (ushort)(left[i] & right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_BitwiseAnd", ["Opcode"] = "&", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)(left[0] & right[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(left[i] & right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_BitwiseAnd", ["Opcode"] = "&", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)(left[0] & right[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(left[i] & right[i])" }), + + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_BitwiseOr", ["Opcode"] = "|", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != (byte)(left[0] | right[0])", ["ValidateRemainingResults"] = "result[i] != (byte)(left[i] | right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_BitwiseOr", ["Opcode"] = "|", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (BitConverter.DoubleToInt64Bits(left[0]) | BitConverter.DoubleToInt64Bits(right[0]))", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != (BitConverter.DoubleToInt64Bits(left[i]) | BitConverter.DoubleToInt64Bits(right[i]))" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_BitwiseOr", ["Opcode"] = "|", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != (short)(left[0] | right[0])", ["ValidateRemainingResults"] = "result[i] != (short)(left[i] | right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_BitwiseOr", ["Opcode"] = "|", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (int)(left[0] | right[0])", ["ValidateRemainingResults"] = "result[i] != (int)(left[i] | right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_BitwiseOr", ["Opcode"] = "|", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (long)(left[0] | right[0])", ["ValidateRemainingResults"] = "result[i] != (long)(left[i] | right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_BitwiseOr", ["Opcode"] = "|", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != (sbyte)(left[0] | right[0])", ["ValidateRemainingResults"] = "result[i] != (sbyte)(left[i] | right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_BitwiseOr", ["Opcode"] = "|", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (BitConverter.SingleToInt32Bits(left[0]) | BitConverter.SingleToInt32Bits(right[0]))", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != (BitConverter.SingleToInt32Bits(left[i]) | BitConverter.SingleToInt32Bits(right[i]))" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_BitwiseOr", ["Opcode"] = "|", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != (ushort)(left[0] | right[0])", ["ValidateRemainingResults"] = "result[i] != (ushort)(left[i] | right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_BitwiseOr", ["Opcode"] = "|", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)(left[0] | right[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(left[i] | right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_BitwiseOr", ["Opcode"] = "|", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)(left[0] | right[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(left[i] | right[i])" }), + + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Division", ["Opcode"] = "/", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "Math.Max((byte)(1), TestLibrary.Generator.GetByte())", ["ValidateFirstResult"] = "result[0] != (byte)(left[0] / right[0])", ["ValidateRemainingResults"] = "result[i] != (byte)(left[i] / right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Division", ["Opcode"] = "/", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "Math.Max((double)(1), TestLibrary.Generator.GetDouble())", ["ValidateFirstResult"] = "result[0] != (double)(left[0] / right[0])", ["ValidateRemainingResults"] = "result[i] != (double)(left[i] / right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Division", ["Opcode"] = "/", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "Math.Max((short)(1), TestLibrary.Generator.GetInt16())", ["ValidateFirstResult"] = "result[0] != (short)(left[0] / right[0])", ["ValidateRemainingResults"] = "result[i] != (short)(left[i] / right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Division", ["Opcode"] = "/", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "Math.Max((int)(1), TestLibrary.Generator.GetInt32())", ["ValidateFirstResult"] = "result[0] != (int)(left[0] / right[0])", ["ValidateRemainingResults"] = "result[i] != (int)(left[i] / right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Division", ["Opcode"] = "/", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "Math.Max((long)(1), TestLibrary.Generator.GetInt64())", ["ValidateFirstResult"] = "result[0] != (long)(left[0] / right[0])", ["ValidateRemainingResults"] = "result[i] != (long)(left[i] / right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Division", ["Opcode"] = "/", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "Math.Max((sbyte)(1), TestLibrary.Generator.GetSByte())", ["ValidateFirstResult"] = "result[0] != (sbyte)(left[0] / right[0])", ["ValidateRemainingResults"] = "result[i] != (sbyte)(left[i] / right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Division", ["Opcode"] = "/", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "Math.Max((float)(1), TestLibrary.Generator.GetSingle())", ["ValidateFirstResult"] = "result[0] != (float)(left[0] / right[0])", ["ValidateRemainingResults"] = "result[i] != (float)(left[i] / right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Division", ["Opcode"] = "/", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "Math.Max((ushort)(1), TestLibrary.Generator.GetUInt16())", ["ValidateFirstResult"] = "result[0] != (ushort)(left[0] / right[0])", ["ValidateRemainingResults"] = "result[i] != (ushort)(left[i] / right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Division", ["Opcode"] = "/", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "Math.Max((uint)(1), TestLibrary.Generator.GetUInt32())", ["ValidateFirstResult"] = "result[0] != (uint)(left[0] / right[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(left[i] / right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Division", ["Opcode"] = "/", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "Math.Max((ulong)(1), TestLibrary.Generator.GetUInt64())", ["ValidateFirstResult"] = "result[0] != (ulong)(left[0] / right[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(left[i] / right[i])" }), + + ("VectorBooleanAllBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Equality", ["Opcode"] = "==", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAllBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Equality", ["Opcode"] = "==", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAllBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Equality", ["Opcode"] = "==", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAllBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Equality", ["Opcode"] = "==", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAllBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Equality", ["Opcode"] = "==", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAllBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Equality", ["Opcode"] = "==", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAllBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Equality", ["Opcode"] = "==", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAllBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Equality", ["Opcode"] = "==", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAllBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Equality", ["Opcode"] = "==", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + ("VectorBooleanAllBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Equality", ["Opcode"] = "==", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "left[i] == right[i]" }), + + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_ExclusiveOr", ["Opcode"] = "^", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != (byte)(left[0] ^ right[0])", ["ValidateRemainingResults"] = "result[i] != (byte)(left[i] ^ right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_ExclusiveOr", ["Opcode"] = "^", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (BitConverter.DoubleToInt64Bits(left[0]) ^ BitConverter.DoubleToInt64Bits(right[0]))", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != (BitConverter.DoubleToInt64Bits(left[i]) ^ BitConverter.DoubleToInt64Bits(right[i]))" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_ExclusiveOr", ["Opcode"] = "^", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != (short)(left[0] ^ right[0])", ["ValidateRemainingResults"] = "result[i] != (short)(left[i] ^ right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_ExclusiveOr", ["Opcode"] = "^", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (int)(left[0] ^ right[0])", ["ValidateRemainingResults"] = "result[i] != (int)(left[i] ^ right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_ExclusiveOr", ["Opcode"] = "^", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (long)(left[0] ^ right[0])", ["ValidateRemainingResults"] = "result[i] != (long)(left[i] ^ right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_ExclusiveOr", ["Opcode"] = "^", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != (sbyte)(left[0] ^ right[0])", ["ValidateRemainingResults"] = "result[i] != (sbyte)(left[i] ^ right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_ExclusiveOr", ["Opcode"] = "^", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (BitConverter.SingleToInt32Bits(left[0]) ^ BitConverter.SingleToInt32Bits(right[0]))", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != (BitConverter.SingleToInt32Bits(left[i]) ^ BitConverter.SingleToInt32Bits(right[i]))" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_ExclusiveOr", ["Opcode"] = "^", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != (ushort)(left[0] ^ right[0])", ["ValidateRemainingResults"] = "result[i] != (ushort)(left[i] ^ right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_ExclusiveOr", ["Opcode"] = "^", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)(left[0] ^ right[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(left[i] ^ right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_ExclusiveOr", ["Opcode"] = "^", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)(left[0] ^ right[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(left[i] ^ right[i])" }), + + ("VectorBooleanAnyBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Inequality", ["Opcode"] = "!=", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "left[i] != right[i]" }), + ("VectorBooleanAnyBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Inequality", ["Opcode"] = "!=", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "left[i] != right[i]" }), + ("VectorBooleanAnyBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Inequality", ["Opcode"] = "!=", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "left[i] != right[i]" }), + ("VectorBooleanAnyBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Inequality", ["Opcode"] = "!=", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "left[i] != right[i]" }), + ("VectorBooleanAnyBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Inequality", ["Opcode"] = "!=", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "left[i] != right[i]" }), + ("VectorBooleanAnyBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Inequality", ["Opcode"] = "!=", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "left[i] != right[i]" }), + ("VectorBooleanAnyBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Inequality", ["Opcode"] = "!=", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "left[i] != right[i]" }), + ("VectorBooleanAnyBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Inequality", ["Opcode"] = "!=", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "left[i] != right[i]" }), + ("VectorBooleanAnyBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Inequality", ["Opcode"] = "!=", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "left[i] != right[i]" }), + ("VectorBooleanAnyBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Inequality", ["Opcode"] = "!=", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "left[i] != right[i]" }), + + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Multiply", ["Opcode"] = "*", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != (byte)(left[0] * right[0])", ["ValidateRemainingResults"] = "result[i] != (byte)(left[i] * right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Multiply", ["Opcode"] = "*", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (double)(left[0] * right[0])", ["ValidateRemainingResults"] = "result[i] != (double)(left[i] * right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Multiply", ["Opcode"] = "*", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != (short)(left[0] * right[0])", ["ValidateRemainingResults"] = "result[i] != (short)(left[i] * right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Multiply", ["Opcode"] = "*", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (int)(left[0] * right[0])", ["ValidateRemainingResults"] = "result[i] != (int)(left[i] * right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Multiply", ["Opcode"] = "*", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (long)(left[0] * right[0])", ["ValidateRemainingResults"] = "result[i] != (long)(left[i] * right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Multiply", ["Opcode"] = "*", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != (sbyte)(left[0] * right[0])", ["ValidateRemainingResults"] = "result[i] != (sbyte)(left[i] * right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Multiply", ["Opcode"] = "*", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (float)(left[0] * right[0])", ["ValidateRemainingResults"] = "result[i] != (float)(left[i] * right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Multiply", ["Opcode"] = "*", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != (ushort)(left[0] * right[0])", ["ValidateRemainingResults"] = "result[i] != (ushort)(left[i] * right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Multiply", ["Opcode"] = "*", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)(left[0] * right[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(left[i] * right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Multiply", ["Opcode"] = "*", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)(left[0] * right[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(left[i] * right[i])" }), + + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_OnesComplement", ["Opcode"] = "~", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != (byte)(~firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (byte)(~firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_OnesComplement", ["Opcode"] = "~", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ~BitConverter.DoubleToInt64Bits(firstOp[0])", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ~BitConverter.DoubleToInt64Bits(firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_OnesComplement", ["Opcode"] = "~", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != (short)(~firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (short)(~firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_OnesComplement", ["Opcode"] = "~", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (int)(~firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (int)(~firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_OnesComplement", ["Opcode"] = "~", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (long)(~firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (long)(~firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_OnesComplement", ["Opcode"] = "~", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != (sbyte)(~firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (sbyte)(~firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_OnesComplement", ["Opcode"] = "~", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ~BitConverter.SingleToInt32Bits(firstOp[0])", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ~BitConverter.SingleToInt32Bits(firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_OnesComplement", ["Opcode"] = "~", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != (ushort)(~firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (ushort)(~firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_OnesComplement", ["Opcode"] = "~", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)(~firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(~firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_OnesComplement", ["Opcode"] = "~", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)(~firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(~firstOp[i])" }), + + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Subtraction", ["Opcode"] = "-", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != (byte)(left[0] - right[0])", ["ValidateRemainingResults"] = "result[i] != (byte)(left[i] - right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Subtraction", ["Opcode"] = "-", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (double)(left[0] - right[0])", ["ValidateRemainingResults"] = "result[i] != (double)(left[i] - right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Subtraction", ["Opcode"] = "-", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != (short)(left[0] - right[0])", ["ValidateRemainingResults"] = "result[i] != (short)(left[i] - right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Subtraction", ["Opcode"] = "-", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (int)(left[0] - right[0])", ["ValidateRemainingResults"] = "result[i] != (int)(left[i] - right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Subtraction", ["Opcode"] = "-", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (long)(left[0] - right[0])", ["ValidateRemainingResults"] = "result[i] != (long)(left[i] - right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Subtraction", ["Opcode"] = "-", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != (sbyte)(left[0] - right[0])", ["ValidateRemainingResults"] = "result[i] != (sbyte)(left[i] - right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Subtraction", ["Opcode"] = "-", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (float)(left[0] - right[0])", ["ValidateRemainingResults"] = "result[i] != (float)(left[i] - right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Subtraction", ["Opcode"] = "-", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != (ushort)(left[0] - right[0])", ["ValidateRemainingResults"] = "result[i] != (ushort)(left[i] - right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Subtraction", ["Opcode"] = "-", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)(left[0] - right[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(left[i] - right[i])" }), + ("VectorBinaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_Subtraction", ["Opcode"] = "-", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)(left[0] - right[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(left[i] - right[i])" }), + + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_UnaryNegation", ["Opcode"] = "-", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != (byte)(0 - firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (byte)(0 - firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_UnaryNegation", ["Opcode"] = "-", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (double)(0 - firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (double)(0 - firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_UnaryNegation", ["Opcode"] = "-", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != (short)(0 - firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (short)(0 - firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_UnaryNegation", ["Opcode"] = "-", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (int)(0 - firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (int)(0 - firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_UnaryNegation", ["Opcode"] = "-", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (long)(0 - firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (long)(0 - firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_UnaryNegation", ["Opcode"] = "-", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != (sbyte)(0 - firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (sbyte)(0 - firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_UnaryNegation", ["Opcode"] = "-", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (float)(0 - firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (float)(0 - firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_UnaryNegation", ["Opcode"] = "-", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != (ushort)(0 - firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (ushort)(0 - firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_UnaryNegation", ["Opcode"] = "-", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)(0 - firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(0 - firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_UnaryNegation", ["Opcode"] = "-", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)(0 - firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(0 - firstOp[i])" }), + + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_UnaryPlus", ["Opcode"] = "+", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "result[0] != (byte)(+firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (byte)(+firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_UnaryPlus", ["Opcode"] = "+", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (double)(+firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (double)(+firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_UnaryPlus", ["Opcode"] = "+", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != (short)(+firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (short)(+firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_UnaryPlus", ["Opcode"] = "+", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (int)(+firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (int)(+firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_UnaryPlus", ["Opcode"] = "+", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (long)(+firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (long)(+firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_UnaryPlus", ["Opcode"] = "+", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != (sbyte)(+firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (sbyte)(+firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_UnaryPlus", ["Opcode"] = "+", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (float)(+firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (float)(+firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_UnaryPlus", ["Opcode"] = "+", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != (ushort)(+firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (ushort)(+firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_UnaryPlus", ["Opcode"] = "+", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)(+firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(+firstOp[i])" }), + ("VectorUnaryOperatorTest.template", new Dictionary { ["Isa"] = "Vector512", ["Method"] = "op_UnaryPlus", ["Opcode"] = "+", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)(+firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(+firstOp[i])" }), +}; + (string templateFileName, Dictionary templateData)[] NotSupportedInputs = new [] { ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanZero", ["TargetType"] = "Vector64", ["Source"] = "Vector64", ["Method"] = "Zero" }), @@ -2152,6 +2831,52 @@ ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanWithUpper", ["TargetType"] = "Vector256", ["Source"] = "default(Vector256)", ["Method"] = "WithUpper(default(Vector128))" }), ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanToScalar", ["TargetType"] = "bool", ["Source"] = "default(Vector256)", ["Method"] = "ToScalar()" }), ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanToString", ["TargetType"] = "string", ["Source"] = "default(Vector256)", ["Method"] = "ToString()" }), + + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanZero", ["TargetType"] = "Vector512", ["Source"] = "Vector512", ["Method"] = "Zero" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAllBitsSet", ["TargetType"] = "Vector512", ["Source"] = "Vector512", ["Method"] = "AllBitsSet" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAsGeneric_Boolean", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "As()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512ByteAsGeneric_Boolean", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "As()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512DoubleAsGeneric_Boolean", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "As()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512Int16AsGeneric_Boolean", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "As()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512Int32AsGeneric_Boolean", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "As()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512Int64AsGeneric_Boolean", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "As()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512SByteAsGeneric_Boolean", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "As()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512SingleAsGeneric_Boolean", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "As()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512UInt16AsGeneric_Boolean", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "As()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512UInt32AsGeneric_Boolean", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "As()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512UInt64AsGeneric_Boolean", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "As()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAsGeneric_Byte", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "As()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAsGeneric_Double", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "As()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAsGeneric_Int16", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "As()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAsGeneric_Int32", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "As()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAsGeneric_Int64", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "As()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAsGeneric_SByte", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "As()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAsGeneric_Single", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "As()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAsGeneric_UInt16", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "As()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAsGeneric_UInt32", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "As()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAsGeneric_UInt64", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "As()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAsByte", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "AsByte()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAsDouble", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "AsDouble()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAsInt16", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "AsInt16()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAsInt32", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "AsInt32()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAsInt64", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "AsInt64()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAsSByte", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "AsSByte()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAsSingle", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "AsSingle()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAsUInt16", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "AsUInt16()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAsUInt32", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "AsUInt32()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanAsUInt64", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "AsUInt64()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanGetElementNegativeOne", ["TargetType"] = "bool", ["Source"] = "default(Vector512)", ["Method"] = "GetElement(-1)" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanGetElement0", ["TargetType"] = "bool", ["Source"] = "default(Vector512)", ["Method"] = "GetElement(0)" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanGetElementMaxValue", ["TargetType"] = "bool", ["Source"] = "default(Vector512)", ["Method"] = "GetElement(int.MaxValue)" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanWithElementNegativeOne", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "WithElement(-1, false)" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanWithElement0", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "WithElement(0, false)" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanWithElementMaxValue", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "WithElement(int.MaxValue, false)" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanGetLower", ["TargetType"] = "Vector256", ["Source"] = "default(Vector512)", ["Method"] = "GetLower()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanWithLower", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "WithLower(default(Vector256))" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanGetUpper", ["TargetType"] = "Vector256", ["Source"] = "default(Vector512)", ["Method"] = "GetUpper()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanWithUpper", ["TargetType"] = "Vector512", ["Source"] = "default(Vector512)", ["Method"] = "WithUpper(default(Vector256))" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanToScalar", ["TargetType"] = "bool", ["Source"] = "default(Vector512)", ["Method"] = "ToScalar()" }), + ("VectorNotSupportedTest.template", new Dictionary { ["Isa"] = "NotSupported", ["Name"] = "Vector512BooleanToString", ["TargetType"] = "string", ["Source"] = "default(Vector512)", ["Method"] = "ToString()" }), }; string projectName = args[0]; @@ -2165,6 +2890,8 @@ ProcessInputs("Vector128_1", Vector128_1Inputs); ProcessInputs("Vector256", Vector256Inputs); ProcessInputs("Vector256_1", Vector256_1Inputs); +ProcessInputs("Vector512", Vector512Inputs); +ProcessInputs("Vector512_1", Vector512_1Inputs); ProcessInputs("NotSupported", NotSupportedInputs); void ProcessInputs(string groupName, (string templateFileName, Dictionary templateData)[] inputs) diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Directory.Build.targets b/src/tests/JIT/HardwareIntrinsics/Arm/Directory.Build.targets index eca47c9c796ad..d72d49174ce0d 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Directory.Build.targets +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Directory.Build.targets @@ -3,6 +3,12 @@ + + + 1 + 0 + + $(IntermediateOutputPath)$(MSBuildProjectName)/gen/ $(GeneratedHWIntrinsicTestDirectory)GeneratedHWIntrinsicTestList.txt diff --git a/src/tests/JIT/HardwareIntrinsics/General/NotSupported/Program.NotSupported.cs b/src/tests/JIT/HardwareIntrinsics/General/NotSupported/Program.NotSupported.cs index d4dc67e5a24c2..6f112a813942b 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/NotSupported/Program.NotSupported.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/NotSupported/Program.NotSupported.cs @@ -10,7 +10,6 @@ public static partial class Program { static Program() { - } } } diff --git a/src/tests/JIT/HardwareIntrinsics/General/Regression/GitHub_75791/GitHub_75791.cs b/src/tests/JIT/HardwareIntrinsics/General/Regression/GitHub_75791/GitHub_75791.cs new file mode 100644 index 0000000000000..a0fcb1caf92a4 --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/General/Regression/GitHub_75791/GitHub_75791.cs @@ -0,0 +1,49 @@ +// Licensed to the .NET Foundation under one or more agreements.( +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +using Xunit; + +namespace GitHub_75791; + +public static class Program +{ + [Fact] + public static void TestVector512() + { + Assert.Equal(2.9288656946658405, Vector512.Dot( + Vector512.Create(0.28391050802823925, 0.33383399868214914, 0.6393570290293658, 0.9486867509591725, 0.03499340831637021, 0.8440502669865283, 0.9382154950924279, 0.9638167025024158), + Vector512.Create(0.1982700660390313, 0.3166301813003236, 0.6653102738185168, 0.9267781773486286, 0.8465606085980281, 0.9969451724464531, 0.2048630727349331, 0.4139565663463529) + )); + + Assert.Equal(3.1271863f, Vector512.Dot( + Vector512.Create(0.9997464f, 0.3368471f, 0.4043606f, 0.40446985f, 0.8205302f, 0.96234834f, 0.033238932f, 0.4785298f, 0.5980946f, 0.035252146f, 0.466319f, 0.48365256f, 0.95094615f, 0.76286495f, 0.058176957f, 0.044761457f), + Vector512.Create(0.192693f, 0.65009266f, 0.73478293f, 0.45294976f, 0.32503143f, 0.096156664f, 0.20120476f, 0.09926898f, 0.4980145f, 0.89575404f, 0.700502f, 0.92765516f, 0.06838739f, 0.7633024f, 0.5538336f, 0.83792007f) + )); + + Assert.Equal(5.161698f, Vector512.Dot( + Vector512.Create(0.024523573f, 0.9157307f, 0.81342965f, 0.975703f, 0.7373163f, 0.17368627f, 0.78028226f, 0.5694267f, 0.06921448f, 0.5432087f, 0.69687283f, 0.96234965f, 0.5256825f, 0.49651694f, 0.969829f, 0.3919952f), + Vector512.Create(0.90546f, 0.61288774f, 0.12319762f, 0.6599227f, 0.18527496f, 0.28016788f, 0.4850578f, 0.5630629f, 0.8017178f, 0.7248057f, 0.6808885f, 0.35055026f, 0.740812f, 0.5224796f, 0.6798979f, 0.97064143f) + )); + } + + [Fact] + public static void TestVector256() + { + Assert.Equal(1.8913451f, Vector256.Dot( + Vector256.Create(0.4797493f, 0.12908089f, 0.65387505f, 0.3784436f, 0.82727f, 0.25609037f, 0.72052014f, 0.11474159f), + Vector256.Create(0.4786259f, 0.17519481f, 0.47962677f, 0.19132254f, 0.9456166f, 0.88822955f, 0.291491f, 0.2903679f) + )); + } + + [Fact] + public static void TestVector128() + { + Assert.Equal(1.2333127f, Vector128.Dot( + Vector128.Create(0.5355215f, 0.9093521f, 0.9310961f, 0.11439307f), + Vector128.Create(0.500749f, 0.7528007f, 0.26315397f, 0.31093028f) + )); + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/General/Regression/GitHub_75791/GitHub_75791.csproj b/src/tests/JIT/HardwareIntrinsics/General/Regression/GitHub_75791/GitHub_75791.csproj new file mode 100644 index 0000000000000..74fe39137ccda --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/General/Regression/GitHub_75791/GitHub_75791.csproj @@ -0,0 +1,10 @@ + + + false + Embedded + True + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBinaryOpTest.template b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBinaryOpTest.template index 9fcc5929cacc6..54b276bdca1a5 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBinaryOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBinaryOpTest.template @@ -73,7 +73,7 @@ namespace JIT.HardwareIntrinsics.General int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>(); int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<{Op2BaseType}>(); int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<{RetBaseType}>(); - if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray) + if (!int.IsPow2(alignment) || (alignment > {LargestVectorSize}) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray) { throw new ArgumentException("Invalid value of alignment"); } diff --git a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBinaryOperatorTest.template b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBinaryOperatorTest.template index 02a466446bd8b..4d953387db0fe 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBinaryOperatorTest.template +++ b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBinaryOperatorTest.template @@ -73,7 +73,7 @@ namespace JIT.HardwareIntrinsics.General int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>(); int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<{Op2BaseType}>(); int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<{RetBaseType}>(); - if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray) + if (!int.IsPow2(alignment) || (alignment > {LargestVectorSize}) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray) { throw new ArgumentException("Invalid value of alignment"); } diff --git a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBooleanAllBinaryOpTest.template b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBooleanAllBinaryOpTest.template index e161eda691771..dfd258833e3b5 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBooleanAllBinaryOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBooleanAllBinaryOpTest.template @@ -70,7 +70,7 @@ namespace JIT.HardwareIntrinsics.General { int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>(); int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<{Op2BaseType}>(); - if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2) + if (!int.IsPow2(alignment) || (alignment > {LargestVectorSize}) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2) { throw new ArgumentException("Invalid value of alignment"); } diff --git a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBooleanAllBinaryOperatorTest.template b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBooleanAllBinaryOperatorTest.template index 3ce4c08b07067..3ed1bb9403fba 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBooleanAllBinaryOperatorTest.template +++ b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBooleanAllBinaryOperatorTest.template @@ -70,7 +70,7 @@ namespace JIT.HardwareIntrinsics.General { int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>(); int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<{Op2BaseType}>(); - if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2) + if (!int.IsPow2(alignment) || (alignment > {LargestVectorSize}) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2) { throw new ArgumentException("Invalid value of alignment"); } diff --git a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBooleanAnyBinaryOpTest.template b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBooleanAnyBinaryOpTest.template index b13e991ff9344..abe4eee604245 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBooleanAnyBinaryOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBooleanAnyBinaryOpTest.template @@ -70,7 +70,7 @@ namespace JIT.HardwareIntrinsics.General { int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>(); int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<{Op2BaseType}>(); - if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2) + if (!int.IsPow2(alignment) || (alignment > {LargestVectorSize}) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2) { throw new ArgumentException("Invalid value of alignment"); } diff --git a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBooleanAnyBinaryOperatorTest.template b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBooleanAnyBinaryOperatorTest.template index 8886e484b8bdb..7623b1721e86c 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBooleanAnyBinaryOperatorTest.template +++ b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorBooleanAnyBinaryOperatorTest.template @@ -70,7 +70,7 @@ namespace JIT.HardwareIntrinsics.General { int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>(); int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<{Op2BaseType}>(); - if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2) + if (!int.IsPow2(alignment) || (alignment > {LargestVectorSize}) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2) { throw new ArgumentException("Invalid value of alignment"); } diff --git a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorConvertToTest.template b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorConvertToTest.template index 8a282e1f286d2..3c6d8c0baab81 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorConvertToTest.template +++ b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorConvertToTest.template @@ -70,7 +70,7 @@ namespace JIT.HardwareIntrinsics.General { int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>(); int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<{RetBaseType}>(); - if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + if (!int.IsPow2(alignment) || (alignment > {LargestVectorSize}) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) { throw new ArgumentException("Invalid value of alignment"); } diff --git a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorDotTest.template b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorDotTest.template index dd48f391dad59..056dc05acc157 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorDotTest.template +++ b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorDotTest.template @@ -70,7 +70,7 @@ namespace JIT.HardwareIntrinsics.General { int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>(); int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<{Op2BaseType}>(); - if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2) + if (!int.IsPow2(alignment) || (alignment > {LargestVectorSize}) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2) { throw new ArgumentException("Invalid value of alignment"); } diff --git a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorNarrowTest.template b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorNarrowTest.template index cf51a67a44f11..44f109d4c6f7d 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorNarrowTest.template +++ b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorNarrowTest.template @@ -73,7 +73,7 @@ namespace JIT.HardwareIntrinsics.General int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>(); int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<{Op2BaseType}>(); int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<{RetBaseType}>(); - if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray) + if (!int.IsPow2(alignment) || (alignment > {LargestVectorSize}) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray) { throw new ArgumentException("Invalid value of alignment"); } diff --git a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorTernaryOpTest.template b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorTernaryOpTest.template index c3f02db8c5272..dd51391b96ddd 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorTernaryOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorTernaryOpTest.template @@ -76,7 +76,7 @@ namespace JIT.HardwareIntrinsics.General int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<{Op2BaseType}>(); int sizeOfinArray3 = inArray3.Length * Unsafe.SizeOf<{Op3BaseType}>(); int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<{RetBaseType}>(); - if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfinArray3 || (alignment * 2) < sizeOfoutArray) + if (!int.IsPow2(alignment) || (alignment > {LargestVectorSize}) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfinArray3 || (alignment * 2) < sizeOfoutArray) { throw new ArgumentException("Invalid value of alignment"); } diff --git a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorUnaryOpTest.template b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorUnaryOpTest.template index 5a6a1a1ccc70d..eb80b1cbde78e 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorUnaryOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorUnaryOpTest.template @@ -70,7 +70,7 @@ namespace JIT.HardwareIntrinsics.General { int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>(); int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<{RetBaseType}>(); - if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + if (!int.IsPow2(alignment) || (alignment > {LargestVectorSize}) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) { throw new ArgumentException("Invalid value of alignment"); } diff --git a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorUnaryOperatorTest.template b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorUnaryOperatorTest.template index 9dc5f9a49bb25..833b83cb90a01 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorUnaryOperatorTest.template +++ b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorUnaryOperatorTest.template @@ -70,7 +70,7 @@ namespace JIT.HardwareIntrinsics.General { int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>(); int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<{RetBaseType}>(); - if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + if (!int.IsPow2(alignment) || (alignment > {LargestVectorSize}) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) { throw new ArgumentException("Invalid value of alignment"); } diff --git a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorWidenTest.template b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorWidenTest.template index 07a350060623c..6952a04430094 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorWidenTest.template +++ b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorWidenTest.template @@ -73,7 +73,7 @@ namespace JIT.HardwareIntrinsics.General int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>(); int sizeOfoutLowerArray = outLowerArray.Length * Unsafe.SizeOf<{RetBaseType}>(); int sizeOfoutUpperArray = outUpperArray.Length * Unsafe.SizeOf<{RetBaseType}>(); - if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutLowerArray|| (alignment * 2) < sizeOfoutUpperArray) + if (!int.IsPow2(alignment) || (alignment > {LargestVectorSize}) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutLowerArray|| (alignment * 2) < sizeOfoutUpperArray) { throw new ArgumentException("Invalid value of alignment"); } diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector256/Vector256_r.csproj b/src/tests/JIT/HardwareIntrinsics/General/Vector256/Vector256_r.csproj index f9279746698a8..1ad7b2601c177 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector256/Vector256_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector256/Vector256_r.csproj @@ -7,6 +7,12 @@ Embedded + + + 1 + 0 + 0 + diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector256/Vector256_ro.csproj b/src/tests/JIT/HardwareIntrinsics/General/Vector256/Vector256_ro.csproj index d03724b0eb94f..daa0b7f4d8c15 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector256/Vector256_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector256/Vector256_ro.csproj @@ -7,6 +7,12 @@ Embedded True + + + 1 + 0 + 0 + diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector256_1/Vector256_1_r.csproj b/src/tests/JIT/HardwareIntrinsics/General/Vector256_1/Vector256_1_r.csproj index 9135dffd9f717..031be37c976c3 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector256_1/Vector256_1_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector256_1/Vector256_1_r.csproj @@ -11,6 +11,12 @@ Embedded + + + 1 + 0 + 0 + diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector256_1/Vector256_1_ro.csproj b/src/tests/JIT/HardwareIntrinsics/General/Vector256_1/Vector256_1_ro.csproj index 39657cac03cb4..a99b519a5a2b7 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector256_1/Vector256_1_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector256_1/Vector256_1_ro.csproj @@ -11,6 +11,12 @@ Embedded True + + + 1 + 0 + 0 + diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector512/Program.Vector512.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector512/Program.Vector512.cs new file mode 100644 index 0000000000000..0a265f854c82e --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector512/Program.Vector512.cs @@ -0,0 +1,15 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; + +namespace JIT.HardwareIntrinsics.General._Vector512 +{ + public static partial class Program + { + static Program() + { + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector512/Vector512_r.csproj b/src/tests/JIT/HardwareIntrinsics/General/Vector512/Vector512_r.csproj new file mode 100644 index 0000000000000..8d6eceaa60a0d --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector512/Vector512_r.csproj @@ -0,0 +1,19 @@ + + + false + true + + + Embedded + + + + + + 1 + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector512/Vector512_ro.csproj b/src/tests/JIT/HardwareIntrinsics/General/Vector512/Vector512_ro.csproj new file mode 100644 index 0000000000000..51c2ea352d587 --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector512/Vector512_ro.csproj @@ -0,0 +1,19 @@ + + + false + true + + + Embedded + True + + + + + 1 + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector512_1/Program.Vector512_1.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector512_1/Program.Vector512_1.cs new file mode 100644 index 0000000000000..e08c381abce7e --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector512_1/Program.Vector512_1.cs @@ -0,0 +1,15 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; + +namespace JIT.HardwareIntrinsics.General._Vector512_1 +{ + public static partial class Program + { + static Program() + { + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector512_1/Vector512_1_r.csproj b/src/tests/JIT/HardwareIntrinsics/General/Vector512_1/Vector512_1_r.csproj new file mode 100644 index 0000000000000..94400c3973315 --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector512_1/Vector512_1_r.csproj @@ -0,0 +1,19 @@ + + + false + true + + + Embedded + + + + + + 1 + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector512_1/Vector512_1_ro.csproj b/src/tests/JIT/HardwareIntrinsics/General/Vector512_1/Vector512_1_ro.csproj new file mode 100644 index 0000000000000..26184da1cda7b --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector512_1/Vector512_1_ro.csproj @@ -0,0 +1,19 @@ + + + false + true + + + Embedded + True + + + + + 1 + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector64/Vector64_r.csproj b/src/tests/JIT/HardwareIntrinsics/General/Vector64/Vector64_r.csproj index 276cca082987b..d71eca99ae913 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector64/Vector64_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector64/Vector64_r.csproj @@ -7,6 +7,11 @@ Embedded + + + 1 + 0 + diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector64/Vector64_ro.csproj b/src/tests/JIT/HardwareIntrinsics/General/Vector64/Vector64_ro.csproj index f387846f6cb65..0ecd27a1733a3 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector64/Vector64_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector64/Vector64_ro.csproj @@ -7,6 +7,11 @@ Embedded True + + + 1 + 0 + diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector64_1/Vector64_1_r.csproj b/src/tests/JIT/HardwareIntrinsics/General/Vector64_1/Vector64_1_r.csproj index 6446da14a204d..07d32d1a24b8e 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector64_1/Vector64_1_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector64_1/Vector64_1_r.csproj @@ -7,6 +7,11 @@ Embedded + + + 1 + 0 + diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector64_1/Vector64_1_ro.csproj b/src/tests/JIT/HardwareIntrinsics/General/Vector64_1/Vector64_1_ro.csproj index 03657d6139634..89d71c8f7af65 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector64_1/Vector64_1_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector64_1/Vector64_1_ro.csproj @@ -7,6 +7,11 @@ Embedded True + + + 1 + 0 + diff --git a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_r.csproj b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_r.csproj index 78073132763bb..d81af3a381450 100644 --- a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_r.csproj @@ -4,9 +4,28 @@ 20 true true + + <_IncludeArm64HWIntrinsicTests>false + <_IncludeArm64HWIntrinsicTests Condition="'$(CLRTestPriorityToBuild)' >= '1' OR '$(TargetArchitecture)' == 'arm64'">true + <_IncludeXarchHWIntrinsicTests>false + <_IncludeXarchHWIntrinsicTests Condition="'$(CLRTestPriorityToBuild)' >= '1' OR '$(TargetArchitecture)' == 'x64' OR ('$(TargetArchitecture)' == 'x86' AND '$(TargetsWindows)' == 'true')">true + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_ro.csproj b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_ro.csproj index c926b276bad50..cec6dbb86c481 100644 --- a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_ro.csproj @@ -4,11 +4,29 @@ 20 true true + + <_IncludeArm64HWIntrinsicTests>false + <_IncludeArm64HWIntrinsicTests Condition="'$(CLRTestPriorityToBuild)' >= '1' OR '$(TargetArchitecture)' == 'arm64'">true + <_IncludeXarchHWIntrinsicTests>false + <_IncludeXarchHWIntrinsicTests Condition="'$(CLRTestPriorityToBuild)' >= '1' OR '$(TargetArchitecture)' == 'x64' OR ('$(TargetArchitecture)' == 'x86' AND '$(TargetsWindows)' == 'true')">true + - - - + + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Directory.Build.targets b/src/tests/JIT/HardwareIntrinsics/X86/Directory.Build.targets index 933c13be21e6a..77fd5e210fc55 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Directory.Build.targets +++ b/src/tests/JIT/HardwareIntrinsics/X86/Directory.Build.targets @@ -3,6 +3,13 @@ + + + 1 + 0 + 0 + + $(IntermediateOutputPath)$(MSBuildProjectName)/gen/ $(GeneratedHWIntrinsicTestDirectory)GeneratedHWIntrinsicTestList.txt diff --git a/src/tests/build.proj b/src/tests/build.proj index e156a911555be..8342197ba3339 100644 --- a/src/tests/build.proj +++ b/src/tests/build.proj @@ -135,7 +135,7 @@ - + diff --git a/src/tests/issues.targets b/src/tests/issues.targets index b9d3cea98928c..d2586148f4e21 100644 --- a/src/tests/issues.targets +++ b/src/tests/issues.targets @@ -907,6 +907,12 @@ Not compatible with multifile testing. Problem with detecting that a JIT intrinsic is reflection-used. + + Not compatible with multifile testing. Problem with detecting that a JIT intrinsic is reflection-used. + + + Not compatible with multifile testing. Problem with detecting that a JIT intrinsic is reflection-used. + Not compatible with multifile testing. @@ -1081,6 +1087,12 @@ https://github.com/dotnet/runtimelab/issues/184 + + https://github.com/dotnet/runtimelab/issues/184 + + + https://github.com/dotnet/runtimelab/issues/184 + https://github.com/dotnet/runtimelab/issues/190 @@ -3086,7 +3098,6 @@ Reflection.Emit is not supported on fullaot - @@ -3331,6 +3342,9 @@ https://github.com/dotnet/runtime/issues/54867 + + https://github.com/dotnet/runtime/issues/54122 + https://github.com/dotnet/runtime/issues/54122 diff --git a/src/tests/readytorun/fieldlayout/fieldlayouttests.cs b/src/tests/readytorun/fieldlayout/fieldlayouttests.cs index 9b42185965364..cbd03e37abfeb 100644 --- a/src/tests/readytorun/fieldlayout/fieldlayouttests.cs +++ b/src/tests/readytorun/fieldlayout/fieldlayouttests.cs @@ -12,7 +12,9 @@ static int Main() SequentialTest.Test(); AutoTest.Test(); EnumAlignmentTest.Test(); - AutoTestWithVector.Test(); + AutoTestWithVector128.Test(); + AutoTestWithVector256.Test(); + AutoTestWithVector512.Test(); return 100; } } @@ -160,7 +162,7 @@ public static void Test() } } -class AutoTestWithVector +class AutoTestWithVector128 { static Auto.int8x16x2 _fld1 = new Auto.int8x16x2(); static Auto.Wrapper_int8x16x2 _fld2 = new Auto.Wrapper_int8x16x2(); @@ -178,6 +180,42 @@ public static void Test() } } +class AutoTestWithVector256 +{ + static Auto.int8x32x2 _fld1 = new Auto.int8x32x2(); + static Auto.Wrapper_int8x32x2 _fld2 = new Auto.Wrapper_int8x32x2(); + static Auto.Wrapper_int8x32x2_2 _fld3 = new Auto.Wrapper_int8x32x2_2(); + + public static void Test() + { + _fld1._0 = new Vector256(); + _fld1._1 = new Vector256(); + + _fld2.fld = _fld1; + + _fld3.fld1 = true; + _fld3.fld2 = _fld1; + } +} + +class AutoTestWithVector512 +{ + static Auto.int8x64x2 _fld1 = new Auto.int8x64x2(); + static Auto.Wrapper_int8x64x2 _fld2 = new Auto.Wrapper_int8x64x2(); + static Auto.Wrapper_int8x64x2_2 _fld3 = new Auto.Wrapper_int8x64x2_2(); + + public static void Test() + { + _fld1._0 = new Vector512(); + _fld1._1 = new Vector512(); + + _fld2.fld = _fld1; + + _fld3.fld1 = true; + _fld3.fld2 = _fld1; + } +} + class SequentialTest { static Sequential.Class1 _fld1 = new Sequential.Class1();