From 89e9b35f0269cdd5e4320ecab4b8000a10611c2a Mon Sep 17 00:00:00 2001 From: Tanner Gooding Date: Tue, 22 Jul 2025 23:18:43 -0700 Subject: [PATCH 01/10] Adding the vector constants property extensions that are only supported for certain T --- .../CompatibilitySuppressions.xml | 94 ++ .../System.Private.CoreLib.csproj | 4 + src/coreclr/jit/fgbasic.cpp | 36 + src/coreclr/jit/hwintrinsicarm64.cpp | 156 ++++ src/coreclr/jit/hwintrinsiccodegenxarch.cpp | 2 +- src/coreclr/jit/hwintrinsiclistarm64.h | 18 + src/coreclr/jit/hwintrinsiclistxarch.h | 31 +- src/coreclr/jit/hwintrinsicxarch.cpp | 165 ++++ .../ref/System.Numerics.Vectors.cs | 18 + .../tests/GenericVectorTests.cs | 94 ++ .../tests/Matrix3x2Tests.cs | 6 +- .../tests/Matrix4x4Tests.cs | 12 +- .../src/CompatibilitySuppressions.xml | 2 +- .../Text/Base64Helper/Base64DecoderHelper.cs | 2 +- .../src/System/Collections/BitArray.cs | 8 +- .../src/System/Numerics/Matrix3x2.Impl.cs | 2 +- .../src/System/Numerics/Matrix4x4.Impl.cs | 4 +- .../src/System/Numerics/Plane.cs | 2 +- .../src/System/Numerics/Vector.cs | 90 +- .../src/System/Numerics/Vector_1.cs | 4 +- .../Intrinsics/SimdVectorExtensions.cs | 2 + .../System/Runtime/Intrinsics/Vector128.cs | 95 +- .../System/Runtime/Intrinsics/Vector128_1.cs | 4 +- .../System/Runtime/Intrinsics/Vector256.cs | 90 +- .../System/Runtime/Intrinsics/Vector256_1.cs | 4 +- .../System/Runtime/Intrinsics/Vector512.cs | 90 +- .../System/Runtime/Intrinsics/Vector512_1.cs | 4 +- .../src/System/Runtime/Intrinsics/Vector64.cs | 90 +- .../System/Runtime/Intrinsics/Vector64_1.cs | 4 +- .../src/System/SpanHelpers.Packed.cs | 2 +- .../ref/System.Runtime.Intrinsics.cs | 72 ++ .../tests/Vectors/Vector128Tests.cs | 98 +- .../tests/Vectors/Vector256Tests.cs | 98 +- .../tests/Vectors/Vector512Tests.cs | 98 +- .../tests/Vectors/Vector64Tests.cs | 98 +- .../tests/Wasm/PackedSimdTests.cs | 10 +- .../JIT/Directed/StructABI/structreturn.cs | 24 +- .../General/HwiOp/CompareVectorWithZero.cs | 256 +++--- .../X86/General/VectorRet.cs | 4 +- .../Regression/GitHub_17073/GitHub_17073.cs | 840 +++++++++--------- .../GitHub_17073/GitHub_17073_gen.csx | 10 +- .../BilinearInterpol/BilinearInterpol.cs | 4 +- .../HWIntrinsic/X86/PacketTracer/Camera.cs | 2 +- .../X86/PacketTracer/Intersections.cs | 2 +- .../X86/PacketTracer/PacketTracer.cs | 4 +- .../HWIntrinsic/X86/PacketTracer/Surfaces.cs | 4 +- .../JitBlue/GitHub_19583/GitHub_19583.cs | 2 +- .../JitBlue/GitHub_23530/GitHub_23530.cs | 2 +- .../ImageSharp_2117/ImageSharp_2117.cs | 4 +- .../JitBlue/Runtime_106546/Runtime_106546.cs | 2 +- .../JitBlue/Runtime_108609/Runtime_108609.cs | 8 +- .../JitBlue/Runtime_33972/Runtime_33972.cs | 32 +- .../JitBlue/Runtime_39737/Runtime_39737.cs | 4 +- .../JitBlue/Runtime_72506/Runtime_72506.cs | 8 +- .../JitBlue/Runtime_90508/Runtime_90508.cs | 2 +- .../JitBlue/Runtime_91252/Runtime_91252.cs | 4 +- .../JitBlue/Runtime_91335/Runtime_91335.cs | 6 +- .../JitBlue/Runtime_92357/Runtime_92357.cs | 4 +- .../JitBlue/Runtime_92590/Runtime_92590.cs | 8 +- .../opt/Loops/LoopSideEffectsForHwiStores.cs | 4 +- 60 files changed, 2158 insertions(+), 691 deletions(-) create mode 100644 src/coreclr/System.Private.CoreLib/CompatibilitySuppressions.xml diff --git a/src/coreclr/System.Private.CoreLib/CompatibilitySuppressions.xml b/src/coreclr/System.Private.CoreLib/CompatibilitySuppressions.xml new file mode 100644 index 00000000000000..eeca822db2da0c --- /dev/null +++ b/src/coreclr/System.Private.CoreLib/CompatibilitySuppressions.xml @@ -0,0 +1,94 @@ + + + + + CP0001 + T:System.Numerics.Vector.<>E__0`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Numerics.Vector.<>E__1`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Numerics.Vector.<>E__2`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector128.<>E__0`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector128.<>E__1`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector128.<>E__2`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector256.<>E__0`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector256.<>E__1`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector256.<>E__2`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector512.<>E__0`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector512.<>E__1`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector512.<>E__2`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector64.<>E__0`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector64.<>E__1`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector64.<>E__2`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + diff --git a/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj b/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj index 2fb4c3e7ffa6bb..ffb4e3179f85fd 100644 --- a/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj +++ b/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj @@ -24,6 +24,10 @@ true + + + + diff --git a/src/coreclr/jit/fgbasic.cpp b/src/coreclr/jit/fgbasic.cpp index 12f4521eb75f0d..5440b50afec469 100644 --- a/src/coreclr/jit/fgbasic.cpp +++ b/src/coreclr/jit/fgbasic.cpp @@ -1479,18 +1479,54 @@ void Compiler::fgFindJumpTargets(const BYTE* codeAddr, IL_OFFSET codeSize, Fixed #if defined(FEATURE_HW_INTRINSICS) #if defined(TARGET_ARM64) case NI_Vector64_get_AllBitsSet: + case NI_Vector64_get_E: + case NI_Vector64_get_Epsilon: + case NI_Vector64_get_NaN: + case NI_Vector64_get_NegativeInfinity: + case NI_Vector64_get_NegativeOne: + case NI_Vector64_get_NegativeZero: case NI_Vector64_get_One: + case NI_Vector64_get_Pi: + case NI_Vector64_get_PositiveInfinity: + case NI_Vector64_get_Tau: case NI_Vector64_get_Zero: #endif // TARGET_ARM64 case NI_Vector128_get_AllBitsSet: + case NI_Vector128_get_E: + case NI_Vector128_get_Epsilon: + case NI_Vector128_get_NaN: + case NI_Vector128_get_NegativeInfinity: + case NI_Vector128_get_NegativeOne: + case NI_Vector128_get_NegativeZero: case NI_Vector128_get_One: + case NI_Vector128_get_Pi: + case NI_Vector128_get_PositiveInfinity: + case NI_Vector128_get_Tau: case NI_Vector128_get_Zero: #if defined(TARGET_XARCH) case NI_Vector256_get_AllBitsSet: + case NI_Vector256_get_E: + case NI_Vector256_get_Epsilon: + case NI_Vector256_get_NaN: + case NI_Vector256_get_NegativeInfinity: + case NI_Vector256_get_NegativeOne: + case NI_Vector256_get_NegativeZero: case NI_Vector256_get_One: + case NI_Vector256_get_Pi: + case NI_Vector256_get_PositiveInfinity: + case NI_Vector256_get_Tau: case NI_Vector256_get_Zero: case NI_Vector512_get_AllBitsSet: + case NI_Vector512_get_E: + case NI_Vector512_get_Epsilon: + case NI_Vector512_get_NaN: + case NI_Vector512_get_NegativeInfinity: + case NI_Vector512_get_NegativeOne: + case NI_Vector512_get_NegativeZero: case NI_Vector512_get_One: + case NI_Vector512_get_Pi: + case NI_Vector512_get_PositiveInfinity: + case NI_Vector512_get_Tau: case NI_Vector512_get_Zero: #endif // TARGET_XARCH #endif // FEATURE_HW_INTRINSICS diff --git a/src/coreclr/jit/hwintrinsicarm64.cpp b/src/coreclr/jit/hwintrinsicarm64.cpp index a30689eef76e83..22f4e1b787538f 100644 --- a/src/coreclr/jit/hwintrinsicarm64.cpp +++ b/src/coreclr/jit/hwintrinsicarm64.cpp @@ -1398,6 +1398,40 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, break; } + case NI_Vector64_get_E: + case NI_Vector128_get_E: + { + assert(sig->numArgs == 0); + + if (varTypeIsFloating(simdBaseType)) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(simdBaseType, 2.718281828459045); + retNode = vecCns; + } + break; + } + + case NI_Vector64_get_Epsilon: + case NI_Vector128_get_Epsilon: + { + assert(sig->numArgs == 0); + + if (simdBaseType == TYP_FLOAT) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(TYP_INT, I64(0x00000001)); + retNode = vecCns; + } + else if (simdBaseType == TYP_DOUBLE) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(TYP_LONG, I64(0x0000000000000001)); + retNode = vecCns; + } + break; + } + case NI_Vector64_get_Indices: case NI_Vector128_get_Indices: { @@ -1406,6 +1440,80 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, break; } + case NI_Vector64_get_NaN: + case NI_Vector128_get_NaN: + { + assert(sig->numArgs == 0); + + if (simdBaseType == TYP_FLOAT) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(TYP_INT, I64(0x7FC00000)); + retNode = vecCns; + } + else if (simdBaseType == TYP_DOUBLE) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(TYP_LONG, I64(0x7FF8000000000000)); + retNode = vecCns; + } + break; + } + + case NI_Vector64_get_NegativeInfinity: + case NI_Vector128_get_NegativeInfinity: + { + assert(sig->numArgs == 0); + + if (simdBaseType == TYP_FLOAT) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(TYP_INT, I64(0xFF800000)); + retNode = vecCns; + } + else if (simdBaseType == TYP_DOUBLE) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(TYP_LONG, I64(0xFFF0000000000000)); + retNode = vecCns; + } + break; + } + + case NI_Vector64_get_NegativeOne: + case NI_Vector128_get_NegativeOne: + { + assert(sig->numArgs == 0); + + if (varTypeIsFloating(simdBaseType)) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(simdBaseType, -1.0); + retNode = vecCns; + } + else if (varTypeIsSigned(simdBaseType)) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(simdBaseType, I64(-1)); + retNode = vecCns; + } + break; + } + + case NI_Vector64_get_NegativeZero: + case NI_Vector128_get_NegativeZero: + { + assert(sig->numArgs == 0); + + if (varTypeIsFloating(simdBaseType)) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(simdBaseType, -0.0); + retNode = vecCns; + } + break; + } + case NI_Vector64_get_One: case NI_Vector128_get_One: { @@ -1414,6 +1522,54 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, break; } + case NI_Vector64_get_Pi: + case NI_Vector128_get_Pi: + { + assert(sig->numArgs == 0); + + if (varTypeIsFloating(simdBaseType)) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(simdBaseType, 3.141592653589793); + retNode = vecCns; + } + break; + } + + case NI_Vector64_get_PositiveInfinity: + case NI_Vector128_get_PositiveInfinity: + { + assert(sig->numArgs == 0); + + if (simdBaseType == TYP_FLOAT) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(TYP_INT, I64(0x7F800000)); + retNode = vecCns; + } + else if (simdBaseType == TYP_DOUBLE) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(TYP_LONG, I64(0x7FF0000000000000)); + retNode = vecCns; + } + break; + } + + case NI_Vector64_get_Tau: + case NI_Vector128_get_Tau: + { + assert(sig->numArgs == 0); + + if (varTypeIsFloating(simdBaseType)) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(simdBaseType, 6.283185307179586); + retNode = vecCns; + } + break; + } + case NI_Vector64_get_Zero: case NI_Vector128_get_Zero: { diff --git a/src/coreclr/jit/hwintrinsiccodegenxarch.cpp b/src/coreclr/jit/hwintrinsiccodegenxarch.cpp index 209ccd5337c046..ef8724124f1bf0 100644 --- a/src/coreclr/jit/hwintrinsiccodegenxarch.cpp +++ b/src/coreclr/jit/hwintrinsiccodegenxarch.cpp @@ -2346,7 +2346,7 @@ void CodeGen::genBaseIntrinsic(GenTreeHWIntrinsic* node, insOpts instOptions) // // Vector128 overflowMask = // Vector128.Equals(op1, Vector128.Create(int.MinValue) - // & Vector128.Equals(op2, Vector128.Create(-1)); + // & Vector128.Equals(op2, Vector128.NegativeOne); // if (!Vector128.EqualsAll(overflowMask, Vector128.Zero)) // { // throw new OverflowException(); diff --git a/src/coreclr/jit/hwintrinsiclistarm64.h b/src/coreclr/jit/hwintrinsiclistarm64.h index ec721f567c50f3..9e3d0a4f8fea7d 100644 --- a/src/coreclr/jit/hwintrinsiclistarm64.h +++ b/src/coreclr/jit/hwintrinsiclistarm64.h @@ -115,8 +115,17 @@ HARDWARE_INTRINSIC(Vector64, WidenLower, HARDWARE_INTRINSIC(Vector64, WidenUpper, 8, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg) HARDWARE_INTRINSIC(Vector64, WithElement, 8, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport) HARDWARE_INTRINSIC(Vector64, get_AllBitsSet, 8, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector64, get_E, 8, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector64, get_Epsilon, 8, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector64, get_Indices, 8, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector64, get_NaN, 8, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector64, get_NegativeInfinity, 8, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector64, get_NegativeOne, 8, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector64, get_NegativeZero, 8, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector64, get_One, 8, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector64, get_Pi, 8, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector64, get_PositiveInfinity, 8, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector64, get_Tau, 8, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector64, get_Zero, 8, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector64, op_Addition, 8, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector64, op_BitwiseAnd, 8, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId|HW_Flag_Commutative) @@ -248,8 +257,17 @@ HARDWARE_INTRINSIC(Vector128, WithElement, HARDWARE_INTRINSIC(Vector128, WithLower, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen) HARDWARE_INTRINSIC(Vector128, WithUpper, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen) HARDWARE_INTRINSIC(Vector128, get_AllBitsSet, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector128, get_E, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector128, get_Epsilon, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector128, get_Indices, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector128, get_NaN, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector128, get_NegativeInfinity, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector128, get_NegativeOne, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector128, get_NegativeZero, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector128, get_One, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector128, get_Pi, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector128, get_PositiveInfinity, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector128, get_Tau, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector128, get_Zero, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector128, op_Addition, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector128, op_BitwiseAnd, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId|HW_Flag_Commutative) diff --git a/src/coreclr/jit/hwintrinsiclistxarch.h b/src/coreclr/jit/hwintrinsiclistxarch.h index be680becff0b52..406c0de231a15a 100644 --- a/src/coreclr/jit/hwintrinsiclistxarch.h +++ b/src/coreclr/jit/hwintrinsiclistxarch.h @@ -134,8 +134,17 @@ HARDWARE_INTRINSIC(Vector128, WidenLower, HARDWARE_INTRINSIC(Vector128, WidenUpper, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg) HARDWARE_INTRINSIC(Vector128, WithElement, 16, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoContainment|HW_Flag_BaseTypeFromFirstArg) HARDWARE_INTRINSIC(Vector128, get_AllBitsSet, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector128, get_E, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector128, get_Epsilon, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector128, get_Indices, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector128, get_NaN, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector128, get_NegativeInfinity, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector128, get_NegativeOne, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector128, get_NegativeZero, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector128, get_One, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector128, get_Pi, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector128, get_PositiveInfinity, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector128, get_Tau, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector128, get_Zero, 16, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector128, op_Addition, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector128, op_BitwiseAnd, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) @@ -264,10 +273,19 @@ HARDWARE_INTRINSIC(Vector256, WidenUpper, HARDWARE_INTRINSIC(Vector256, WithElement, 32, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoContainment|HW_Flag_BaseTypeFromFirstArg|HW_Flag_AvxOnlyCompatible) HARDWARE_INTRINSIC(Vector256, WithLower, 32, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_AvxOnlyCompatible) HARDWARE_INTRINSIC(Vector256, WithUpper, 32, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_AvxOnlyCompatible) -HARDWARE_INTRINSIC(Vector256, get_AllBitsSet, 32, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId|HW_Flag_AvxOnlyCompatible) +HARDWARE_INTRINSIC(Vector256, get_AllBitsSet, 32, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector256, get_E, 32, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector256, get_Epsilon, 32, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector256, get_Indices, 32, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector256, get_NaN, 32, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector256, get_NegativeInfinity, 32, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector256, get_NegativeOne, 32, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector256, get_NegativeZero, 32, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector256, get_One, 32, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) -HARDWARE_INTRINSIC(Vector256, get_Zero, 32, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId|HW_Flag_AvxOnlyCompatible) +HARDWARE_INTRINSIC(Vector256, get_Pi, 32, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector256, get_PositiveInfinity, 32, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector256, get_Tau, 32, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector256, get_Zero, 32, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector256, op_Addition, 32, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector256, op_BitwiseAnd, 32, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId|HW_Flag_AvxOnlyCompatible) HARDWARE_INTRINSIC(Vector256, op_BitwiseOr, 32, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId|HW_Flag_AvxOnlyCompatible) @@ -395,8 +413,17 @@ HARDWARE_INTRINSIC(Vector512, WithElement, HARDWARE_INTRINSIC(Vector512, WithLower, 64, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen) HARDWARE_INTRINSIC(Vector512, WithUpper, 64, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen) HARDWARE_INTRINSIC(Vector512, get_AllBitsSet, 64, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector512, get_E, 64, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector512, get_Epsilon, 64, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector512, get_Indices, 64, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector512, get_NaN, 64, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector512, get_NegativeInfinity, 64, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector512, get_NegativeOne, 64, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector512, get_NegativeZero, 64, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector512, get_One, 64, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector512, get_Pi, 64, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector512, get_PositiveInfinity, 64, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) +HARDWARE_INTRINSIC(Vector512, get_Tau, 64, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector512, get_Zero, 64, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector512, op_Addition, 64, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(Vector512, op_BitwiseAnd, 64, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) diff --git a/src/coreclr/jit/hwintrinsicxarch.cpp b/src/coreclr/jit/hwintrinsicxarch.cpp index c614918b2074d5..1ae9124435ce1e 100644 --- a/src/coreclr/jit/hwintrinsicxarch.cpp +++ b/src/coreclr/jit/hwintrinsicxarch.cpp @@ -2528,6 +2528,42 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, break; } + case NI_Vector128_get_E: + case NI_Vector256_get_E: + case NI_Vector512_get_E: + { + assert(sig->numArgs == 0); + + if (varTypeIsFloating(simdBaseType)) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(simdBaseType, 2.718281828459045); + retNode = vecCns; + } + break; + } + + case NI_Vector128_get_Epsilon: + case NI_Vector256_get_Epsilon: + case NI_Vector512_get_Epsilon: + { + assert(sig->numArgs == 0); + + if (simdBaseType == TYP_FLOAT) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(TYP_INT, I64(0x00000001)); + retNode = vecCns; + } + else if (simdBaseType == TYP_DOUBLE) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(TYP_LONG, I64(0x0000000000000001)); + retNode = vecCns; + } + break; + } + case NI_Vector128_get_Indices: case NI_Vector256_get_Indices: case NI_Vector512_get_Indices: @@ -2537,6 +2573,84 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, break; } + case NI_Vector128_get_NaN: + case NI_Vector256_get_NaN: + case NI_Vector512_get_NaN: + { + assert(sig->numArgs == 0); + + if (simdBaseType == TYP_FLOAT) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(TYP_INT, I64(0xFFC00000)); + retNode = vecCns; + } + else if (simdBaseType == TYP_DOUBLE) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(TYP_LONG, I64(0xFFF8000000000000)); + retNode = vecCns; + } + break; + } + + case NI_Vector128_get_NegativeInfinity: + case NI_Vector256_get_NegativeInfinity: + case NI_Vector512_get_NegativeInfinity: + { + assert(sig->numArgs == 0); + + if (simdBaseType == TYP_FLOAT) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(TYP_INT, I64(0xFF800000)); + retNode = vecCns; + } + else if (simdBaseType == TYP_DOUBLE) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(TYP_LONG, I64(0xFFF0000000000000)); + retNode = vecCns; + } + break; + } + + case NI_Vector128_get_NegativeOne: + case NI_Vector256_get_NegativeOne: + case NI_Vector512_get_NegativeOne: + { + assert(sig->numArgs == 0); + + if (varTypeIsFloating(simdBaseType)) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(simdBaseType, -1.0); + retNode = vecCns; + } + else if (varTypeIsSigned(simdBaseType)) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(simdBaseType, I64(-1)); + retNode = vecCns; + } + break; + } + + case NI_Vector128_get_NegativeZero: + case NI_Vector256_get_NegativeZero: + case NI_Vector512_get_NegativeZero: + { + assert(sig->numArgs == 0); + + if (varTypeIsFloating(simdBaseType)) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(simdBaseType, -0.0); + retNode = vecCns; + } + break; + } + case NI_Vector128_get_One: case NI_Vector256_get_One: case NI_Vector512_get_One: @@ -2546,6 +2660,57 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, break; } + case NI_Vector128_get_Pi: + case NI_Vector256_get_Pi: + case NI_Vector512_get_Pi: + { + assert(sig->numArgs == 0); + + if (varTypeIsFloating(simdBaseType)) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(simdBaseType, 3.141592653589793); + retNode = vecCns; + } + break; + } + + case NI_Vector128_get_PositiveInfinity: + case NI_Vector256_get_PositiveInfinity: + case NI_Vector512_get_PositiveInfinity: + { + assert(sig->numArgs == 0); + + if (simdBaseType == TYP_FLOAT) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(TYP_INT, I64(0x7F800000)); + retNode = vecCns; + } + else if (simdBaseType == TYP_DOUBLE) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(TYP_LONG, I64(0x7FF0000000000000)); + retNode = vecCns; + } + break; + } + + case NI_Vector128_get_Tau: + case NI_Vector256_get_Tau: + case NI_Vector512_get_Tau: + { + assert(sig->numArgs == 0); + + if (varTypeIsFloating(simdBaseType)) + { + GenTreeVecCon* vecCns = gtNewVconNode(retType); + vecCns->EvaluateBroadcastInPlace(simdBaseType, 6.283185307179586); + retNode = vecCns; + } + break; + } + case NI_Vector128_get_Zero: case NI_Vector256_get_Zero: case NI_Vector512_get_Zero: diff --git a/src/libraries/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs b/src/libraries/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs index b8643c54d9c81d..f816c820aa67e7 100644 --- a/src/libraries/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs +++ b/src/libraries/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs @@ -573,6 +573,24 @@ public static partial class Vector public static System.Numerics.Vector3 WithElement(this System.Numerics.Vector3 vector, int index, float value) { throw null; } public static System.Numerics.Vector4 WithElement(this System.Numerics.Vector4 vector, int index, float value) { throw null; } public static System.Numerics.Vector Xor(System.Numerics.Vector left, System.Numerics.Vector right) { throw null; } + extension(Vector) where T : System.Numerics.IFloatingPointConstants + { + public static System.Numerics.Vector E { get { throw null; } } + public static System.Numerics.Vector Pi { get { throw null; } } + public static System.Numerics.Vector Tau { get { throw null; } } + } + extension(Vector) where T : System.Numerics.IFloatingPointIeee754 + { + public static System.Numerics.Vector Epsilon { get { throw null; } } + public static System.Numerics.Vector NaN { get { throw null; } } + public static System.Numerics.Vector NegativeInfinity { get { throw null; } } + public static System.Numerics.Vector NegativeZero { get { throw null; } } + public static System.Numerics.Vector PositiveInfinity { get { throw null; } } + } + extension(Vector) where T : System.Numerics.ISignedNumber + { + public static System.Numerics.Vector NegativeOne { get { throw null; } } + } } public partial struct Vector2 : System.IEquatable, System.IFormattable { diff --git a/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs b/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs index b5f4568a628285..052a4ce76c4918 100644 --- a/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs +++ b/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs @@ -6079,5 +6079,99 @@ public void SubtractSaturateSByteTest() [Fact] public void SubtractSaturateUIntPtrTest() => SubtractSaturateToMinTest(1); + + [Fact] + public void EDoubleTest() => TestConstant(Vector.E, double.E); + + [Fact] + public void ESingleTest() => TestConstant(Vector.E, float.E); + + [Fact] + public void EpsilonDoubleTest() => TestConstant(Vector.Epsilon, double.Epsilon); + + [Fact] + public void EpsilonSingleTest() => TestConstant(Vector.Epsilon, float.Epsilon); + + [Fact] + public void NaNDoubleTest() => TestConstant(Vector.NaN, double.NaN); + + [Fact] + public void NaNSingleTest() => TestConstant(Vector.NaN, float.NaN); + + [Fact] + public void NegativeInfinityDoubleTest() => TestConstant(Vector.NegativeInfinity, double.NegativeInfinity); + + [Fact] + public void NegativeInfinitySingleTest() => TestConstant(Vector.NegativeInfinity, float.NegativeInfinity); + + [Fact] + public void NegativeOneDoubleTest() => TestConstant(Vector.NegativeOne, -1.0); + + [Fact] + public void NegativeOneInt16Test() => TestConstant(Vector.NegativeOne, -1); + + [Fact] + public void NegativeOneInt32Test() => TestConstant(Vector.NegativeOne, -1); + + [Fact] + public void NegativeOneInt64Test() => TestConstant(Vector.NegativeOne, -1); + + [Fact] + public void NegativeOneSByteTest() => TestConstant(Vector.NegativeOne, -1); + + [Fact] + public void NegativeOneSingleTest() => TestConstant(Vector.NegativeOne, -1.0f); + + [Fact] + public void NegativeZeroDoubleTest() => TestConstant(Vector.NegativeZero, double.NegativeZero); + + [Fact] + public void NegativeZeroSingleTest() => TestConstant(Vector.NegativeZero, float.NegativeZero); + + [Fact] + public void PiDoubleTest() => TestConstant(Vector.Pi, double.Pi); + + [Fact] + public void PiSingleTest() => TestConstant(Vector.Pi, float.Pi); + + [Fact] + public void PositiveInfinityDoubleTest() => TestConstant(Vector.PositiveInfinity, double.PositiveInfinity); + + [Fact] + public void PositiveInfinitySingleTest() => TestConstant(Vector.PositiveInfinity, float.PositiveInfinity); + + [Fact] + public void TauDoubleTest() => TestConstant(Vector.Tau, double.Tau); + + [Fact] + public void TauSingleTest() => TestConstant(Vector.Tau, float.Tau); + + [MethodImpl(MethodImplOptions.NoInlining)] + private void TestConstant(Vector actual, double expected) + { + for (int i = 0; i < Vector.Count; i++) + { + Assert.Equal(BitConverter.DoubleToInt64Bits(expected), BitConverter.DoubleToInt64Bits(actual[i])); + } + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private void TestConstant(Vector actual, float expected) + { + for (int i = 0; i < Vector.Count; i++) + { + Assert.Equal(BitConverter.SingleToInt32Bits(expected), BitConverter.SingleToInt32Bits(actual[i])); + } + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private void TestConstant(Vector actual, T expected) + where T : IBinaryInteger + { + for (int i = 0; i < Vector.Count; i++) + { + Assert.Equal(expected, actual[i]); + } + } } } diff --git a/src/libraries/System.Numerics.Vectors/tests/Matrix3x2Tests.cs b/src/libraries/System.Numerics.Vectors/tests/Matrix3x2Tests.cs index f06cc4e73dcfa8..4371b7b7b6e053 100644 --- a/src/libraries/System.Numerics.Vectors/tests/Matrix3x2Tests.cs +++ b/src/libraries/System.Numerics.Vectors/tests/Matrix3x2Tests.cs @@ -1089,9 +1089,9 @@ public void Matrix3x2CreateBroadcastScalarTest() { Matrix3x2 a = Matrix3x2.Create(float.Pi); - Assert.Equal(Vector2.Create(float.Pi), a.X); - Assert.Equal(Vector2.Create(float.Pi), a.Y); - Assert.Equal(Vector2.Create(float.Pi), a.Z); + Assert.Equal(Vector2.Pi, a.X); + Assert.Equal(Vector2.Pi, a.Y); + Assert.Equal(Vector2.Pi, a.Z); } [Fact] diff --git a/src/libraries/System.Numerics.Vectors/tests/Matrix4x4Tests.cs b/src/libraries/System.Numerics.Vectors/tests/Matrix4x4Tests.cs index 87e035215ede69..1ae9921d78babe 100644 --- a/src/libraries/System.Numerics.Vectors/tests/Matrix4x4Tests.cs +++ b/src/libraries/System.Numerics.Vectors/tests/Matrix4x4Tests.cs @@ -67,14 +67,14 @@ private static Matrix4x4 GenerateTestMatrix() // The handedness-swapped matrix of matrix M is B^-1 * M * B where B is the change of handedness matrix. // Since only the Z coordinate is flipped when changing handedness, - // + // // B = [ 1 0 0 0 // 0 1 0 0 // 0 0 -1 0 // 0 0 0 1 ] // // and B is its own inverse. So the handedness swap can be simplified to - // + // // B^-1 * M * B = [ m11 m12 -m13 m14 // m21 m22 -m23 m24 // -m31 -m32 m33 -m34 @@ -3174,10 +3174,10 @@ public void Matrix4x4CreateBroadcastScalarTest() { Matrix4x4 a = Matrix4x4.Create(float.Pi); - Assert.Equal(Vector4.Create(float.Pi), a.X); - Assert.Equal(Vector4.Create(float.Pi), a.Y); - Assert.Equal(Vector4.Create(float.Pi), a.Z); - Assert.Equal(Vector4.Create(float.Pi), a.W); + Assert.Equal(Vector4.Pi, a.X); + Assert.Equal(Vector4.Pi, a.Y); + Assert.Equal(Vector4.Pi, a.Z); + Assert.Equal(Vector4.Pi, a.W); } [Fact] diff --git a/src/libraries/System.Private.CoreLib/src/CompatibilitySuppressions.xml b/src/libraries/System.Private.CoreLib/src/CompatibilitySuppressions.xml index 21e9323f9e7168..01683374a671f8 100644 --- a/src/libraries/System.Private.CoreLib/src/CompatibilitySuppressions.xml +++ b/src/libraries/System.Private.CoreLib/src/CompatibilitySuppressions.xml @@ -1,5 +1,5 @@  - + CP0001 diff --git a/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Base64Helper/Base64DecoderHelper.cs b/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Base64Helper/Base64DecoderHelper.cs index 37b8c4bb97cf96..8c6e002b46c800 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Base64Helper/Base64DecoderHelper.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Base64Helper/Base64DecoderHelper.cs @@ -1069,7 +1069,7 @@ private static unsafe void Vector128Decode(TBase64Decoder dec Vector128 packBytesMask = Vector128.Create(0x06000102, 0x090A0405, 0x0C0D0E08, 0xffffffff).AsSByte(); Vector128 mergeConstant0 = Vector128.Create(0x01400140).AsByte(); Vector128 mergeConstant1 = Vector128.Create(0x00011000).AsInt16(); - Vector128 one = Vector128.Create((byte)1); + Vector128 one = Vector128.One; Vector128 mask2F = Vector128.Create(decoder.MaskSlashOrUnderscore); Vector128 mask8F = Vector128.Create((byte)0x8F); Vector128 shiftForUnderscore = Vector128.Create((byte)33); diff --git a/src/libraries/System.Private.CoreLib/src/System/Collections/BitArray.cs b/src/libraries/System.Private.CoreLib/src/System/Collections/BitArray.cs index 66fe6f6c37eff6..773d178d34e1d7 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Collections/BitArray.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Collections/BitArray.cs @@ -744,7 +744,7 @@ public unsafe void CopyTo(Array array, int index) Vector256 lowerShuffleMask_CopyToBoolArray256 = Vector256.Create(lowerShuffleMask_CopyToBoolArray, upperShuffleMask_CopyToBoolArray); Vector512 shuffleMask = Vector512.Create(lowerShuffleMask_CopyToBoolArray256, upperShuffleMask_CopyToBoolArray256); Vector512 bitMask = Vector512.Create(0x80402010_08040201).AsByte(); - Vector512 ones = Vector512.Create((byte)1); + Vector512 ones = Vector512.One; fixed (bool* destination = &boolArray[index]) { @@ -766,7 +766,7 @@ public unsafe void CopyTo(Array array, int index) { Vector256 shuffleMask = Vector256.Create(lowerShuffleMask_CopyToBoolArray, upperShuffleMask_CopyToBoolArray); Vector256 bitMask = Vector256.Create(0x80402010_08040201).AsByte(); - Vector256 ones = Vector256.Create((byte)1); + Vector256 ones = Vector256.One; fixed (bool* destination = &boolArray[index]) { @@ -788,7 +788,7 @@ public unsafe void CopyTo(Array array, int index) { Vector128 lowerShuffleMask = lowerShuffleMask_CopyToBoolArray; Vector128 upperShuffleMask = upperShuffleMask_CopyToBoolArray; - Vector128 ones = Vector128.Create((byte)1); + Vector128 ones = Vector128.One; Vector128 bitMask128 = Vector128.Create(0x80402010_08040201).AsByte(); fixed (bool* destination = &boolArray[index]) @@ -812,7 +812,7 @@ public unsafe void CopyTo(Array array, int index) } else if (AdvSimd.Arm64.IsSupported) { - Vector128 ones = Vector128.Create((byte)1); + Vector128 ones = Vector128.One; Vector128 bitMask128 = Vector128.Create(0x80402010_08040201).AsByte(); fixed (bool* destination = &boolArray[index]) diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Matrix3x2.Impl.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Matrix3x2.Impl.cs index 09815c5089a570..12aed8626dd75a 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Numerics/Matrix3x2.Impl.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/Matrix3x2.Impl.cs @@ -357,7 +357,7 @@ public static bool Invert(in Impl matrix, out Impl result) if (float.Abs(det) < float.Epsilon) { - Vector2 vNaN = Vector2.Create(float.NaN); + Vector2 vNaN = Vector2.NaN; result.X = vNaN; result.Y = vNaN; diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Matrix4x4.Impl.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Matrix4x4.Impl.cs index 708d1e03b1b945..3ff84c8e9de3b3 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Numerics/Matrix4x4.Impl.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/Matrix4x4.Impl.cs @@ -1286,7 +1286,7 @@ static bool SseImpl(in Impl matrix, out Impl result) // Check determinate is not zero if (float.Abs(det) < float.Epsilon) { - Vector4 vNaN = Vector4.Create(float.NaN); + Vector4 vNaN = Vector4.NaN; result.X = vNaN; result.Y = vNaN; @@ -1424,7 +1424,7 @@ static bool SoftwareFallback(in Impl matrix, out Impl result) if (float.Abs(det) < float.Epsilon) { - Vector4 vNaN = Vector4.Create(float.NaN); + Vector4 vNaN = Vector4.NaN; result.X = vNaN; result.Y = vNaN; diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Plane.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Plane.cs index 5e756f452c9a92..dab451045467cd 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Numerics/Plane.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/Plane.cs @@ -133,7 +133,7 @@ public static Plane Normalize(Plane value) return Vector128.AndNot( (value.AsVector128() / Vector128.Sqrt(lengthSquared)), - Vector128.Equals(lengthSquared, Vector128.Create(float.PositiveInfinity)) + Vector128.Equals(lengthSquared, Vector128.PositiveInfinity) ).AsPlane(); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs index f80cba2809dc12..ceccc9aebd9305 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs @@ -23,6 +23,84 @@ public static bool IsHardwareAccelerated get => IsHardwareAccelerated; } + /// The type of the elements in the vector. + extension(Vector) + where T : IFloatingPointConstants + { + /// + public static Vector E + { + [Intrinsic] + get => Create(T.E); + } + + /// + public static Vector Pi + { + [Intrinsic] + get => Create(T.Pi); + } + + /// + public static Vector Tau + { + [Intrinsic] + get => Create(T.Tau); + } + } + + /// The type of the elements in the vector. + extension(Vector) + where T : IFloatingPointIeee754 + { + /// + public static Vector Epsilon + { + [Intrinsic] + get => Create(T.Epsilon); + } + + /// + public static Vector NaN + { + [Intrinsic] + get => Create(T.NaN); + } + + /// + public static Vector NegativeInfinity + { + [Intrinsic] + get => Create(T.NegativeInfinity); + } + + /// + public static Vector NegativeZero + { + [Intrinsic] + get => Create(T.NegativeZero); + } + + /// + public static Vector PositiveInfinity + { + [Intrinsic] + get => Create(T.PositiveInfinity); + } + } + + /// The type of the elements in the vector. + extension(Vector) + where T : ISignedNumber + { + /// + public static Vector NegativeOne + { + [Intrinsic] + get => Create(T.NegativeOne); + } + } + /// Computes the absolute value of each element in a vector. /// The vector that will have its absolute value computed. /// The type of the elements in the vector. @@ -1405,11 +1483,11 @@ public static Vector IsFinite(Vector vector) { if (typeof(T) == typeof(float)) { - return ~IsZero(AndNot(Create(float.PositiveInfinityBits), vector.As())).As(); + return ~IsZero(AndNot(Vector.PositiveInfinity.As(), vector.As())).As(); } else if (typeof(T) == typeof(double)) { - return ~IsZero(AndNot(Create(double.PositiveInfinityBits), vector.As())).As(); + return ~IsZero(AndNot(Vector.PositiveInfinity.As(), vector.As())).As(); } return Vector.AllBitsSet; } @@ -1484,11 +1562,11 @@ public static Vector IsNegativeInfinity(Vector vector) { if (typeof(T) == typeof(float)) { - return Equals(vector, Create(float.NegativeInfinity).As()); + return Equals(vector, Vector.NegativeInfinity.As()); } else if (typeof(T) == typeof(double)) { - return Equals(vector, Create(double.NegativeInfinity).As()); + return Equals(vector, Vector.NegativeInfinity.As()); } return Vector.Zero; } @@ -1559,11 +1637,11 @@ public static Vector IsPositiveInfinity(Vector vector) { if (typeof(T) == typeof(float)) { - return Equals(vector, Create(float.PositiveInfinity).As()); + return Equals(vector, Vector.PositiveInfinity.As()); } else if (typeof(T) == typeof(double)) { - return Equals(vector, Create(double.PositiveInfinity).As()); + return Equals(vector, Vector.PositiveInfinity.As()); } return Vector.Zero; } diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector_1.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector_1.cs index 3cea422e72c638..9799c31049649f 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector_1.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector_1.cs @@ -577,11 +577,11 @@ public static Vector operator >>(Vector value, int shiftCount) { if (typeof(T) == typeof(float)) { - return value ^ Vector.Create(-0.0f).As(); + return value ^ Vector.NegativeZero.As(); } else if (typeof(T) == typeof(double)) { - return value ^ Vector.Create(-0.0).As(); + return value ^ Vector.NegativeZero.As(); } else { diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/SimdVectorExtensions.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/SimdVectorExtensions.cs index 74b3e7729a5d4f..666497b294eaa2 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/SimdVectorExtensions.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/SimdVectorExtensions.cs @@ -1,6 +1,8 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System.Numerics; + namespace System.Runtime.Intrinsics { internal static unsafe class SimdVectorExtensions diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs index 6aac6ab0314a74..e26aaf0effb926 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs @@ -49,6 +49,93 @@ public static bool IsHardwareAccelerated get => IsHardwareAccelerated; } + /// The type of the elements in the vector. + extension(Vector128) + where T : IFloatingPointConstants + { + /// Gets a new vector with all elements initialized to . + /// The type of the current instance () is not supported. + public static Vector128 E + { + [Intrinsic] + get => Create(T.E); + } + + /// Gets a new vector with all elements initialized to . + /// The type of the current instance () is not supported. + public static Vector128 Pi + { + [Intrinsic] + get => Create(T.Pi); + } + + /// Gets a new vector with all elements initialized to . + /// The type of the current instance () is not supported. + public static Vector128 Tau + { + [Intrinsic] + get => Create(T.Tau); + } + } + + /// The type of the elements in the vector. + extension(Vector128) + where T : IFloatingPointIeee754 + { + /// Gets a new vector with all elements initialized to . + /// The type of the current instance () is not supported. + public static Vector128 Epsilon + { + [Intrinsic] + get => Create(T.Epsilon); + } + + /// Gets a new vector with all elements initialized to . + /// The type of the current instance () is not supported. + public static Vector128 NaN + { + [Intrinsic] + get => Create(T.NaN); + } + + /// Gets a new vector with all elements initialized to . + /// The type of the current instance () is not supported. + public static Vector128 NegativeInfinity + { + [Intrinsic] + get => Create(T.NegativeInfinity); + } + + /// Gets a new vector with all elements initialized to . + /// The type of the current instance () is not supported. + public static Vector128 NegativeZero + { + [Intrinsic] + get => Create(T.NegativeZero); + } + + /// Gets a new vector with all elements initialized to . + /// The type of the current instance () is not supported. + public static Vector128 PositiveInfinity + { + [Intrinsic] + get => Create(T.PositiveInfinity); + } + } + + /// The type of the elements in the vector. + extension(Vector128) + where T : ISignedNumber + { + /// Gets a new vector with all elements initialized to . + /// The type of the current instance () is not supported. + public static Vector128 NegativeOne + { + [Intrinsic] + get => Create(T.NegativeOne); + } + } + /// 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. @@ -1970,11 +2057,11 @@ public static Vector128 IsNegativeInfinity(Vector128 vector) { if (typeof(T) == typeof(float)) { - return Equals(vector, Create(float.NegativeInfinity).As()); + return Equals(vector, Vector128.NegativeInfinity.As()); } else if (typeof(T) == typeof(double)) { - return Equals(vector, Create(double.NegativeInfinity).As()); + return Equals(vector, Vector128.NegativeInfinity.As()); } return Vector128.Zero; } @@ -2045,11 +2132,11 @@ public static Vector128 IsPositiveInfinity(Vector128 vector) { if (typeof(T) == typeof(float)) { - return Equals(vector, Create(float.PositiveInfinity).As()); + return Equals(vector, Vector128.PositiveInfinity.As()); } else if (typeof(T) == typeof(double)) { - return Equals(vector, Create(double.PositiveInfinity).As()); + return Equals(vector, Vector128.PositiveInfinity.As()); } return Vector128.Zero; } 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 bfcf28021c5845..7c8e8a8a75073d 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 @@ -342,11 +342,11 @@ public static Vector128 operator >>(Vector128 value, int shiftCount) { if (typeof(T) == typeof(float)) { - return vector ^ Vector128.Create(-0.0f).As(); + return vector ^ Vector128.NegativeZero.As(); } else if (typeof(T) == typeof(double)) { - return vector ^ Vector128.Create(-0.0).As(); + return vector ^ Vector128.NegativeZero.As(); } else { 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 397b6428656ec3..573eb014c7051c 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 @@ -52,6 +52,84 @@ public static bool IsHardwareAccelerated get => IsHardwareAccelerated; } + /// The type of the elements in the vector. + extension(Vector256) + where T : IFloatingPointConstants + { + /// + public static Vector256 E + { + [Intrinsic] + get => Create(T.E); + } + + /// + public static Vector256 Pi + { + [Intrinsic] + get => Create(T.Pi); + } + + /// + public static Vector256 Tau + { + [Intrinsic] + get => Create(T.Tau); + } + } + + /// The type of the elements in the vector. + extension(Vector256) + where T : IFloatingPointIeee754 + { + /// + public static Vector256 Epsilon + { + [Intrinsic] + get => Create(T.Epsilon); + } + + /// + public static Vector256 NaN + { + [Intrinsic] + get => Create(T.NaN); + } + + /// + public static Vector256 NegativeInfinity + { + [Intrinsic] + get => Create(T.NegativeInfinity); + } + + /// + public static Vector256 NegativeZero + { + [Intrinsic] + get => Create(T.NegativeZero); + } + + /// + public static Vector256 PositiveInfinity + { + [Intrinsic] + get => Create(T.PositiveInfinity); + } + } + + /// The type of the elements in the vector. + extension(Vector256) + where T : ISignedNumber + { + /// + public static Vector256 NegativeOne + { + [Intrinsic] + get => Create(T.NegativeOne); + } + } + /// 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. @@ -1984,11 +2062,11 @@ public static Vector256 IsFinite(Vector256 vector) { if (typeof(T) == typeof(float)) { - return ~IsZero(AndNot(Create(float.PositiveInfinityBits), vector.AsUInt32())).As(); + return ~IsZero(AndNot(Vector256.PositiveInfinity.AsUInt32(), vector.AsUInt32())).As(); } else if (typeof(T) == typeof(double)) { - return ~IsZero(AndNot(Create(double.PositiveInfinityBits), vector.AsUInt64())).As(); + return ~IsZero(AndNot(Vector256.PositiveInfinity.AsUInt64(), vector.AsUInt64())).As(); } return Vector256.AllBitsSet; } @@ -2063,11 +2141,11 @@ public static Vector256 IsNegativeInfinity(Vector256 vector) { if (typeof(T) == typeof(float)) { - return Equals(vector, Create(float.NegativeInfinity).As()); + return Equals(vector, Vector256.NegativeInfinity.As()); } else if (typeof(T) == typeof(double)) { - return Equals(vector, Create(double.NegativeInfinity).As()); + return Equals(vector, Vector256.NegativeInfinity.As()); } return Vector256.Zero; } @@ -2138,11 +2216,11 @@ public static Vector256 IsPositiveInfinity(Vector256 vector) { if (typeof(T) == typeof(float)) { - return Equals(vector, Create(float.PositiveInfinity).As()); + return Equals(vector, Vector256.PositiveInfinity.As()); } else if (typeof(T) == typeof(double)) { - return Equals(vector, Create(double.PositiveInfinity).As()); + return Equals(vector, Vector256.PositiveInfinity.As()); } return Vector256.Zero; } 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 d9fdbd88f3db9d..1e1e4e713a59d0 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 @@ -340,11 +340,11 @@ public static Vector256 operator >>(Vector256 value, int shiftCount) { if (typeof(T) == typeof(float)) { - return vector ^ Vector256.Create(-0.0f).As(); + return vector ^ Vector256.NegativeZero.As(); } else if (typeof(T) == typeof(double)) { - return vector ^ Vector256.Create(-0.0).As(); + return vector ^ Vector256.NegativeZero.As(); } else { 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 index 85b780a3271b66..c993d274408257 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs @@ -51,6 +51,84 @@ public static bool IsHardwareAccelerated get => IsHardwareAccelerated; } + /// The type of the elements in the vector. + extension(Vector512) + where T : IFloatingPointConstants + { + /// + public static Vector512 E + { + [Intrinsic] + get => Create(T.E); + } + + /// + public static Vector512 Pi + { + [Intrinsic] + get => Create(T.Pi); + } + + /// + public static Vector512 Tau + { + [Intrinsic] + get => Create(T.Tau); + } + } + + /// The type of the elements in the vector. + extension(Vector512) + where T : IFloatingPointIeee754 + { + /// + public static Vector512 Epsilon + { + [Intrinsic] + get => Create(T.Epsilon); + } + + /// + public static Vector512 NaN + { + [Intrinsic] + get => Create(T.NaN); + } + + /// + public static Vector512 NegativeInfinity + { + [Intrinsic] + get => Create(T.NegativeInfinity); + } + + /// + public static Vector512 NegativeZero + { + [Intrinsic] + get => Create(T.NegativeZero); + } + + /// + public static Vector512 PositiveInfinity + { + [Intrinsic] + get => Create(T.PositiveInfinity); + } + } + + /// The type of the elements in the vector. + extension(Vector512) + where T : ISignedNumber + { + /// + public static Vector512 NegativeOne + { + [Intrinsic] + get => Create(T.NegativeOne); + } + } + /// 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. @@ -2010,11 +2088,11 @@ public static Vector512 IsFinite(Vector512 vector) { if (typeof(T) == typeof(float)) { - return ~IsZero(AndNot(Create(float.PositiveInfinityBits), vector.AsUInt32())).As(); + return ~IsZero(AndNot(Vector512.PositiveInfinity.AsUInt32(), vector.AsUInt32())).As(); } else if (typeof(T) == typeof(double)) { - return ~IsZero(AndNot(Create(double.PositiveInfinityBits), vector.AsUInt64())).As(); + return ~IsZero(AndNot(Vector512.PositiveInfinity.AsUInt64(), vector.AsUInt64())).As(); } return Vector512.AllBitsSet; } @@ -2089,11 +2167,11 @@ public static Vector512 IsNegativeInfinity(Vector512 vector) { if (typeof(T) == typeof(float)) { - return Equals(vector, Create(float.NegativeInfinity).As()); + return Equals(vector, Vector512.NegativeInfinity.As()); } else if (typeof(T) == typeof(double)) { - return Equals(vector, Create(double.NegativeInfinity).As()); + return Equals(vector, Vector512.NegativeInfinity.As()); } return Vector512.Zero; } @@ -2164,11 +2242,11 @@ public static Vector512 IsPositiveInfinity(Vector512 vector) { if (typeof(T) == typeof(float)) { - return Equals(vector, Create(float.PositiveInfinity).As()); + return Equals(vector, Vector512.PositiveInfinity.As()); } else if (typeof(T) == typeof(double)) { - return Equals(vector, Create(double.PositiveInfinity).As()); + return Equals(vector, Vector512.PositiveInfinity.As()); } return Vector512.Zero; } 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 index b1c40fcfa72c1b..eec2be8a3f79fb 100644 --- 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 @@ -340,11 +340,11 @@ public static Vector512 operator >>(Vector512 value, int shiftCount) { if (typeof(T) == typeof(float)) { - return vector ^ Vector512.Create(-0.0f).As(); + return vector ^ Vector512.NegativeZero.As(); } else if (typeof(T) == typeof(double)) { - return vector ^ Vector512.Create(-0.0).As(); + return vector ^ Vector512.NegativeZero.As(); } else { 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 b4bf35654517bd..e2a5bd6914a623 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 @@ -24,6 +24,84 @@ public static bool IsHardwareAccelerated get => IsHardwareAccelerated; } + /// The type of the elements in the vector. + extension(Vector64) + where T : IFloatingPointConstants + { + /// + public static Vector64 E + { + [Intrinsic] + get => Create(T.E); + } + + /// + public static Vector64 Pi + { + [Intrinsic] + get => Create(T.Pi); + } + + /// + public static Vector64 Tau + { + [Intrinsic] + get => Create(T.Tau); + } + } + + /// The type of the elements in the vector. + extension(Vector64) + where T : IFloatingPointIeee754 + { + /// + public static Vector64 Epsilon + { + [Intrinsic] + get => Create(T.Epsilon); + } + + /// + public static Vector64 NaN + { + [Intrinsic] + get => Create(T.NaN); + } + + /// + public static Vector64 NegativeInfinity + { + [Intrinsic] + get => Create(T.NegativeInfinity); + } + + /// + public static Vector64 NegativeZero + { + [Intrinsic] + get => Create(T.NegativeZero); + } + + /// + public static Vector64 PositiveInfinity + { + [Intrinsic] + get => Create(T.PositiveInfinity); + } + } + + /// The type of the elements in the vector. + extension(Vector64) + where T : ISignedNumber + { + /// + public static Vector64 NegativeOne + { + [Intrinsic] + get => Create(T.NegativeOne); + } + } + /// 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. @@ -1820,11 +1898,11 @@ public static Vector64 IsFinite(Vector64 vector) { if (typeof(T) == typeof(float)) { - return ~IsZero(AndNot(Create(float.PositiveInfinityBits), vector.AsUInt32())).As(); + return ~IsZero(AndNot(Vector64.PositiveInfinity.AsUInt32(), vector.AsUInt32())).As(); } else if (typeof(T) == typeof(double)) { - return ~IsZero(AndNot(Create(double.PositiveInfinityBits), vector.AsUInt64())).As(); + return ~IsZero(AndNot(Vector64.PositiveInfinity.AsUInt64(), vector.AsUInt64())).As(); } return Vector64.AllBitsSet; } @@ -1899,11 +1977,11 @@ public static Vector64 IsNegativeInfinity(Vector64 vector) { if (typeof(T) == typeof(float)) { - return Equals(vector, Create(float.NegativeInfinity).As()); + return Equals(vector, Vector64.NegativeInfinity.As()); } else if (typeof(T) == typeof(double)) { - return Equals(vector, Create(double.NegativeInfinity).As()); + return Equals(vector, Vector64.PositiveInfinity.As()); } return Vector64.Zero; } @@ -1974,11 +2052,11 @@ public static Vector64 IsPositiveInfinity(Vector64 vector) { if (typeof(T) == typeof(float)) { - return Equals(vector, Create(float.PositiveInfinity).As()); + return Equals(vector, Vector64.PositiveInfinity.As()); } else if (typeof(T) == typeof(double)) { - return Equals(vector, Create(double.PositiveInfinity).As()); + return Equals(vector, Vector64.PositiveInfinity.As()); } return Vector64.Zero; } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64_1.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64_1.cs index 68e99650be094e..e06b50891fba28 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64_1.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64_1.cs @@ -394,11 +394,11 @@ public static Vector64 operator >>(Vector64 value, int shiftCount) { if (typeof(T) == typeof(float)) { - return vector ^ Vector64.Create(-0.0f).As(); + return vector ^ Vector64.NegativeZero.As(); } else if (typeof(T) == typeof(double)) { - return vector ^ Vector64.Create(-0.0).As(); + return vector ^ Vector64.NegativeZero.As(); } else { diff --git a/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Packed.cs b/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Packed.cs index 52eb1b0b2bedce..1866e82e30f2c3 100644 --- a/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Packed.cs +++ b/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Packed.cs @@ -1301,7 +1301,7 @@ private static int ComputeFirstIndexOverlapped(ref short searchSpace, ref short internal static Vector256 FixUpPackedVector256Result(Vector256 result) { Debug.Assert(Avx2.IsSupported); - // Avx2.PackUnsignedSaturate(Vector256.Create((short)1), Vector256.Create((short)2)) will result in + // Avx2.PackUnsignedSaturate(Vector256.One, Vector256.Create(2)) will result in // 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2 // We want to swap the X and Y bits // 1, 1, 1, 1, 1, 1, 1, 1, X, X, X, X, X, X, X, X, Y, Y, Y, Y, Y, Y, Y, Y, 2, 2, 2, 2, 2, 2, 2, 2 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 93d0b66e802530..b122a5c3797d25 100644 --- a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs +++ b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs @@ -411,6 +411,24 @@ public static void CopyTo(this System.Runtime.Intrinsics.Vector128 vector, public static System.Runtime.Intrinsics.Vector128 WithLower(this System.Runtime.Intrinsics.Vector128 vector, System.Runtime.Intrinsics.Vector64 value) { throw null; } public static System.Runtime.Intrinsics.Vector128 WithUpper(this System.Runtime.Intrinsics.Vector128 vector, System.Runtime.Intrinsics.Vector64 value) { throw null; } public static System.Runtime.Intrinsics.Vector128 Xor(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right) { throw null; } + extension(System.Runtime.Intrinsics.Vector128) where T : System.Numerics.IFloatingPointConstants + { + public static System.Runtime.Intrinsics.Vector128 E { get { throw null; } } + public static System.Runtime.Intrinsics.Vector128 Pi { get { throw null; } } + public static System.Runtime.Intrinsics.Vector128 Tau { get { throw null; } } + } + extension(System.Runtime.Intrinsics.Vector128) where T : System.Numerics.IFloatingPointIeee754 + { + public static System.Runtime.Intrinsics.Vector128 Epsilon { get { throw null; } } + public static System.Runtime.Intrinsics.Vector128 NaN { get { throw null; } } + public static System.Runtime.Intrinsics.Vector128 NegativeInfinity { get { throw null; } } + public static System.Runtime.Intrinsics.Vector128 NegativeZero { get { throw null; } } + public static System.Runtime.Intrinsics.Vector128 PositiveInfinity { get { throw null; } } + } + extension(System.Runtime.Intrinsics.Vector128) where T : System.Numerics.ISignedNumber + { + public static System.Runtime.Intrinsics.Vector128 NegativeOne { get { throw null; } } + } } public readonly partial struct Vector128 : System.IEquatable> { @@ -837,6 +855,24 @@ public static void CopyTo(this System.Runtime.Intrinsics.Vector256 vector, public static System.Runtime.Intrinsics.Vector256 WithLower(this System.Runtime.Intrinsics.Vector256 vector, System.Runtime.Intrinsics.Vector128 value) { throw null; } public static System.Runtime.Intrinsics.Vector256 WithUpper(this System.Runtime.Intrinsics.Vector256 vector, System.Runtime.Intrinsics.Vector128 value) { throw null; } public static System.Runtime.Intrinsics.Vector256 Xor(System.Runtime.Intrinsics.Vector256 left, System.Runtime.Intrinsics.Vector256 right) { throw null; } + extension(System.Runtime.Intrinsics.Vector256) where T : System.Numerics.IFloatingPointConstants + { + public static System.Runtime.Intrinsics.Vector256 E { get { throw null; } } + public static System.Runtime.Intrinsics.Vector256 Pi { get { throw null; } } + public static System.Runtime.Intrinsics.Vector256 Tau { get { throw null; } } + } + extension(System.Runtime.Intrinsics.Vector256) where T : System.Numerics.IFloatingPointIeee754 + { + public static System.Runtime.Intrinsics.Vector256 Epsilon { get { throw null; } } + public static System.Runtime.Intrinsics.Vector256 NaN { get { throw null; } } + public static System.Runtime.Intrinsics.Vector256 NegativeInfinity { get { throw null; } } + public static System.Runtime.Intrinsics.Vector256 NegativeZero { get { throw null; } } + public static System.Runtime.Intrinsics.Vector256 PositiveInfinity { get { throw null; } } + } + extension(System.Runtime.Intrinsics.Vector256) where T : System.Numerics.ISignedNumber + { + public static System.Runtime.Intrinsics.Vector256 NegativeOne { get { throw null; } } + } } public readonly partial struct Vector256 : System.IEquatable> { @@ -1262,6 +1298,24 @@ public static void CopyTo(this System.Runtime.Intrinsics.Vector512 vector, public static System.Runtime.Intrinsics.Vector512 WithLower(this System.Runtime.Intrinsics.Vector512 vector, System.Runtime.Intrinsics.Vector256 value) { throw null; } public static System.Runtime.Intrinsics.Vector512 WithUpper(this System.Runtime.Intrinsics.Vector512 vector, System.Runtime.Intrinsics.Vector256 value) { throw null; } public static System.Runtime.Intrinsics.Vector512 Xor(System.Runtime.Intrinsics.Vector512 left, System.Runtime.Intrinsics.Vector512 right) { throw null; } + extension(System.Runtime.Intrinsics.Vector512) where T : System.Numerics.IFloatingPointConstants + { + public static System.Runtime.Intrinsics.Vector512 E { get { throw null; } } + public static System.Runtime.Intrinsics.Vector512 Pi { get { throw null; } } + public static System.Runtime.Intrinsics.Vector512 Tau { get { throw null; } } + } + extension(System.Runtime.Intrinsics.Vector512) where T : System.Numerics.IFloatingPointIeee754 + { + public static System.Runtime.Intrinsics.Vector512 Epsilon { get { throw null; } } + public static System.Runtime.Intrinsics.Vector512 NaN { get { throw null; } } + public static System.Runtime.Intrinsics.Vector512 NegativeInfinity { get { throw null; } } + public static System.Runtime.Intrinsics.Vector512 NegativeZero { get { throw null; } } + public static System.Runtime.Intrinsics.Vector512 PositiveInfinity { get { throw null; } } + } + extension(System.Runtime.Intrinsics.Vector512) where T : System.Numerics.ISignedNumber + { + public static System.Runtime.Intrinsics.Vector512 NegativeOne { get { throw null; } } + } } public readonly partial struct Vector512 : System.IEquatable> { @@ -1650,6 +1704,24 @@ public static void CopyTo(this System.Runtime.Intrinsics.Vector64 vector, public static System.Runtime.Intrinsics.Vector64 WidenUpper(System.Runtime.Intrinsics.Vector64 source) { throw null; } public static System.Runtime.Intrinsics.Vector64 WithElement(this System.Runtime.Intrinsics.Vector64 vector, int index, T value) { throw null; } public static System.Runtime.Intrinsics.Vector64 Xor(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right) { throw null; } + extension(System.Runtime.Intrinsics.Vector64) where T : System.Numerics.IFloatingPointConstants + { + public static System.Runtime.Intrinsics.Vector64 E { get { throw null; } } + public static System.Runtime.Intrinsics.Vector64 Pi { get { throw null; } } + public static System.Runtime.Intrinsics.Vector64 Tau { get { throw null; } } + } + extension(System.Runtime.Intrinsics.Vector64) where T : System.Numerics.IFloatingPointIeee754 + { + public static System.Runtime.Intrinsics.Vector64 Epsilon { get { throw null; } } + public static System.Runtime.Intrinsics.Vector64 NaN { get { throw null; } } + public static System.Runtime.Intrinsics.Vector64 NegativeInfinity { get { throw null; } } + public static System.Runtime.Intrinsics.Vector64 NegativeZero { get { throw null; } } + public static System.Runtime.Intrinsics.Vector64 PositiveInfinity { get { throw null; } } + } + extension(System.Runtime.Intrinsics.Vector64) where T : System.Numerics.ISignedNumber + { + public static System.Runtime.Intrinsics.Vector64 NegativeOne { get { throw null; } } + } } public readonly partial struct Vector64 : System.IEquatable> { diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs index cc700e2f34aa56..9e8eea5b6d4092 100644 --- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs +++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs @@ -4962,14 +4962,14 @@ public void Vector128Int64IndexerTest(params long[] values) [Fact] public void Vector128DoubleEqualsNaNTest() { - Vector128 nan = Vector128.Create(double.NaN); + Vector128 nan = Vector128.NaN; Assert.True(nan.Equals(nan)); } [Fact] public void Vector128SingleEqualsNaNTest() { - Vector128 nan = Vector128.Create(float.NaN); + Vector128 nan = Vector128.NaN; Assert.True(nan.Equals(nan)); } @@ -6935,5 +6935,99 @@ public void SubtractSaturateSByteTest() [Fact] public void SubtractSaturateUIntPtrTest() => SubtractSaturateToMinTest(1); + + [Fact] + public void EDoubleTest() => TestConstant(Vector128.E, double.E); + + [Fact] + public void ESingleTest() => TestConstant(Vector128.E, float.E); + + [Fact] + public void EpsilonDoubleTest() => TestConstant(Vector128.Epsilon, double.Epsilon); + + [Fact] + public void EpsilonSingleTest() => TestConstant(Vector128.Epsilon, float.Epsilon); + + [Fact] + public void NaNDoubleTest() => TestConstant(Vector128.NaN, double.NaN); + + [Fact] + public void NaNSingleTest() => TestConstant(Vector128.NaN, float.NaN); + + [Fact] + public void NegativeInfinityDoubleTest() => TestConstant(Vector128.NegativeInfinity, double.NegativeInfinity); + + [Fact] + public void NegativeInfinitySingleTest() => TestConstant(Vector128.NegativeInfinity, float.NegativeInfinity); + + [Fact] + public void NegativeOneDoubleTest() => TestConstant(Vector128.NegativeOne, -1.0); + + [Fact] + public void NegativeOneInt16Test() => TestConstant(Vector128.NegativeOne, -1); + + [Fact] + public void NegativeOneInt32Test() => TestConstant(Vector128.NegativeOne, -1); + + [Fact] + public void NegativeOneInt64Test() => TestConstant(Vector128.NegativeOne, -1); + + [Fact] + public void NegativeOneSByteTest() => TestConstant(Vector128.NegativeOne, -1); + + [Fact] + public void NegativeOneSingleTest() => TestConstant(Vector128.NegativeOne, -1.0f); + + [Fact] + public void NegativeZeroDoubleTest() => TestConstant(Vector128.NegativeZero, double.NegativeZero); + + [Fact] + public void NegativeZeroSingleTest() => TestConstant(Vector128.NegativeZero, float.NegativeZero); + + [Fact] + public void PiDoubleTest() => TestConstant(Vector128.Pi, double.Pi); + + [Fact] + public void PiSingleTest() => TestConstant(Vector128.Pi, float.Pi); + + [Fact] + public void PositiveInfinityDoubleTest() => TestConstant(Vector128.PositiveInfinity, double.PositiveInfinity); + + [Fact] + public void PositiveInfinitySingleTest() => TestConstant(Vector128.PositiveInfinity, float.PositiveInfinity); + + [Fact] + public void TauDoubleTest() => TestConstant(Vector128.Tau, double.Tau); + + [Fact] + public void TauSingleTest() => TestConstant(Vector128.Tau, float.Tau); + + [MethodImpl(MethodImplOptions.NoInlining)] + private void TestConstant(Vector128 actual, double expected) + { + for (int i = 0; i < Vector128.Count; i++) + { + Assert.Equal(BitConverter.DoubleToInt64Bits(expected), BitConverter.DoubleToInt64Bits(actual[i])); + } + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private void TestConstant(Vector128 actual, float expected) + { + for (int i = 0; i < Vector128.Count; i++) + { + Assert.Equal(BitConverter.SingleToInt32Bits(expected), BitConverter.SingleToInt32Bits(actual[i])); + } + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private void TestConstant(Vector128 actual, T expected) + where T : IBinaryInteger + { + for (int i = 0; i < Vector128.Count; i++) + { + Assert.Equal(expected, actual[i]); + } + } } } diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs index 644b6fff368c1a..14c1c7e56040b4 100644 --- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs +++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs @@ -6145,14 +6145,14 @@ public void Vector256Int64IndexerTest(params long[] values) [Fact] public void Vector256DoubleEqualsNaNTest() { - Vector256 nan = Vector256.Create(double.NaN); + Vector256 nan = Vector256.NaN; Assert.True(nan.Equals(nan)); } [Fact] public void Vector256SingleEqualsNaNTest() { - Vector256 nan = Vector256.Create(float.NaN); + Vector256 nan = Vector256.NaN; Assert.True(nan.Equals(nan)); } @@ -8111,5 +8111,99 @@ public void SubtractSaturateSByteTest() [Fact] public void SubtractSaturateUIntPtrTest() => SubtractSaturateToMinTest(1); + + [Fact] + public void EDoubleTest() => TestConstant(Vector256.E, double.E); + + [Fact] + public void ESingleTest() => TestConstant(Vector256.E, float.E); + + [Fact] + public void EpsilonDoubleTest() => TestConstant(Vector256.Epsilon, double.Epsilon); + + [Fact] + public void EpsilonSingleTest() => TestConstant(Vector256.Epsilon, float.Epsilon); + + [Fact] + public void NaNDoubleTest() => TestConstant(Vector256.NaN, double.NaN); + + [Fact] + public void NaNSingleTest() => TestConstant(Vector256.NaN, float.NaN); + + [Fact] + public void NegativeInfinityDoubleTest() => TestConstant(Vector256.NegativeInfinity, double.NegativeInfinity); + + [Fact] + public void NegativeInfinitySingleTest() => TestConstant(Vector256.NegativeInfinity, float.NegativeInfinity); + + [Fact] + public void NegativeOneDoubleTest() => TestConstant(Vector256.NegativeOne, -1.0); + + [Fact] + public void NegativeOneInt16Test() => TestConstant(Vector256.NegativeOne, -1); + + [Fact] + public void NegativeOneInt32Test() => TestConstant(Vector256.NegativeOne, -1); + + [Fact] + public void NegativeOneInt64Test() => TestConstant(Vector256.NegativeOne, -1); + + [Fact] + public void NegativeOneSByteTest() => TestConstant(Vector256.NegativeOne, -1); + + [Fact] + public void NegativeOneSingleTest() => TestConstant(Vector256.NegativeOne, -1.0f); + + [Fact] + public void NegativeZeroDoubleTest() => TestConstant(Vector256.NegativeZero, double.NegativeZero); + + [Fact] + public void NegativeZeroSingleTest() => TestConstant(Vector256.NegativeZero, float.NegativeZero); + + [Fact] + public void PiDoubleTest() => TestConstant(Vector256.Pi, double.Pi); + + [Fact] + public void PiSingleTest() => TestConstant(Vector256.Pi, float.Pi); + + [Fact] + public void PositiveInfinityDoubleTest() => TestConstant(Vector256.PositiveInfinity, double.PositiveInfinity); + + [Fact] + public void PositiveInfinitySingleTest() => TestConstant(Vector256.PositiveInfinity, float.PositiveInfinity); + + [Fact] + public void TauDoubleTest() => TestConstant(Vector256.Tau, double.Tau); + + [Fact] + public void TauSingleTest() => TestConstant(Vector256.Tau, float.Tau); + + [MethodImpl(MethodImplOptions.NoInlining)] + private void TestConstant(Vector256 actual, double expected) + { + for (int i = 0; i < Vector256.Count; i++) + { + Assert.Equal(BitConverter.DoubleToInt64Bits(expected), BitConverter.DoubleToInt64Bits(actual[i])); + } + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private void TestConstant(Vector256 actual, float expected) + { + for (int i = 0; i < Vector256.Count; i++) + { + Assert.Equal(BitConverter.SingleToInt32Bits(expected), BitConverter.SingleToInt32Bits(actual[i])); + } + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private void TestConstant(Vector256 actual, T expected) + where T : IBinaryInteger + { + for (int i = 0; i < Vector256.Count; i++) + { + Assert.Equal(expected, actual[i]); + } + } } } diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs index 637a930e55c5e6..06e09be9daaa31 100644 --- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs +++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs @@ -5973,14 +5973,14 @@ public void Vector512Int64IndexerTest(params long[] values) [Fact] public void Vector512DoubleEqualsNaNTest() { - Vector512 nan = Vector512.Create(double.NaN); + Vector512 nan = Vector512.NaN; Assert.True(nan.Equals(nan)); } [Fact] public void Vector512SingleEqualsNaNTest() { - Vector512 nan = Vector512.Create(float.NaN); + Vector512 nan = Vector512.NaN; Assert.True(nan.Equals(nan)); } @@ -7894,5 +7894,99 @@ public void SubtractSaturateSByteTest() [Fact] public void SubtractSaturateUIntPtrTest() => SubtractSaturateToMinTest(1); + + [Fact] + public void EDoubleTest() => TestConstant(Vector512.E, double.E); + + [Fact] + public void ESingleTest() => TestConstant(Vector512.E, float.E); + + [Fact] + public void EpsilonDoubleTest() => TestConstant(Vector512.Epsilon, double.Epsilon); + + [Fact] + public void EpsilonSingleTest() => TestConstant(Vector512.Epsilon, float.Epsilon); + + [Fact] + public void NaNDoubleTest() => TestConstant(Vector512.NaN, double.NaN); + + [Fact] + public void NaNSingleTest() => TestConstant(Vector512.NaN, float.NaN); + + [Fact] + public void NegativeInfinityDoubleTest() => TestConstant(Vector512.NegativeInfinity, double.NegativeInfinity); + + [Fact] + public void NegativeInfinitySingleTest() => TestConstant(Vector512.NegativeInfinity, float.NegativeInfinity); + + [Fact] + public void NegativeOneDoubleTest() => TestConstant(Vector512.NegativeOne, -1.0); + + [Fact] + public void NegativeOneInt16Test() => TestConstant(Vector512.NegativeOne, -1); + + [Fact] + public void NegativeOneInt32Test() => TestConstant(Vector512.NegativeOne, -1); + + [Fact] + public void NegativeOneInt64Test() => TestConstant(Vector512.NegativeOne, -1); + + [Fact] + public void NegativeOneSByteTest() => TestConstant(Vector512.NegativeOne, -1); + + [Fact] + public void NegativeOneSingleTest() => TestConstant(Vector512.NegativeOne, -1.0f); + + [Fact] + public void NegativeZeroDoubleTest() => TestConstant(Vector512.NegativeZero, double.NegativeZero); + + [Fact] + public void NegativeZeroSingleTest() => TestConstant(Vector512.NegativeZero, float.NegativeZero); + + [Fact] + public void PiDoubleTest() => TestConstant(Vector512.Pi, double.Pi); + + [Fact] + public void PiSingleTest() => TestConstant(Vector512.Pi, float.Pi); + + [Fact] + public void PositiveInfinityDoubleTest() => TestConstant(Vector512.PositiveInfinity, double.PositiveInfinity); + + [Fact] + public void PositiveInfinitySingleTest() => TestConstant(Vector512.PositiveInfinity, float.PositiveInfinity); + + [Fact] + public void TauDoubleTest() => TestConstant(Vector512.Tau, double.Tau); + + [Fact] + public void TauSingleTest() => TestConstant(Vector512.Tau, float.Tau); + + [MethodImpl(MethodImplOptions.NoInlining)] + private void TestConstant(Vector512 actual, double expected) + { + for (int i = 0; i < Vector512.Count; i++) + { + Assert.Equal(BitConverter.DoubleToInt64Bits(expected), BitConverter.DoubleToInt64Bits(actual[i])); + } + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private void TestConstant(Vector512 actual, float expected) + { + for (int i = 0; i < Vector512.Count; i++) + { + Assert.Equal(BitConverter.SingleToInt32Bits(expected), BitConverter.SingleToInt32Bits(actual[i])); + } + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private void TestConstant(Vector512 actual, T expected) + where T : IBinaryInteger + { + for (int i = 0; i < Vector512.Count; i++) + { + Assert.Equal(expected, actual[i]); + } + } } } diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs index 94965ae1a919a0..88869d71914b76 100644 --- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs +++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs @@ -4243,14 +4243,14 @@ public void Vector64Int64IndexerTest(params long[] values) [Fact] public void Vector64DoubleEqualsNaNTest() { - Vector64 nan = Vector64.Create(double.NaN); + Vector64 nan = Vector64.NaN; Assert.True(nan.Equals(nan)); } [Fact] public void Vector64SingleEqualsNaNTest() { - Vector64 nan = Vector64.Create(float.NaN); + Vector64 nan = Vector64.NaN; Assert.True(nan.Equals(nan)); } @@ -6199,5 +6199,99 @@ public void SubtractSaturateSByteTest() [Fact] public void SubtractSaturateUIntPtrTest() => SubtractSaturateToMinTest(1); + + [Fact] + public void EDoubleTest() => TestConstant(Vector64.E, double.E); + + [Fact] + public void ESingleTest() => TestConstant(Vector64.E, float.E); + + [Fact] + public void EpsilonDoubleTest() => TestConstant(Vector64.Epsilon, double.Epsilon); + + [Fact] + public void EpsilonSingleTest() => TestConstant(Vector64.Epsilon, float.Epsilon); + + [Fact] + public void NaNDoubleTest() => TestConstant(Vector64.NaN, double.NaN); + + [Fact] + public void NaNSingleTest() => TestConstant(Vector64.NaN, float.NaN); + + [Fact] + public void NegativeInfinityDoubleTest() => TestConstant(Vector64.NegativeInfinity, double.NegativeInfinity); + + [Fact] + public void NegativeInfinitySingleTest() => TestConstant(Vector64.NegativeInfinity, float.NegativeInfinity); + + [Fact] + public void NegativeOneDoubleTest() => TestConstant(Vector64.NegativeOne, -1.0); + + [Fact] + public void NegativeOneInt16Test() => TestConstant(Vector64.NegativeOne, -1); + + [Fact] + public void NegativeOneInt32Test() => TestConstant(Vector64.NegativeOne, -1); + + [Fact] + public void NegativeOneInt64Test() => TestConstant(Vector64.NegativeOne, -1); + + [Fact] + public void NegativeOneSByteTest() => TestConstant(Vector64.NegativeOne, -1); + + [Fact] + public void NegativeOneSingleTest() => TestConstant(Vector64.NegativeOne, -1.0f); + + [Fact] + public void NegativeZeroDoubleTest() => TestConstant(Vector64.NegativeZero, double.NegativeZero); + + [Fact] + public void NegativeZeroSingleTest() => TestConstant(Vector64.NegativeZero, float.NegativeZero); + + [Fact] + public void PiDoubleTest() => TestConstant(Vector64.Pi, double.Pi); + + [Fact] + public void PiSingleTest() => TestConstant(Vector64.Pi, float.Pi); + + [Fact] + public void PositiveInfinityDoubleTest() => TestConstant(Vector64.PositiveInfinity, double.PositiveInfinity); + + [Fact] + public void PositiveInfinitySingleTest() => TestConstant(Vector64.PositiveInfinity, float.PositiveInfinity); + + [Fact] + public void TauDoubleTest() => TestConstant(Vector64.Tau, double.Tau); + + [Fact] + public void TauSingleTest() => TestConstant(Vector64.Tau, float.Tau); + + [MethodImpl(MethodImplOptions.NoInlining)] + private void TestConstant(Vector64 actual, double expected) + { + for (int i = 0; i < Vector64.Count; i++) + { + Assert.Equal(BitConverter.DoubleToInt64Bits(expected), BitConverter.DoubleToInt64Bits(actual[i])); + } + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private void TestConstant(Vector64 actual, float expected) + { + for (int i = 0; i < Vector64.Count; i++) + { + Assert.Equal(BitConverter.SingleToInt32Bits(expected), BitConverter.SingleToInt32Bits(actual[i])); + } + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private void TestConstant(Vector64 actual, T expected) + where T : IBinaryInteger + { + for (int i = 0; i < Vector64.Count; i++) + { + Assert.Equal(expected, actual[i]); + } + } } } diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Wasm/PackedSimdTests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Wasm/PackedSimdTests.cs index d8d4cfc87d4af7..cb529221bf2e61 100644 --- a/src/libraries/System.Runtime.Intrinsics/tests/Wasm/PackedSimdTests.cs +++ b/src/libraries/System.Runtime.Intrinsics/tests/Wasm/PackedSimdTests.cs @@ -416,7 +416,7 @@ public unsafe void SaturatingArithmeticEdgeCasesTest() // Edge cases for signed bytes var sbMax = Vector128.Create(sbyte.MaxValue); var sbMin = Vector128.Create(sbyte.MinValue); - var sbOne = Vector128.Create((sbyte)1); + var sbOne = Vector128.One; var sbOverflow = PackedSimd.AddSaturate(sbMax, sbOne); var sbUnderflow = PackedSimd.SubtractSaturate(sbMin, sbOne); @@ -427,7 +427,7 @@ public unsafe void SaturatingArithmeticEdgeCasesTest() // Edge cases for unsigned bytes var bMax = Vector128.Create(byte.MaxValue); var bMin = Vector128.Create(byte.MinValue); - var bOne = Vector128.Create((byte)1); + var bOne = Vector128.One; var bOverflow = PackedSimd.AddSaturate(bMax, bOne); var bUnderflow = PackedSimd.SubtractSaturate(bMin, bOne); @@ -438,7 +438,7 @@ public unsafe void SaturatingArithmeticEdgeCasesTest() // Edge cases for signed shorts var shortMax = Vector128.Create(short.MaxValue); var shortMin = Vector128.Create(short.MinValue); - var shortOne = Vector128.Create((short)1); + var shortOne = Vector128.One; var shortOverflow = PackedSimd.AddSaturate(shortMax, shortOne); var shortUnderflow = PackedSimd.SubtractSaturate(shortMin, shortOne); @@ -449,7 +449,7 @@ public unsafe void SaturatingArithmeticEdgeCasesTest() // Edge cases for unsigned shorts var ushortMax = Vector128.Create(ushort.MaxValue); var ushortMin = Vector128.Create(ushort.MinValue); - var ushortOne = Vector128.Create((ushort)1); + var ushortOne = Vector128.One; var ushortOverflow = PackedSimd.AddSaturate(ushortMax, ushortOne); var ushortUnderflow = PackedSimd.SubtractSaturate(ushortMin, ushortOne); @@ -929,4 +929,4 @@ public unsafe void BitmaskTest() Assert.Equal(v128emsb_i, (uint)bitmask_i); } } -} \ No newline at end of file +} diff --git a/src/tests/JIT/Directed/StructABI/structreturn.cs b/src/tests/JIT/Directed/StructABI/structreturn.cs index 4f9108f5e29224..6807420addbc40 100644 --- a/src/tests/JIT/Directed/StructABI/structreturn.cs +++ b/src/tests/JIT/Directed/StructABI/structreturn.cs @@ -1411,13 +1411,13 @@ static void TestReturnVectorT() [MethodImpl(MethodImplOptions.NoInlining)] static Vector64 ReturnVector64Int() { - return System.Runtime.Intrinsics.Vector64.Create(1); + return System.Runtime.Intrinsics.Vector64.One; } [MethodImpl(MethodImplOptions.NoInlining)] static Vector64 ReturnVector64Double() { - return System.Runtime.Intrinsics.Vector64.Create(1.0); + return System.Runtime.Intrinsics.Vector64.One; } [MethodImpl(MethodImplOptions.NoInlining)] @@ -1426,9 +1426,9 @@ static Vector64 ReturnVector64IntWithMerge(int v) switch (v) { case 0: - return System.Runtime.Intrinsics.Vector64.Create(0); + return System.Runtime.Intrinsics.Vector64.Zero; case 1: - return System.Runtime.Intrinsics.Vector64.Create(1); + return System.Runtime.Intrinsics.Vector64.One; case 2: return System.Runtime.Intrinsics.Vector64.Create(2); case 3: @@ -1458,13 +1458,13 @@ static void TestReturnVector64(int v) [MethodImpl(MethodImplOptions.NoInlining)] static Vector128 ReturnVector128Int() { - return System.Runtime.Intrinsics.Vector128.Create(1); + return System.Runtime.Intrinsics.Vector128.One; } [MethodImpl(MethodImplOptions.NoInlining)] static Vector128 ReturnVector128Double() { - return System.Runtime.Intrinsics.Vector128.Create(1.0); + return System.Runtime.Intrinsics.Vector128.One; } [MethodImpl(MethodImplOptions.NoInlining)] @@ -1473,9 +1473,9 @@ static Vector128 ReturnVector128IntWithMerge(int v) switch (v) { case 0: - return System.Runtime.Intrinsics.Vector128.Create(0); + return System.Runtime.Intrinsics.Vector128.Zero; case 1: - return System.Runtime.Intrinsics.Vector128.Create(1); + return System.Runtime.Intrinsics.Vector128.One; case 2: return System.Runtime.Intrinsics.Vector128.Create(2); case 3: @@ -1505,13 +1505,13 @@ static void TestReturnVector128(int v) [MethodImpl(MethodImplOptions.NoInlining)] static Vector256 ReturnVector256Int() { - return System.Runtime.Intrinsics.Vector256.Create(1); + return System.Runtime.Intrinsics.Vector256.One; } [MethodImpl(MethodImplOptions.NoInlining)] static Vector256 ReturnVector256Double() { - return System.Runtime.Intrinsics.Vector256.Create(1.0); + return System.Runtime.Intrinsics.Vector256.One; } [MethodImpl(MethodImplOptions.NoInlining)] @@ -1520,9 +1520,9 @@ static Vector256 ReturnVector256IntWithMerge(int v) switch (v) { case 0: - return System.Runtime.Intrinsics.Vector256.Create(0); + return System.Runtime.Intrinsics.Vector256.Zero; case 1: - return System.Runtime.Intrinsics.Vector256.Create(1); + return System.Runtime.Intrinsics.Vector256.One; case 2: return System.Runtime.Intrinsics.Vector256.Create(2); case 3: diff --git a/src/tests/JIT/HardwareIntrinsics/General/HwiOp/CompareVectorWithZero.cs b/src/tests/JIT/HardwareIntrinsics/General/HwiOp/CompareVectorWithZero.cs index c167bec8ae77dd..326b825a9ba809 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/HwiOp/CompareVectorWithZero.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/HwiOp/CompareVectorWithZero.cs @@ -13,16 +13,16 @@ public class CompareVectorWithZero public static void TestVector64Equality() { TestEquality(Vector64.Create(0)); - TestEquality(Vector64.Create(0.0f)); - TestEquality(Vector64.Create(-0.0f)); - TestEquality(Vector64.Create(0.0)); - TestEquality(Vector64.Create(-0.0)); + TestEquality(Vector64.Zero); + TestEquality(Vector64.NegativeZero); + TestEquality(Vector64.Zero); + TestEquality(Vector64.NegativeZero); TestEqualityUsingReversedInputs(Vector64.Create(0)); - TestEqualityUsingReversedInputs(Vector64.Create(0.0f)); - TestEqualityUsingReversedInputs(Vector64.Create(-0.0f)); - TestEqualityUsingReversedInputs(Vector64.Create(0.0)); - TestEqualityUsingReversedInputs(Vector64.Create(-0.0)); + TestEqualityUsingReversedInputs(Vector64.Zero); + TestEqualityUsingReversedInputs(Vector64.NegativeZero); + TestEqualityUsingReversedInputs(Vector64.Zero); + TestEqualityUsingReversedInputs(Vector64.NegativeZero); TestEquality(Vector64.Create(-10)); TestEquality(Vector64.Create(10)); @@ -32,16 +32,16 @@ public static void TestVector64Equality() TestEquality(Vector64.Create(0, 0, 0, 0, 0, 0, 0, -1)); TestEqualityUsingAnd(Vector64.Create(0), Vector64.Create(0)); - TestEqualityUsingAnd(Vector64.Create(0.0f), Vector64.Create(0.0f)); - TestEqualityUsingAnd(Vector64.Create(-0.0f), Vector64.Create(-0.0f)); - TestEqualityUsingAnd(Vector64.Create(0.0), Vector64.Create(0.0)); - TestEqualityUsingAnd(Vector64.Create(-0.0), Vector64.Create(-0.0)); + TestEqualityUsingAnd(Vector64.Zero, Vector64.Zero); + TestEqualityUsingAnd(Vector64.NegativeZero, Vector64.NegativeZero); + TestEqualityUsingAnd(Vector64.Zero, Vector64.Zero); + TestEqualityUsingAnd(Vector64.NegativeZero, Vector64.NegativeZero); TestEqualityUsingAndNot(Vector64.Create(0), Vector64.Create(0)); - TestEqualityUsingAndNot(Vector64.Create(0.0f), Vector64.Create(0.0f)); - TestEqualityUsingAndNot(Vector64.Create(-0.0f), Vector64.Create(-0.0f)); - TestEqualityUsingAndNot(Vector64.Create(0.0), Vector64.Create(0.0)); - TestEqualityUsingAndNot(Vector64.Create(-0.0), Vector64.Create(-0.0)); + TestEqualityUsingAndNot(Vector64.Zero, Vector64.Zero); + TestEqualityUsingAndNot(Vector64.NegativeZero, Vector64.NegativeZero); + TestEqualityUsingAndNot(Vector64.Zero, Vector64.Zero); + TestEqualityUsingAndNot(Vector64.NegativeZero, Vector64.NegativeZero); TestEquality(Vector64.Create(0, 0, 0, 0, 0, 0, -1, 0)); TestEquality(Vector64.Create(0, 0, 0, 0, 0, 0, -1, 0)); @@ -58,16 +58,16 @@ public static void TestVector64Equality() public static void TestVector128Equality() { TestEquality(Vector128.Create(0)); - TestEquality(Vector128.Create(0.0f)); - TestEquality(Vector128.Create(-0.0f)); - TestEquality(Vector128.Create(0.0)); - TestEquality(Vector128.Create(-0.0)); + TestEquality(Vector128.Zero); + TestEquality(Vector128.NegativeZero); + TestEquality(Vector128.Zero); + TestEquality(Vector128.NegativeZero); TestEqualityUsingReversedInputs(Vector128.Create(0)); - TestEqualityUsingReversedInputs(Vector128.Create(0.0f)); - TestEqualityUsingReversedInputs(Vector128.Create(-0.0f)); - TestEqualityUsingReversedInputs(Vector128.Create(0.0)); - TestEqualityUsingReversedInputs(Vector128.Create(-0.0)); + TestEqualityUsingReversedInputs(Vector128.Zero); + TestEqualityUsingReversedInputs(Vector128.NegativeZero); + TestEqualityUsingReversedInputs(Vector128.Zero); + TestEqualityUsingReversedInputs(Vector128.NegativeZero); TestEquality(Vector128.Create(-10)); TestEquality(Vector128.Create(10)); @@ -77,16 +77,16 @@ public static void TestVector128Equality() TestEquality(Vector128.Create(0, 0, 0, 0, 0, 0, 0, -1)); TestEqualityUsingAnd(Vector128.Create(0), Vector128.Create(0)); - TestEqualityUsingAnd(Vector128.Create(0.0f), Vector128.Create(0.0f)); - TestEqualityUsingAnd(Vector128.Create(-0.0f), Vector128.Create(-0.0f)); - TestEqualityUsingAnd(Vector128.Create(0.0), Vector128.Create(0.0)); - TestEqualityUsingAnd(Vector128.Create(-0.0), Vector128.Create(-0.0)); + TestEqualityUsingAnd(Vector128.Zero, Vector128.Zero); + TestEqualityUsingAnd(Vector128.NegativeZero, Vector128.NegativeZero); + TestEqualityUsingAnd(Vector128.Zero, Vector128.Zero); + TestEqualityUsingAnd(Vector128.NegativeZero, Vector128.NegativeZero); TestEqualityUsingAndNot(Vector128.Create(0), Vector128.Create(0)); - TestEqualityUsingAndNot(Vector128.Create(0.0f), Vector128.Create(0.0f)); - TestEqualityUsingAndNot(Vector128.Create(-0.0f), Vector128.Create(-0.0f)); - TestEqualityUsingAndNot(Vector128.Create(0.0), Vector128.Create(0.0)); - TestEqualityUsingAndNot(Vector128.Create(-0.0), Vector128.Create(-0.0)); + TestEqualityUsingAndNot(Vector128.Zero, Vector128.Zero); + TestEqualityUsingAndNot(Vector128.NegativeZero, Vector128.NegativeZero); + TestEqualityUsingAndNot(Vector128.Zero, Vector128.Zero); + TestEqualityUsingAndNot(Vector128.NegativeZero, Vector128.NegativeZero); TestEquality(Vector128.Create(0, 0, 0, 0, 0, 0, 1, 0)); TestEquality(Vector128.Create(0, 0, 0, 0, 0, 0, 1, 0)); @@ -103,16 +103,16 @@ public static void TestVector128Equality() public static void TestVector256Equality() { TestEquality(Vector256.Create(0)); - TestEquality(Vector256.Create(0.0f)); - TestEquality(Vector256.Create(-0.0f)); - TestEquality(Vector256.Create(0.0)); - TestEquality(Vector256.Create(-0.0)); + TestEquality(Vector256.Zero); + TestEquality(Vector256.NegativeZero); + TestEquality(Vector256.Zero); + TestEquality(Vector256.NegativeZero); TestEqualityUsingReversedInputs(Vector256.Create(0)); - TestEqualityUsingReversedInputs(Vector256.Create(0.0f)); - TestEqualityUsingReversedInputs(Vector256.Create(-0.0f)); - TestEqualityUsingReversedInputs(Vector256.Create(0.0)); - TestEqualityUsingReversedInputs(Vector256.Create(-0.0)); + TestEqualityUsingReversedInputs(Vector256.Zero); + TestEqualityUsingReversedInputs(Vector256.NegativeZero); + TestEqualityUsingReversedInputs(Vector256.Zero); + TestEqualityUsingReversedInputs(Vector256.NegativeZero); TestEquality(Vector256.Create(-10)); TestEquality(Vector256.Create(10)); @@ -122,16 +122,16 @@ public static void TestVector256Equality() TestEquality(Vector256.Create(0, 0, 0, 0, 0, 0, 0, -1)); TestEqualityUsingAnd(Vector256.Create(0), Vector256.Create(0)); - TestEqualityUsingAnd(Vector256.Create(0.0f), Vector256.Create(0.0f)); - TestEqualityUsingAnd(Vector256.Create(-0.0f), Vector256.Create(-0.0f)); - TestEqualityUsingAnd(Vector256.Create(0.0), Vector256.Create(0.0)); - TestEqualityUsingAnd(Vector256.Create(-0.0), Vector256.Create(-0.0)); + TestEqualityUsingAnd(Vector256.Zero, Vector256.Zero); + TestEqualityUsingAnd(Vector256.NegativeZero, Vector256.NegativeZero); + TestEqualityUsingAnd(Vector256.Zero, Vector256.Zero); + TestEqualityUsingAnd(Vector256.NegativeZero, Vector256.NegativeZero); TestEqualityUsingAndNot(Vector256.Create(0), Vector256.Create(0)); - TestEqualityUsingAndNot(Vector256.Create(0.0f), Vector256.Create(0.0f)); - TestEqualityUsingAndNot(Vector256.Create(-0.0f), Vector256.Create(-0.0f)); - TestEqualityUsingAndNot(Vector256.Create(0.0), Vector256.Create(0.0)); - TestEqualityUsingAndNot(Vector256.Create(-0.0), Vector256.Create(-0.0)); + TestEqualityUsingAndNot(Vector256.Zero, Vector256.Zero); + TestEqualityUsingAndNot(Vector256.NegativeZero, Vector256.NegativeZero); + TestEqualityUsingAndNot(Vector256.Zero, Vector256.Zero); + TestEqualityUsingAndNot(Vector256.NegativeZero, Vector256.NegativeZero); } [ActiveIssue("https://github.com/dotnet/runtime/pull/65632#issuecomment-1046294324", TestRuntimes.Mono)] @@ -139,16 +139,16 @@ public static void TestVector256Equality() public static void TestVector512Equality() { TestEquality(Vector512.Create(0)); - TestEquality(Vector512.Create(0.0f)); - TestEquality(Vector512.Create(-0.0f)); - TestEquality(Vector512.Create(0.0)); - TestEquality(Vector512.Create(-0.0)); + TestEquality(Vector512.Zero); + TestEquality(Vector512.NegativeZero); + TestEquality(Vector512.Zero); + TestEquality(Vector512.NegativeZero); TestEqualityUsingReversedInputs(Vector512.Create(0)); - TestEqualityUsingReversedInputs(Vector512.Create(0.0f)); - TestEqualityUsingReversedInputs(Vector512.Create(-0.0f)); - TestEqualityUsingReversedInputs(Vector512.Create(0.0)); - TestEqualityUsingReversedInputs(Vector512.Create(-0.0)); + TestEqualityUsingReversedInputs(Vector512.Zero); + TestEqualityUsingReversedInputs(Vector512.NegativeZero); + TestEqualityUsingReversedInputs(Vector512.Zero); + TestEqualityUsingReversedInputs(Vector512.NegativeZero); TestEquality(Vector512.Create(-10)); TestEquality(Vector512.Create(10)); @@ -158,16 +158,16 @@ public static void TestVector512Equality() TestEquality(Vector512.Create(0, 0, 0, 0, 0, 0, 0, -1)); TestEqualityUsingAnd(Vector512.Create(0), Vector512.Create(0)); - TestEqualityUsingAnd(Vector512.Create(0.0f), Vector512.Create(0.0f)); - TestEqualityUsingAnd(Vector512.Create(-0.0f), Vector512.Create(-0.0f)); - TestEqualityUsingAnd(Vector512.Create(0.0), Vector512.Create(0.0)); - TestEqualityUsingAnd(Vector512.Create(-0.0), Vector512.Create(-0.0)); + TestEqualityUsingAnd(Vector512.Zero, Vector512.Zero); + TestEqualityUsingAnd(Vector512.NegativeZero, Vector512.NegativeZero); + TestEqualityUsingAnd(Vector512.Zero, Vector512.Zero); + TestEqualityUsingAnd(Vector512.NegativeZero, Vector512.NegativeZero); TestEqualityUsingAndNot(Vector512.Create(0), Vector512.Create(0)); - TestEqualityUsingAndNot(Vector512.Create(0.0f), Vector512.Create(0.0f)); - TestEqualityUsingAndNot(Vector512.Create(-0.0f), Vector512.Create(-0.0f)); - TestEqualityUsingAndNot(Vector512.Create(0.0), Vector512.Create(0.0)); - TestEqualityUsingAndNot(Vector512.Create(-0.0), Vector512.Create(-0.0)); + TestEqualityUsingAndNot(Vector512.Zero, Vector512.Zero); + TestEqualityUsingAndNot(Vector512.NegativeZero, Vector512.NegativeZero); + TestEqualityUsingAndNot(Vector512.Zero, Vector512.Zero); + TestEqualityUsingAndNot(Vector512.NegativeZero, Vector512.NegativeZero); } [ActiveIssue("https://github.com/dotnet/runtime/pull/65632#issuecomment-1046294324", TestRuntimes.Mono)] @@ -175,16 +175,16 @@ public static void TestVector512Equality() public static void TestVector64Inequality() { TestInequality(Vector64.Create(0)); - TestInequality(Vector64.Create(0.0f)); - TestInequality(Vector64.Create(-0.0f)); - TestInequality(Vector64.Create(0.0)); - TestInequality(Vector64.Create(-0.0)); + TestInequality(Vector64.Zero); + TestInequality(Vector64.NegativeZero); + TestInequality(Vector64.Zero); + TestInequality(Vector64.NegativeZero); TestInequalityUsingReversedInputs(Vector64.Create(0)); - TestInequalityUsingReversedInputs(Vector64.Create(0.0f)); - TestInequalityUsingReversedInputs(Vector64.Create(-0.0f)); - TestInequalityUsingReversedInputs(Vector64.Create(0.0)); - TestInequalityUsingReversedInputs(Vector64.Create(-0.0)); + TestInequalityUsingReversedInputs(Vector64.Zero); + TestInequalityUsingReversedInputs(Vector64.NegativeZero); + TestInequalityUsingReversedInputs(Vector64.Zero); + TestInequalityUsingReversedInputs(Vector64.NegativeZero); TestInequality(Vector64.Create(-10)); TestInequality(Vector64.Create(10)); @@ -194,16 +194,16 @@ public static void TestVector64Inequality() TestInequality(Vector64.Create(0, 0, 0, 0, 0, 0, 0, -1)); TestInequalityUsingAnd(Vector64.Create(0), Vector64.Create(0)); - TestInequalityUsingAnd(Vector64.Create(0.0f), Vector64.Create(0.0f)); - TestInequalityUsingAnd(Vector64.Create(-0.0f), Vector64.Create(-0.0f)); - TestInequalityUsingAnd(Vector64.Create(0.0), Vector64.Create(0.0)); - TestInequalityUsingAnd(Vector64.Create(-0.0), Vector64.Create(-0.0)); + TestInequalityUsingAnd(Vector64.Zero, Vector64.Zero); + TestInequalityUsingAnd(Vector64.NegativeZero, Vector64.NegativeZero); + TestInequalityUsingAnd(Vector64.Zero, Vector64.Zero); + TestInequalityUsingAnd(Vector64.NegativeZero, Vector64.NegativeZero); TestInequalityUsingAndNot(Vector64.Create(0), Vector64.Create(0)); - TestInequalityUsingAndNot(Vector64.Create(0.0f), Vector64.Create(0.0f)); - TestInequalityUsingAndNot(Vector64.Create(-0.0f), Vector64.Create(-0.0f)); - TestInequalityUsingAndNot(Vector64.Create(0.0), Vector64.Create(0.0)); - TestInequalityUsingAndNot(Vector64.Create(-0.0), Vector64.Create(-0.0)); + TestInequalityUsingAndNot(Vector64.Zero, Vector64.Zero); + TestInequalityUsingAndNot(Vector64.NegativeZero, Vector64.NegativeZero); + TestInequalityUsingAndNot(Vector64.Zero, Vector64.Zero); + TestInequalityUsingAndNot(Vector64.NegativeZero, Vector64.NegativeZero); TestInequality(Vector64.Create(0, 0, 0, 0, 0, 0, -1, 0)); TestInequality(Vector64.Create(0, 0, 0, 0, 0, 0, -1, 0)); @@ -220,16 +220,16 @@ public static void TestVector64Inequality() public static void TestVector128Inequality() { TestInequality(Vector128.Create(0)); - TestInequality(Vector128.Create(0.0f)); - TestInequality(Vector128.Create(-0.0f)); - TestInequality(Vector128.Create(0.0)); - TestInequality(Vector128.Create(-0.0)); + TestInequality(Vector128.Zero); + TestInequality(Vector128.NegativeZero); + TestInequality(Vector128.Zero); + TestInequality(Vector128.NegativeZero); TestInequalityUsingReversedInputs(Vector128.Create(0)); - TestInequalityUsingReversedInputs(Vector128.Create(0.0f)); - TestInequalityUsingReversedInputs(Vector128.Create(-0.0f)); - TestInequalityUsingReversedInputs(Vector128.Create(0.0)); - TestInequalityUsingReversedInputs(Vector128.Create(-0.0)); + TestInequalityUsingReversedInputs(Vector128.Zero); + TestInequalityUsingReversedInputs(Vector128.NegativeZero); + TestInequalityUsingReversedInputs(Vector128.Zero); + TestInequalityUsingReversedInputs(Vector128.NegativeZero); TestInequality(Vector128.Create(-10)); TestInequality(Vector128.Create(10)); @@ -239,16 +239,16 @@ public static void TestVector128Inequality() TestInequality(Vector128.Create(0, 0, 0, 0, 0, 0, 0, -1)); TestInequalityUsingAnd(Vector128.Create(0), Vector128.Create(0)); - TestInequalityUsingAnd(Vector128.Create(0.0f), Vector128.Create(0.0f)); - TestInequalityUsingAnd(Vector128.Create(-0.0f), Vector128.Create(-0.0f)); - TestInequalityUsingAnd(Vector128.Create(0.0), Vector128.Create(0.0)); - TestInequalityUsingAnd(Vector128.Create(-0.0), Vector128.Create(-0.0)); + TestInequalityUsingAnd(Vector128.Zero, Vector128.Zero); + TestInequalityUsingAnd(Vector128.NegativeZero, Vector128.NegativeZero); + TestInequalityUsingAnd(Vector128.Zero, Vector128.Zero); + TestInequalityUsingAnd(Vector128.NegativeZero, Vector128.NegativeZero); TestInequalityUsingAndNot(Vector128.Create(0), Vector128.Create(0)); - TestInequalityUsingAndNot(Vector128.Create(0.0f), Vector128.Create(0.0f)); - TestInequalityUsingAndNot(Vector128.Create(-0.0f), Vector128.Create(-0.0f)); - TestInequalityUsingAndNot(Vector128.Create(0.0), Vector128.Create(0.0)); - TestInequalityUsingAndNot(Vector128.Create(-0.0), Vector128.Create(-0.0)); + TestInequalityUsingAndNot(Vector128.Zero, Vector128.Zero); + TestInequalityUsingAndNot(Vector128.NegativeZero, Vector128.NegativeZero); + TestInequalityUsingAndNot(Vector128.Zero, Vector128.Zero); + TestInequalityUsingAndNot(Vector128.NegativeZero, Vector128.NegativeZero); TestInequality(Vector128.Create(0, 0, 0, 0, 0, 0, 1, 0)); TestInequality(Vector128.Create(0, 0, 0, 0, 0, 0, 1, 0)); @@ -265,16 +265,16 @@ public static void TestVector128Inequality() public static void TestVector256Inequality() { TestInequality(Vector256.Create(0)); - TestInequality(Vector256.Create(0.0f)); - TestInequality(Vector256.Create(-0.0f)); - TestInequality(Vector256.Create(0.0)); - TestInequality(Vector256.Create(-0.0)); + TestInequality(Vector256.Zero); + TestInequality(Vector256.NegativeZero); + TestInequality(Vector256.Zero); + TestInequality(Vector256.NegativeZero); TestInequalityUsingReversedInputs(Vector256.Create(0)); - TestInequalityUsingReversedInputs(Vector256.Create(0.0f)); - TestInequalityUsingReversedInputs(Vector256.Create(-0.0f)); - TestInequalityUsingReversedInputs(Vector256.Create(0.0)); - TestInequalityUsingReversedInputs(Vector256.Create(-0.0)); + TestInequalityUsingReversedInputs(Vector256.Zero); + TestInequalityUsingReversedInputs(Vector256.NegativeZero); + TestInequalityUsingReversedInputs(Vector256.Zero); + TestInequalityUsingReversedInputs(Vector256.NegativeZero); TestInequality(Vector256.Create(-10)); TestInequality(Vector256.Create(10)); @@ -284,16 +284,16 @@ public static void TestVector256Inequality() TestInequality(Vector256.Create(0, 0, 0, 0, 0, 0, 0, -1)); TestInequalityUsingAnd(Vector256.Create(0), Vector256.Create(0)); - TestInequalityUsingAnd(Vector256.Create(0.0f), Vector256.Create(0.0f)); - TestInequalityUsingAnd(Vector256.Create(-0.0f), Vector256.Create(-0.0f)); - TestInequalityUsingAnd(Vector256.Create(0.0), Vector256.Create(0.0)); - TestInequalityUsingAnd(Vector256.Create(-0.0), Vector256.Create(-0.0)); + TestInequalityUsingAnd(Vector256.Zero, Vector256.Zero); + TestInequalityUsingAnd(Vector256.NegativeZero, Vector256.NegativeZero); + TestInequalityUsingAnd(Vector256.Zero, Vector256.Zero); + TestInequalityUsingAnd(Vector256.NegativeZero, Vector256.NegativeZero); TestInequalityUsingAndNot(Vector256.Create(0), Vector256.Create(0)); - TestInequalityUsingAndNot(Vector256.Create(0.0f), Vector256.Create(0.0f)); - TestInequalityUsingAndNot(Vector256.Create(-0.0f), Vector256.Create(-0.0f)); - TestInequalityUsingAndNot(Vector256.Create(0.0), Vector256.Create(0.0)); - TestInequalityUsingAndNot(Vector256.Create(-0.0), Vector256.Create(-0.0)); + TestInequalityUsingAndNot(Vector256.Zero, Vector256.Zero); + TestInequalityUsingAndNot(Vector256.NegativeZero, Vector256.NegativeZero); + TestInequalityUsingAndNot(Vector256.Zero, Vector256.Zero); + TestInequalityUsingAndNot(Vector256.NegativeZero, Vector256.NegativeZero); } [ActiveIssue("https://github.com/dotnet/runtime/pull/65632#issuecomment-1046294324", TestRuntimes.Mono)] @@ -301,16 +301,16 @@ public static void TestVector256Inequality() public static void TestVector512Inequality() { TestInequality(Vector512.Create(0)); - TestInequality(Vector512.Create(0.0f)); - TestInequality(Vector512.Create(-0.0f)); - TestInequality(Vector512.Create(0.0)); - TestInequality(Vector512.Create(-0.0)); + TestInequality(Vector512.Zero); + TestInequality(Vector512.NegativeZero); + TestInequality(Vector512.Zero); + TestInequality(Vector512.NegativeZero); TestInequalityUsingReversedInputs(Vector512.Create(0)); - TestInequalityUsingReversedInputs(Vector512.Create(0.0f)); - TestInequalityUsingReversedInputs(Vector512.Create(-0.0f)); - TestInequalityUsingReversedInputs(Vector512.Create(0.0)); - TestInequalityUsingReversedInputs(Vector512.Create(-0.0)); + TestInequalityUsingReversedInputs(Vector512.Zero); + TestInequalityUsingReversedInputs(Vector512.NegativeZero); + TestInequalityUsingReversedInputs(Vector512.Zero); + TestInequalityUsingReversedInputs(Vector512.NegativeZero); TestInequality(Vector512.Create(-10)); TestInequality(Vector512.Create(10)); @@ -320,16 +320,16 @@ public static void TestVector512Inequality() TestInequality(Vector512.Create(0, 0, 0, 0, 0, 0, 0, -1)); TestInequalityUsingAnd(Vector512.Create(0), Vector512.Create(0)); - TestInequalityUsingAnd(Vector512.Create(0.0f), Vector512.Create(0.0f)); - TestInequalityUsingAnd(Vector512.Create(-0.0f), Vector512.Create(-0.0f)); - TestInequalityUsingAnd(Vector512.Create(0.0), Vector512.Create(0.0)); - TestInequalityUsingAnd(Vector512.Create(-0.0), Vector512.Create(-0.0)); + TestInequalityUsingAnd(Vector512.Zero, Vector512.Zero); + TestInequalityUsingAnd(Vector512.NegativeZero, Vector512.NegativeZero); + TestInequalityUsingAnd(Vector512.Zero, Vector512.Zero); + TestInequalityUsingAnd(Vector512.NegativeZero, Vector512.NegativeZero); TestInequalityUsingAndNot(Vector512.Create(0), Vector512.Create(0)); - TestInequalityUsingAndNot(Vector512.Create(0.0f), Vector512.Create(0.0f)); - TestInequalityUsingAndNot(Vector512.Create(-0.0f), Vector512.Create(-0.0f)); - TestInequalityUsingAndNot(Vector512.Create(0.0), Vector512.Create(0.0)); - TestInequalityUsingAndNot(Vector512.Create(-0.0), Vector512.Create(-0.0)); + TestInequalityUsingAndNot(Vector512.Zero, Vector512.Zero); + TestInequalityUsingAndNot(Vector512.NegativeZero, Vector512.NegativeZero); + TestInequalityUsingAndNot(Vector512.Zero, Vector512.Zero); + TestInequalityUsingAndNot(Vector512.NegativeZero, Vector512.NegativeZero); } [MethodImpl(MethodImplOptions.NoInlining)] diff --git a/src/tests/JIT/HardwareIntrinsics/X86/General/VectorRet.cs b/src/tests/JIT/HardwareIntrinsics/X86/General/VectorRet.cs index c9c68fbfcc4e68..9b57cb689cd84a 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/General/VectorRet.cs +++ b/src/tests/JIT/HardwareIntrinsics/X86/General/VectorRet.cs @@ -273,7 +273,7 @@ public static unsafe int Vector128ReturnTest() [MethodImplAttribute(MethodImplOptions.NoInlining)] public static Vector128 GetVector128Int16One() { - return Vector128.Create((short)1); + return Vector128.One; } [MethodImplAttribute(MethodImplOptions.NoInlining)] @@ -350,7 +350,7 @@ public static unsafe int Vector256ReturnTest() [MethodImplAttribute(MethodImplOptions.NoInlining)] public static Vector256 GetVector256Int32One() { - return Vector256.Create(1); + return Vector256.One; } [MethodImplAttribute(MethodImplOptions.NoInlining)] diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073.cs b/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073.cs index 197151b371a241..454a1f499c50b2 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073.cs +++ b/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073.cs @@ -26,873 +26,873 @@ public static void Test() r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN))); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN))); - r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Normal(Vector128.Create(0), Vector128.Create(0))); - r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Normal(Vector128.Create(1), Vector128.Create(2))); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Normal(Vector128.Zero, Vector128.Zero)); + r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Normal(Vector128.One, Vector128.Create(2))); r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_Normal(Vector128.Create(2), Vector128.Create(3))); r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_Normal(Vector128.Create(3), Vector128.Create(2))); - r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_LogicalNot(Vector128.Create(0), Vector128.Create(0))); - r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_LogicalNot(Vector128.Create(1), Vector128.Create(2))); + r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_LogicalNot(Vector128.Zero, Vector128.Zero)); + r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_LogicalNot(Vector128.One, Vector128.Create(2))); r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_LogicalNot(Vector128.Create(2), Vector128.Create(3))); r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_LogicalNot(Vector128.Create(3), Vector128.Create(2))); - r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Branch(Vector128.Create(0), Vector128.Create(0))); - r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Branch(Vector128.Create(1), Vector128.Create(2))); + r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Branch(Vector128.Zero, Vector128.Zero)); + r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Branch(Vector128.One, Vector128.Create(2))); r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_Branch(Vector128.Create(2), Vector128.Create(3))); r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_Branch(Vector128.Create(3), Vector128.Create(2))); - r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Swap(Vector128.Create(0), Vector128.Create(0))); - r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Swap(Vector128.Create(1), Vector128.Create(2))); + r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Swap(Vector128.Zero, Vector128.Zero)); + r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Swap(Vector128.One, Vector128.Create(2))); r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_Swap(Vector128.Create(2), Vector128.Create(3))); r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_Swap(Vector128.Create(3), Vector128.Create(2))); - r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_LogicalNot_Swap(Vector128.Create(0), Vector128.Create(0))); - r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_LogicalNot_Swap(Vector128.Create(1), Vector128.Create(2))); + r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_LogicalNot_Swap(Vector128.Zero, Vector128.Zero)); + r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_LogicalNot_Swap(Vector128.One, Vector128.Create(2))); r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_LogicalNot_Swap(Vector128.Create(2), Vector128.Create(3))); r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_LogicalNot_Swap(Vector128.Create(3), Vector128.Create(2))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector128.Create(0), Vector128.Create(0))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector128.Create(1), Vector128.Create(2))); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector128.Zero, Vector128.Zero)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector128.One, Vector128.Create(2))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Normal(Vector128.Create(2), Vector128.Create(3))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Normal(Vector128.Create(3), Vector128.Create(2))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector128.Create(0), Vector128.Create(0))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector128.Create(1), Vector128.Create(2))); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector128.Zero, Vector128.Zero)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector128.One, Vector128.Create(2))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot(Vector128.Create(2), Vector128.Create(3))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot(Vector128.Create(3), Vector128.Create(2))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector128.Create(0), Vector128.Create(0))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector128.Create(1), Vector128.Create(2))); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector128.Zero, Vector128.Zero)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector128.One, Vector128.Create(2))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Branch(Vector128.Create(2), Vector128.Create(3))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Branch(Vector128.Create(3), Vector128.Create(2))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector128.Create(0), Vector128.Create(0))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector128.Create(1), Vector128.Create(2))); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector128.Zero, Vector128.Zero)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector128.One, Vector128.Create(2))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Swap(Vector128.Create(2), Vector128.Create(3))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Swap(Vector128.Create(3), Vector128.Create(2))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Swap(Vector128.Create(0), Vector128.Create(0))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Swap(Vector128.Create(1), Vector128.Create(2))); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Swap(Vector128.Zero, Vector128.Zero)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Swap(Vector128.One, Vector128.Create(2))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot_Swap(Vector128.Create(2), Vector128.Create(3))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot_Swap(Vector128.Create(3), Vector128.Create(2))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector256.Create(0), Vector256.Create(0))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector256.Create(1), Vector256.Create(2))); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector256.Zero, Vector256.Zero)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector256.One, Vector256.Create(2))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Normal(Vector256.Create(2), Vector256.Create(3))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Normal(Vector256.Create(3), Vector256.Create(2))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector256.Create(0), Vector256.Create(0))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector256.Create(1), Vector256.Create(2))); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector256.Zero, Vector256.Zero)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector256.One, Vector256.Create(2))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot(Vector256.Create(2), Vector256.Create(3))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot(Vector256.Create(3), Vector256.Create(2))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector256.Create(0), Vector256.Create(0))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector256.Create(1), Vector256.Create(2))); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector256.Zero, Vector256.Zero)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector256.One, Vector256.Create(2))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Branch(Vector256.Create(2), Vector256.Create(3))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Branch(Vector256.Create(3), Vector256.Create(2))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector256.Create(0), Vector256.Create(0))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector256.Create(1), Vector256.Create(2))); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector256.Zero, Vector256.Zero)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector256.One, Vector256.Create(2))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Swap(Vector256.Create(2), Vector256.Create(3))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Swap(Vector256.Create(3), Vector256.Create(2))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Swap(Vector256.Create(0), Vector256.Create(0))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Swap(Vector256.Create(1), Vector256.Create(2))); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Swap(Vector256.Zero, Vector256.Zero)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Swap(Vector256.One, Vector256.Create(2))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot_Swap(Vector256.Create(2), Vector256.Create(3))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot_Swap(Vector256.Create(3), Vector256.Create(2))); - r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_Normal(Vector128.Create(0), Vector128.Create(0))); - r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_Normal(Vector128.Create(1), Vector128.Create(2))); + r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_Normal(Vector128.Zero, Vector128.Zero)); + r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_Normal(Vector128.One, Vector128.Create(2))); r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_Normal(Vector128.Create(2), Vector128.Create(3))); r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_Normal(Vector128.Create(3), Vector128.Create(2))); - r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_LogicalNot(Vector128.Create(0), Vector128.Create(0))); - r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_LogicalNot(Vector128.Create(1), Vector128.Create(2))); + r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_LogicalNot(Vector128.Zero, Vector128.Zero)); + r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_LogicalNot(Vector128.One, Vector128.Create(2))); r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_LogicalNot(Vector128.Create(2), Vector128.Create(3))); r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_LogicalNot(Vector128.Create(3), Vector128.Create(2))); - r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_Branch(Vector128.Create(0), Vector128.Create(0))); - r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_Branch(Vector128.Create(1), Vector128.Create(2))); + r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_Branch(Vector128.Zero, Vector128.Zero)); + r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_Branch(Vector128.One, Vector128.Create(2))); r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_Branch(Vector128.Create(2), Vector128.Create(3))); r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_Branch(Vector128.Create(3), Vector128.Create(2))); - r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_Swap(Vector128.Create(0), Vector128.Create(0))); - r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_Swap(Vector128.Create(1), Vector128.Create(2))); + r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_Swap(Vector128.Zero, Vector128.Zero)); + r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_Swap(Vector128.One, Vector128.Create(2))); r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_Swap(Vector128.Create(2), Vector128.Create(3))); r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_Swap(Vector128.Create(3), Vector128.Create(2))); - r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_LogicalNot_Swap(Vector128.Create(0), Vector128.Create(0))); - r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_LogicalNot_Swap(Vector128.Create(1), Vector128.Create(2))); + r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_LogicalNot_Swap(Vector128.Zero, Vector128.Zero)); + r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_LogicalNot_Swap(Vector128.One, Vector128.Create(2))); r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_LogicalNot_Swap(Vector128.Create(2), Vector128.Create(3))); r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_LogicalNot_Swap(Vector128.Create(3), Vector128.Create(2))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector128.Create(0), Vector128.Create(0))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Normal(Vector128.Create(1), Vector128.Create(2))); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector128.Zero, Vector128.Zero)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Normal(Vector128.One, Vector128.Create(2))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Normal(Vector128.Create(2), Vector128.Create(3))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector128.Create(3), Vector128.Create(2))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector128.Create(0), Vector128.Create(0))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot(Vector128.Create(1), Vector128.Create(2))); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector128.Zero, Vector128.Zero)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot(Vector128.One, Vector128.Create(2))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot(Vector128.Create(2), Vector128.Create(3))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector128.Create(3), Vector128.Create(2))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector128.Create(0), Vector128.Create(0))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Branch(Vector128.Create(1), Vector128.Create(2))); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector128.Zero, Vector128.Zero)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Branch(Vector128.One, Vector128.Create(2))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Branch(Vector128.Create(2), Vector128.Create(3))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector128.Create(3), Vector128.Create(2))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector128.Create(0), Vector128.Create(0))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Swap(Vector128.Create(1), Vector128.Create(2))); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector128.Zero, Vector128.Zero)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Swap(Vector128.One, Vector128.Create(2))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Swap(Vector128.Create(2), Vector128.Create(3))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector128.Create(3), Vector128.Create(2))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Swap(Vector128.Create(0), Vector128.Create(0))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot_Swap(Vector128.Create(1), Vector128.Create(2))); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Swap(Vector128.Zero, Vector128.Zero)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot_Swap(Vector128.One, Vector128.Create(2))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot_Swap(Vector128.Create(2), Vector128.Create(3))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Swap(Vector128.Create(3), Vector128.Create(2))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector256.Create(0), Vector256.Create(0))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Normal(Vector256.Create(1), Vector256.Create(2))); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector256.Zero, Vector256.Zero)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Normal(Vector256.One, Vector256.Create(2))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Normal(Vector256.Create(2), Vector256.Create(3))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector256.Create(3), Vector256.Create(2))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector256.Create(0), Vector256.Create(0))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot(Vector256.Create(1), Vector256.Create(2))); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector256.Zero, Vector256.Zero)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot(Vector256.One, Vector256.Create(2))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot(Vector256.Create(2), Vector256.Create(3))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector256.Create(3), Vector256.Create(2))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector256.Create(0), Vector256.Create(0))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Branch(Vector256.Create(1), Vector256.Create(2))); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector256.Zero, Vector256.Zero)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Branch(Vector256.One, Vector256.Create(2))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Branch(Vector256.Create(2), Vector256.Create(3))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector256.Create(3), Vector256.Create(2))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector256.Create(0), Vector256.Create(0))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Swap(Vector256.Create(1), Vector256.Create(2))); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector256.Zero, Vector256.Zero)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Swap(Vector256.One, Vector256.Create(2))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Swap(Vector256.Create(2), Vector256.Create(3))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector256.Create(3), Vector256.Create(2))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Swap(Vector256.Create(0), Vector256.Create(0))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot_Swap(Vector256.Create(1), Vector256.Create(2))); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Swap(Vector256.Zero, Vector256.Zero)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot_Swap(Vector256.One, Vector256.Create(2))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot_Swap(Vector256.Create(2), Vector256.Create(3))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Swap(Vector256.Create(3), Vector256.Create(2))); - r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Normal(Vector128.Create(0), Vector128.Create(0))); - r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Normal(Vector128.Create(1), Vector128.Create(2))); + r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Normal(Vector128.Zero, Vector128.Zero)); + r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Normal(Vector128.One, Vector128.Create(2))); r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_Normal(Vector128.Create(2), Vector128.Create(3))); r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Normal(Vector128.Create(3), Vector128.Create(2))); - r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_LogicalNot(Vector128.Create(0), Vector128.Create(0))); - r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_LogicalNot(Vector128.Create(1), Vector128.Create(2))); + r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_LogicalNot(Vector128.Zero, Vector128.Zero)); + r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_LogicalNot(Vector128.One, Vector128.Create(2))); r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_LogicalNot(Vector128.Create(2), Vector128.Create(3))); r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_LogicalNot(Vector128.Create(3), Vector128.Create(2))); - r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Branch(Vector128.Create(0), Vector128.Create(0))); - r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Branch(Vector128.Create(1), Vector128.Create(2))); + r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Branch(Vector128.Zero, Vector128.Zero)); + r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Branch(Vector128.One, Vector128.Create(2))); r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_Branch(Vector128.Create(2), Vector128.Create(3))); r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Branch(Vector128.Create(3), Vector128.Create(2))); - r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Swap(Vector128.Create(0), Vector128.Create(0))); - r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Swap(Vector128.Create(1), Vector128.Create(2))); + r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Swap(Vector128.Zero, Vector128.Zero)); + r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Swap(Vector128.One, Vector128.Create(2))); r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_Swap(Vector128.Create(2), Vector128.Create(3))); r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Swap(Vector128.Create(3), Vector128.Create(2))); - r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_LogicalNot_Swap(Vector128.Create(0), Vector128.Create(0))); - r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_LogicalNot_Swap(Vector128.Create(1), Vector128.Create(2))); + r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_LogicalNot_Swap(Vector128.Zero, Vector128.Zero)); + r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_LogicalNot_Swap(Vector128.One, Vector128.Create(2))); r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_LogicalNot_Swap(Vector128.Create(2), Vector128.Create(3))); r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_LogicalNot_Swap(Vector128.Create(3), Vector128.Create(2))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128.Create(0), Vector128.Create(0))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128.Create(1), Vector128.Create(2))); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128.Zero, Vector128.Zero)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128.One, Vector128.Create(2))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_Normal(Vector128.Create(2), Vector128.Create(3))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128.Create(3), Vector128.Create(2))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128.Create(0), Vector128.Create(0))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128.Create(1), Vector128.Create(2))); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128.Zero, Vector128.Zero)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128.One, Vector128.Create(2))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128.Create(2), Vector128.Create(3))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128.Create(3), Vector128.Create(2))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128.Create(0), Vector128.Create(0))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128.Create(1), Vector128.Create(2))); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128.Zero, Vector128.Zero)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128.One, Vector128.Create(2))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_Branch(Vector128.Create(2), Vector128.Create(3))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128.Create(3), Vector128.Create(2))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128.Create(0), Vector128.Create(0))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128.Create(1), Vector128.Create(2))); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128.Zero, Vector128.Zero)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128.One, Vector128.Create(2))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_Swap(Vector128.Create(2), Vector128.Create(3))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128.Create(3), Vector128.Create(2))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector128.Create(0), Vector128.Create(0))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector128.Create(1), Vector128.Create(2))); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector128.Zero, Vector128.Zero)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector128.One, Vector128.Create(2))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector128.Create(2), Vector128.Create(3))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector128.Create(3), Vector128.Create(2))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256.Create(0), Vector256.Create(0))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256.Create(1), Vector256.Create(2))); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256.Zero, Vector256.Zero)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256.One, Vector256.Create(2))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_Normal(Vector256.Create(2), Vector256.Create(3))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256.Create(3), Vector256.Create(2))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256.Create(0), Vector256.Create(0))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256.Create(1), Vector256.Create(2))); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256.Zero, Vector256.Zero)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256.One, Vector256.Create(2))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256.Create(2), Vector256.Create(3))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256.Create(3), Vector256.Create(2))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256.Create(0), Vector256.Create(0))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256.Create(1), Vector256.Create(2))); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256.Zero, Vector256.Zero)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256.One, Vector256.Create(2))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_Branch(Vector256.Create(2), Vector256.Create(3))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256.Create(3), Vector256.Create(2))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256.Create(0), Vector256.Create(0))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256.Create(1), Vector256.Create(2))); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256.Zero, Vector256.Zero)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256.One, Vector256.Create(2))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_Swap(Vector256.Create(2), Vector256.Create(3))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256.Create(3), Vector256.Create(2))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector256.Create(0), Vector256.Create(0))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector256.Create(1), Vector256.Create(2))); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector256.Zero, Vector256.Zero)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector256.One, Vector256.Create(2))); r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector256.Create(2), Vector256.Create(3))); r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector256.Create(3), Vector256.Create(2))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector128.Create(1.0f), Vector128.Create(1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector128.Create(1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Normal(Vector128.Create(-1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector128.Create(1.0f), Vector128.Create(1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector128.Create(1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot(Vector128.Create(-1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector128.Create(1.0f), Vector128.Create(1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector128.Create(1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Branch(Vector128.Create(-1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector128.Create(1.0f), Vector128.Create(1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector128.Create(1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Swap(Vector128.Create(-1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector128.Create(1.0f), Vector128.Create(1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector128.Create(1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector128.Create(-1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector256.Create(1.0f), Vector256.Create(1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector256.Create(1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Normal(Vector256.Create(-1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector256.Create(1.0f), Vector256.Create(1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector256.Create(1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot(Vector256.Create(-1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector256.Create(1.0f), Vector256.Create(1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector256.Create(1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Branch(Vector256.Create(-1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector256.Create(1.0f), Vector256.Create(1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector256.Create(1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Swap(Vector256.Create(-1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector256.Create(1.0f), Vector256.Create(1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector256.Create(1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector256.Create(-1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector128.Create(1.0f), Vector128.Create(1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Normal(Vector128.Create(1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector128.Create(-1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector128.Create(1.0f), Vector128.Create(1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot(Vector128.Create(1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector128.Create(-1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector128.Create(1.0f), Vector128.Create(1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Branch(Vector128.Create(1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector128.Create(-1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector128.Create(1.0f), Vector128.Create(1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Swap(Vector128.Create(1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector128.Create(-1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector128.Create(1.0f), Vector128.Create(1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector128.Create(1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector128.Create(-1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector256.Create(1.0f), Vector256.Create(1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Normal(Vector256.Create(1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector256.Create(-1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector256.Create(1.0f), Vector256.Create(1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot(Vector256.Create(1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector256.Create(-1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector256.Create(1.0f), Vector256.Create(1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Branch(Vector256.Create(1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector256.Create(-1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector256.Create(1.0f), Vector256.Create(1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Swap(Vector256.Create(1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector256.Create(-1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector256.Create(1.0f), Vector256.Create(1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector256.Create(1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector256.Create(-1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128.Create(1.0f), Vector128.Create(1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128.Create(1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128.Create(-1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128.Create(1.0f), Vector128.Create(1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128.Create(1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128.Create(-1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128.Create(1.0f), Vector128.Create(1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128.Create(1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128.Create(-1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128.Create(1.0f), Vector128.Create(1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128.Create(1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128.Create(-1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector128.Create(1.0f), Vector128.Create(1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector128.Create(1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector128.Create(-1.0f), Vector128.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256.Create(1.0f), Vector256.Create(1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256.Create(1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256.Create(-1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256.Create(1.0f), Vector256.Create(1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256.Create(1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256.Create(-1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256.Create(1.0f), Vector256.Create(1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256.Create(1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256.Create(-1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256.Create(1.0f), Vector256.Create(1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256.Create(1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256.Create(-1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector256.Create(1.0f), Vector256.Create(1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector256.Create(1.0f), Vector256.Create(-1.0f))); - r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector256.Create(-1.0f), Vector256.Create(-1.0f))); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector128.One, Vector128.One)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector128.One, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Normal(Vector128.NegativeOne, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector128.One, Vector128.One)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector128.One, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot(Vector128.NegativeOne, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector128.One, Vector128.One)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector128.One, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Branch(Vector128.NegativeOne, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector128.One, Vector128.One)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector128.One, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Swap(Vector128.NegativeOne, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector128.One, Vector128.One)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector128.One, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector128.NegativeOne, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector256.One, Vector256.One)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector256.One, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Normal(Vector256.NegativeOne, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector256.One, Vector256.One)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector256.One, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot(Vector256.NegativeOne, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector256.One, Vector256.One)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector256.One, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Branch(Vector256.NegativeOne, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector256.One, Vector256.One)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector256.One, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Swap(Vector256.NegativeOne, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector256.One, Vector256.One)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector256.One, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector256.NegativeOne, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector128.One, Vector128.One)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Normal(Vector128.One, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector128.NegativeOne, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector128.One, Vector128.One)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot(Vector128.One, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector128.NegativeOne, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector128.One, Vector128.One)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Branch(Vector128.One, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector128.NegativeOne, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector128.One, Vector128.One)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Swap(Vector128.One, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector128.NegativeOne, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector128.One, Vector128.One)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector128.One, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector128.NegativeOne, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector256.One, Vector256.One)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Normal(Vector256.One, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector256.NegativeOne, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector256.One, Vector256.One)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot(Vector256.One, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector256.NegativeOne, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector256.One, Vector256.One)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Branch(Vector256.One, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector256.NegativeOne, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector256.One, Vector256.One)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Swap(Vector256.One, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector256.NegativeOne, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector256.One, Vector256.One)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector256.One, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector256.NegativeOne, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128.One, Vector128.One)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128.One, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128.NegativeOne, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128.One, Vector128.One)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128.One, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128.NegativeOne, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128.One, Vector128.One)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128.One, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128.NegativeOne, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128.One, Vector128.One)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128.One, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128.NegativeOne, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector128.One, Vector128.One)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector128.One, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector128.NegativeOne, Vector128.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256.One, Vector256.One)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256.One, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256.NegativeOne, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256.One, Vector256.One)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256.One, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256.NegativeOne, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256.One, Vector256.One)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256.One, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256.NegativeOne, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256.One, Vector256.One)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256.One, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256.NegativeOne, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector256.One, Vector256.One)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector256.One, Vector256.NegativeOne)); + r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector256.NegativeOne, Vector256.NegativeOne)); Assert.True(r); } diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073_gen.csx b/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073_gen.csx index 99f4f5cbd7d16c..2bbfeace2e35b0 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073_gen.csx +++ b/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073_gen.csx @@ -168,9 +168,15 @@ void GeneratePackedDoubleTestTests(List tests) static string CreateVector(int vectorSize, string vectorElementType, double value) { if (vectorElementType == "Single") - return double.IsNaN(value) ? $"Vector{vectorSize}.Create(float.NaN)" : $"Vector{vectorSize}.Create({value:F1}f)"; + return double.IsNaN(value) ? $"Vector{vectorSize}.NaN" : + (value == 1.0f) ? $"Vector{vectorSize}.One" : + (value == -1.0f) ? $"Vector{vectorSize}.NegativeOne" : + $"Vector{vectorSize}.Create({value:F1}f)"; if (vectorElementType == "Double") - return double.IsNaN(value) ? $"Vector{vectorSize}.Create(double.NaN)" : $"Vector{vectorSize}.Create({value:F1})"; + return double.IsNaN(value) ? $"Vector{vectorSize}.NaN" + (value == 1.0) ? $"Vector{vectorSize}.One" : + (value == -1.0) ? $"Vector{vectorSize}.NegativeOne" : + $"Vector{vectorSize}.Create({value:F1})"; throw new NotSupportedException(); } diff --git a/src/tests/JIT/Performance/CodeQuality/BilinearInterpol/BilinearInterpol.cs b/src/tests/JIT/Performance/CodeQuality/BilinearInterpol/BilinearInterpol.cs index 248adb877dd226..f023ac405e4711 100644 --- a/src/tests/JIT/Performance/CodeQuality/BilinearInterpol/BilinearInterpol.cs +++ b/src/tests/JIT/Performance/CodeQuality/BilinearInterpol/BilinearInterpol.cs @@ -35,7 +35,7 @@ public class BilinearTest const int lengthB = 500; const double deltaB = (maxXB - minXB) / (double)(lengthB - 1); - //ref values + //ref values double[] A, B, input, output; internal void Setup() @@ -229,7 +229,7 @@ private static unsafe double[] BilinearInterpol_AVX( Vector128 ALengthMinusOne = Vector128.Create(A.Length - 1); Vector128 BLengthMinusOne = Vector128.Create(B.Length - 1); - Vector128 One = Vector128.Create(1); + Vector128 One = Vector128.One; for (var i = 0; i < x.Length; i += Vector256.Count) { diff --git a/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Camera.cs b/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Camera.cs index 0c73f35070df1d..31edb364ccfab0 100644 --- a/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Camera.cs +++ b/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Camera.cs @@ -18,7 +18,7 @@ internal class Camera public static Camera Create(VectorPacket256 pos, VectorPacket256 lookAt) { VectorPacket256 forward = (lookAt - pos).Normalize(); - VectorPacket256 down = new VectorPacket256(Vector256.Zero, Vector256.Create(-1.0f), Vector256.Zero); + VectorPacket256 down = new VectorPacket256(Vector256.Zero, Vector256.NegativeOne, Vector256.Zero); Vector256 OnePointFive = Vector256.Create(1.5f); VectorPacket256 right = OnePointFive * VectorPacket256.CrossProduct(forward, down).Normalize(); VectorPacket256 up = OnePointFive * VectorPacket256.CrossProduct(forward, right).Normalize(); diff --git a/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Intersections.cs b/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Intersections.cs index 8feb8acdaff83a..30a5de46e307a2 100644 --- a/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Intersections.cs +++ b/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Intersections.cs @@ -15,7 +15,7 @@ internal struct Intersections public Vector256 ThingIndices; public static readonly Vector256 NullDistance = Vector256.Create(float.MaxValue); - public static readonly Vector256 NullIndex = Vector256.Create(-1); + public static readonly Vector256 NullIndex = Vector256.NegativeOne; public Intersections(Vector256 dis, Vector256 things) { diff --git a/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/PacketTracer.cs b/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/PacketTracer.cs index 093eea990c2174..036c474a425167 100644 --- a/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/PacketTracer.cs +++ b/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/PacketTracer.cs @@ -53,7 +53,7 @@ internal unsafe void RenderVectorized(Scene scene, int* rgb) Store(output + 8, intAoS.Gs); Store(output + 16, intAoS.Bs); } - + } } @@ -226,7 +226,7 @@ private static Scene CreateDefaultScene() { ObjectPacket256[] things = { new SpherePacket256(new VectorPacket256(-0.5f, 1f, 1.5f), Vector256.Create(0.5f), Surfaces.MatteShiny), - new SpherePacket256(new VectorPacket256(0f, 1f, -0.25f), Vector256.Create(1f), Surfaces.Shiny), + new SpherePacket256(new VectorPacket256(0f, 1f, -0.25f), Vector256.One, Surfaces.Shiny), new PlanePacket256((new VectorPacket256(0, 1, 0)), Vector256.Create(0f), Surfaces.CheckerBoard) }; diff --git a/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Surfaces.cs b/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Surfaces.cs index 1bbca5db7246ed..e044ed6b47e04b 100644 --- a/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Surfaces.cs +++ b/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Surfaces.cs @@ -20,7 +20,7 @@ internal static class Surfaces delegate (VectorPacket256 pos) { var floored = ConvertToVector256Int32(Add(Floor(pos.Zs), Floor(pos.Xs))); - var modMask = Vector256.Create(1); + var modMask = Vector256.One; var evenMaskint = Avx2.And(floored, modMask); var evenMask = Avx2.CompareEqual(evenMaskint, modMask); @@ -34,7 +34,7 @@ internal static class Surfaces delegate (VectorPacket256 pos) { var floored = ConvertToVector256Int32(Add(Floor(pos.Zs), Floor(pos.Xs))); - var modMask = Vector256.Create(1); + var modMask = Vector256.One; var evenMaskUint = Avx2.And(floored, modMask); var evenMask = Avx2.CompareEqual(evenMaskUint, modMask); diff --git a/src/tests/JIT/Regression/JitBlue/GitHub_19583/GitHub_19583.cs b/src/tests/JIT/Regression/JitBlue/GitHub_19583/GitHub_19583.cs index 0031ad6a0d7ac7..f7104c2bc3f43a 100644 --- a/src/tests/JIT/Regression/JitBlue/GitHub_19583/GitHub_19583.cs +++ b/src/tests/JIT/Regression/JitBlue/GitHub_19583/GitHub_19583.cs @@ -78,7 +78,7 @@ public static unsafe int Run() if (!Sse2.IsSupported) return 0; vec v = new vec(); - Vector128 o = Vector128.Create(1); + Vector128 o = Vector128.One; int vr16 = v.y; Sse2.Store(&v.x, o); return vr16; diff --git a/src/tests/JIT/Regression/JitBlue/GitHub_23530/GitHub_23530.cs b/src/tests/JIT/Regression/JitBlue/GitHub_23530/GitHub_23530.cs index 0c77aad1b94a82..dd9fb3a02f9b8d 100644 --- a/src/tests/JIT/Regression/JitBlue/GitHub_23530/GitHub_23530.cs +++ b/src/tests/JIT/Regression/JitBlue/GitHub_23530/GitHub_23530.cs @@ -25,7 +25,7 @@ struct vec static unsafe float fmaTest() { vec a; - var b = Vector128.Create(1f); + var b = Vector128.One; var c = Vector128.Create(2f); var d = Vector128.Create(3f); diff --git a/src/tests/JIT/Regression/JitBlue/ImageSharp_2117/ImageSharp_2117.cs b/src/tests/JIT/Regression/JitBlue/ImageSharp_2117/ImageSharp_2117.cs index 27fbc9ffa31b5c..c7d888033dc0c5 100644 --- a/src/tests/JIT/Regression/JitBlue/ImageSharp_2117/ImageSharp_2117.cs +++ b/src/tests/JIT/Regression/JitBlue/ImageSharp_2117/ImageSharp_2117.cs @@ -12,7 +12,7 @@ public static int TestEntryPoint() { if (Sse.IsSupported) { - Vector128 fnan = Vector128.Create(float.NaN); + Vector128 fnan = Vector128.NaN; Vector128 res1 = Sse.Max(Sse.LoadVector128((float*)(&fnan)), Vector128.Zero); Vector128 res2 = Sse.Min(Sse.LoadVector128((float*)(&fnan)), Vector128.Zero); @@ -24,7 +24,7 @@ public static int TestEntryPoint() if (Sse2.IsSupported) { - Vector128 dnan = Vector128.Create(double.NaN); + Vector128 dnan = Vector128.NaN; Vector128 res3 = Sse2.Max(Sse2.LoadVector128((double*)(&dnan)), Vector128.Zero); Vector128 res4 = Sse2.Min(Sse2.LoadVector128((double*)(&dnan)), Vector128.Zero); diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_106546/Runtime_106546.cs b/src/tests/JIT/Regression/JitBlue/Runtime_106546/Runtime_106546.cs index a92d32daed0c61..75c7df4d0af5b0 100644 --- a/src/tests/JIT/Regression/JitBlue/Runtime_106546/Runtime_106546.cs +++ b/src/tests/JIT/Regression/JitBlue/Runtime_106546/Runtime_106546.cs @@ -124,4 +124,4 @@ private unsafe void GatherMaskVector256() Console.WriteLine(Avx2.GatherMaskVector256(source, ptr, indices, mask, 7)); } } -} \ No newline at end of file +} diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_108609/Runtime_108609.cs b/src/tests/JIT/Regression/JitBlue/Runtime_108609/Runtime_108609.cs index fdbd8b2821109d..22143cef52afef 100644 --- a/src/tests/JIT/Regression/JitBlue/Runtime_108609/Runtime_108609.cs +++ b/src/tests/JIT/Regression/JitBlue/Runtime_108609/Runtime_108609.cs @@ -32,7 +32,7 @@ public struct S1 static Vector128 s_v128_short_31 = Vector128.Create(0, 2, -5, 0, 1, 0, 2, 2); static Vector128 s_v128_ulong_36 = Vector128.Zero; static Vector128 s_v128_double_38 = Vector128.Create(1.0769230769230769, 72.01666666666667); - static Vector s_v_ulong_46 = Vector.Create((ulong)1); + static Vector s_v_ulong_46 = Vector.One; static Vector s_v_float_47 = Vector.Zero; static S1 s_s1_52 = new S1(); char char_56 = 'K'; @@ -42,7 +42,7 @@ public struct S1 Vector128 v128_sbyte_80 = Vector128.Create(-2, -2, -1, 0, 5, -1, -1, -1, 1, 2, -1, 0, -1, 72, -5, 0); Vector128 v128_short_81 = Vector128.CreateScalar((short)-1); Vector128 v128_ulong_86 = Vector128.AllBitsSet; - Vector v_ulong_96 = Vector.Create((ulong)1); + Vector v_ulong_96 = Vector.One; Vector v_float_97 = Vector.Create(2f); Vector3 v3_100 = Vector3.Create(0.09090909f, 2.4f, -0.94f); S1 s1_102 = new S1(); @@ -86,13 +86,13 @@ private void Method0() return; } } - + [Fact] public static void TestEntryPoint() { Antigen(); } - + private static int Antigen() { new Runtime_108609().Method0(); diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs b/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs index f6f1d600fb5509..c503442ee12329 100644 --- a/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs +++ b/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs @@ -686,28 +686,28 @@ static int Tests_AdvSimd() // Begin CompareGreaterThan Tests - if (!ValidateResult_Vector64(AdvSimd_CompareGreaterThan_Vector64_Byte_Zero(Vector64.Create((byte)1)), Byte.MaxValue)) + if (!ValidateResult_Vector64(AdvSimd_CompareGreaterThan_Vector64_Byte_Zero(Vector64.One), Byte.MaxValue)) result = -1; - if (!ValidateResult_Vector64(AdvSimd_CompareGreaterThan_Vector64_Single_Zero(Vector64.Create(1.0f)), Single.NaN)) + if (!ValidateResult_Vector64(AdvSimd_CompareGreaterThan_Vector64_Single_Zero(Vector64.One), Single.NaN)) result = -1; - if (!ValidateResult_Vector128(AdvSimd_CompareGreaterThan_Vector128_Byte_Zero(Vector128.Create((byte)1)), Byte.MaxValue)) + if (!ValidateResult_Vector128(AdvSimd_CompareGreaterThan_Vector128_Byte_Zero(Vector128.One), Byte.MaxValue)) result = -1; - if (!ValidateResult_Vector128(AdvSimd_CompareGreaterThan_Vector128_Single_Zero(Vector128.Create(1.0f)), Single.NaN)) + if (!ValidateResult_Vector128(AdvSimd_CompareGreaterThan_Vector128_Single_Zero(Vector128.One), Single.NaN)) result = -1; - if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareGreaterThan_Vector128_Double_Zero(Vector128.Create(1.0)), Double.NaN)) + if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareGreaterThan_Vector128_Double_Zero(Vector128.One), Double.NaN)) result = -1; - if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareGreaterThan_Vector128_Int64_Zero(Vector128.Create(1L)), -1)) + if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareGreaterThan_Vector128_Int64_Zero(Vector128.One), -1)) result = -1; - if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareGreaterThanScalar_Vector64_Double_Zero(Vector64.Create(1.0)), Double.NaN)) + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareGreaterThanScalar_Vector64_Double_Zero(Vector64.One), Double.NaN)) result = -1; - if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareGreaterThanScalar_Vector64_Int64_Zero(Vector64.Create(1L)), -1)) + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareGreaterThanScalar_Vector64_Int64_Zero(Vector64.One), -1)) result = -1; if (ValidateResult_Vector64(AdvSimd_CompareGreaterThan_Vector64_Byte_Zero(Vector64.Zero), Byte.MaxValue)) @@ -738,28 +738,28 @@ static int Tests_AdvSimd() // Begin CompareGreaterThanOrEqual Tests - if (!ValidateResult_Vector64(AdvSimd_CompareGreaterThanOrEqual_Vector64_Byte_Zero(Vector64.Create((byte)1)), Byte.MaxValue)) + if (!ValidateResult_Vector64(AdvSimd_CompareGreaterThanOrEqual_Vector64_Byte_Zero(Vector64.One), Byte.MaxValue)) result = -1; - if (!ValidateResult_Vector64(AdvSimd_CompareGreaterThanOrEqual_Vector64_Single_Zero(Vector64.Create(1.0f)), Single.NaN)) + if (!ValidateResult_Vector64(AdvSimd_CompareGreaterThanOrEqual_Vector64_Single_Zero(Vector64.One), Single.NaN)) result = -1; - if (!ValidateResult_Vector128(AdvSimd_CompareGreaterThanOrEqual_Vector128_Byte_Zero(Vector128.Create((byte)1)), Byte.MaxValue)) + if (!ValidateResult_Vector128(AdvSimd_CompareGreaterThanOrEqual_Vector128_Byte_Zero(Vector128.One), Byte.MaxValue)) result = -1; - if (!ValidateResult_Vector128(AdvSimd_CompareGreaterThanOrEqual_Vector128_Single_Zero(Vector128.Create(1.0f)), Single.NaN)) + if (!ValidateResult_Vector128(AdvSimd_CompareGreaterThanOrEqual_Vector128_Single_Zero(Vector128.One), Single.NaN)) result = -1; - if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareGreaterThanOrEqual_Vector128_Double_Zero(Vector128.Create(1.0)), Double.NaN)) + if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareGreaterThanOrEqual_Vector128_Double_Zero(Vector128.One), Double.NaN)) result = -1; - if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareGreaterThanOrEqual_Vector128_Int64_Zero(Vector128.Create(1L)), -1)) + if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareGreaterThanOrEqual_Vector128_Int64_Zero(Vector128.One), -1)) result = -1; - if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareGreaterThanOrEqualScalar_Vector64_Double_Zero(Vector64.Create(1.0)), Double.NaN)) + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareGreaterThanOrEqualScalar_Vector64_Double_Zero(Vector64.One), Double.NaN)) result = -1; - if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareGreaterThanOrEqualScalar_Vector64_Int64_Zero(Vector64.Create(1L)), -1)) + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareGreaterThanOrEqualScalar_Vector64_Int64_Zero(Vector64.One), -1)) result = -1; if (!ValidateResult_Vector64(AdvSimd_CompareGreaterThanOrEqual_Vector64_Byte_Zero(Vector64.Zero), Byte.MaxValue)) diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_39737/Runtime_39737.cs b/src/tests/JIT/Regression/JitBlue/Runtime_39737/Runtime_39737.cs index 5754400fc5ae3c..5f6fbf9396a892 100644 --- a/src/tests/JIT/Regression/JitBlue/Runtime_39737/Runtime_39737.cs +++ b/src/tests/JIT/Regression/JitBlue/Runtime_39737/Runtime_39737.cs @@ -10,13 +10,13 @@ using Xunit; public class Runtime_39403 -{ +{ [Fact] public static void TestEntryPoint() { if (Sse41.IsSupported) { - Vector128 left = Vector128.Create(1); + Vector128 left = Vector128.One; Vector128 right = Vector128.Create(2); ref var rightRef = ref right; Vector128 mask = Vector128.Create(3); diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_72506/Runtime_72506.cs b/src/tests/JIT/Regression/JitBlue/Runtime_72506/Runtime_72506.cs index 15eaedc71b2089..9cef24567724d2 100644 --- a/src/tests/JIT/Regression/JitBlue/Runtime_72506/Runtime_72506.cs +++ b/src/tests/JIT/Regression/JitBlue/Runtime_72506/Runtime_72506.cs @@ -14,25 +14,25 @@ public class Runtime_72506 public static int TestEntryPoint() { // float - AssertEqual(Vector256.Create(1f).ToString(), "<1, 1, 1, 1, 1, 1, 1, 1>"); + AssertEqual(Vector256.One.ToString(), "<1, 1, 1, 1, 1, 1, 1, 1>"); AssertEqual(Vector256.CreateScalar(1f).ToString(), "<1, 0, 0, 0, 0, 0, 0, 0>"); AssertEqual(Vector256.CreateScalarUnsafe(1f).ToScalar().ToString(), "1"); AssertEqual(Vector256.Create(0.0f, 1, 2, 3, 4, 5, 6, 7).ToString(), "<0, 1, 2, 3, 4, 5, 6, 7>"); // double - AssertEqual(Vector256.Create(1.0).ToString(), "<1, 1, 1, 1>"); + AssertEqual(Vector256.One.ToString(), "<1, 1, 1, 1>"); AssertEqual(Vector256.CreateScalar(1.0).ToString(), "<1, 0, 0, 0>"); AssertEqual(Vector256.CreateScalarUnsafe(1.0).ToScalar().ToString(), "1"); AssertEqual(Vector256.Create(0.0, 1, 2, 3).ToString(), "<0, 1, 2, 3>"); // ushort - AssertEqual(Vector256.Create((ushort)1).ToString(), "<1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1>"); + AssertEqual(Vector256.One.ToString(), "<1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1>"); AssertEqual(Vector256.CreateScalar((ushort)1).ToString(), "<1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>"); AssertEqual(Vector256.CreateScalarUnsafe((ushort)1).ToScalar().ToString(), "1"); AssertEqual(Vector256.Create((ushort)0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15).ToString(), "<0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15>"); // long - AssertEqual(Vector256.Create((long)1).ToString(), "<1, 1, 1, 1>"); + AssertEqual(Vector256.One.ToString(), "<1, 1, 1, 1>"); AssertEqual(Vector256.CreateScalar((long)1).ToString(), "<1, 0, 0, 0>"); AssertEqual(Vector256.CreateScalarUnsafe((long)1).ToScalar().ToString(), "1"); AssertEqual(Vector256.Create((long)0, 1, 2, 3).ToString(), "<0, 1, 2, 3>"); diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_90508/Runtime_90508.cs b/src/tests/JIT/Regression/JitBlue/Runtime_90508/Runtime_90508.cs index ce2881a9d67185..d3d523a7f133b9 100644 --- a/src/tests/JIT/Regression/JitBlue/Runtime_90508/Runtime_90508.cs +++ b/src/tests/JIT/Regression/JitBlue/Runtime_90508/Runtime_90508.cs @@ -18,7 +18,7 @@ private static Vector128 Test2(Vector128 v) => [MethodImpl(MethodImplOptions.NoInlining)] private static Vector128 Test3(Vector128 v) => - v + Sse3.MoveAndDuplicate(Vector128.Create(1.0)); + v + Sse3.MoveAndDuplicate(Vector128.One); [Fact] public static int TestEntryPoint() diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_91252/Runtime_91252.cs b/src/tests/JIT/Regression/JitBlue/Runtime_91252/Runtime_91252.cs index d4035f3de978fc..d3720603279e16 100644 --- a/src/tests/JIT/Regression/JitBlue/Runtime_91252/Runtime_91252.cs +++ b/src/tests/JIT/Regression/JitBlue/Runtime_91252/Runtime_91252.cs @@ -1,7 +1,7 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // -// This test verifies if we correctly value number the operation of +// This test verifies if we correctly value number the operation of // x ^ x to zero. // // Found by Antigen @@ -13,7 +13,7 @@ public class Issue_91252 { static Vector64 s_v64_int_22 = Vector64.Create(-5); - Vector64 v64_int_72 = Vector64.Create(-1); + Vector64 v64_int_72 = Vector64.NegativeOne; [MethodImpl(MethodImplOptions.NoInlining)] public int Repro() diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_91335/Runtime_91335.cs b/src/tests/JIT/Regression/JitBlue/Runtime_91335/Runtime_91335.cs index 067b25abb8e826..b11b48eae7028a 100644 --- a/src/tests/JIT/Regression/JitBlue/Runtime_91335/Runtime_91335.cs +++ b/src/tests/JIT/Regression/JitBlue/Runtime_91335/Runtime_91335.cs @@ -28,7 +28,7 @@ public struct S2 static Vector128 s_v128_int_32 = Vector128.CreateScalar(2); static Vector128 s_v128_uint_33 = Vector128.Create((uint)1, 1, 1, 2); static Vector128 s_v128_long_34 = Vector128.Create(-2, 2); - static Vector128 s_v128_ulong_35 = Vector128.Create((ulong)1); + static Vector128 s_v128_ulong_35 = Vector128.One; static Vector128 s_v128_float_36 = Vector128.CreateScalar(0.1f); static Vector128 s_v128_double_37 = Vector128.Create(1.0235294117647058, 2); static Vector256 s_v256_byte_38 = Vector256.CreateScalar((byte)5); @@ -41,7 +41,7 @@ public struct S2 static Vector256 s_v256_ulong_45 = Vector256.Zero; static Vector256 s_v256_float_46 = Vector256.CreateScalar(-4.969697f); static Vector256 s_v256_double_47 = Vector256.Create(97.03448275862068); - static Vector512 s_v512_byte_48 = Vector512.Create((byte)1); + static Vector512 s_v512_byte_48 = Vector512.One; static Vector512 s_v512_sbyte_49 = Vector512.Create((sbyte)5); static Vector512 s_v512_short_50 = Vector512.AllBitsSet; static Vector512 s_v512_ushort_51 = Vector512.AllBitsSet; @@ -75,7 +75,7 @@ public struct S2 public Vector256 Method31() { byte byte_929 = 2; - return s_v256_int_42 += v256_int_101 | v256_int_101 ^ v256_int_101 | + return s_v256_int_42 += v256_int_101 | v256_int_101 ^ v256_int_101 | Vector256.AllBitsSet & s_v256_int_42 ^ (s_v256_int_42 *= v256_int_101) - (v256_int_101 ^ Vector256.Zero) & (v256_int_101 *= v256_int_101) - Avx2.ShiftRightLogical(v256_int_101, byte_929); } diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_92357/Runtime_92357.cs b/src/tests/JIT/Regression/JitBlue/Runtime_92357/Runtime_92357.cs index 4704441bacce6c..37a9a3b8154921 100644 --- a/src/tests/JIT/Regression/JitBlue/Runtime_92357/Runtime_92357.cs +++ b/src/tests/JIT/Regression/JitBlue/Runtime_92357/Runtime_92357.cs @@ -20,14 +20,14 @@ public static void Problem() int y1 = 5; - Vector256 actual1 = Test1(Vector256.Create((short)1), ref y1); + Vector256 actual1 = Test1(Vector256.One, ref y1); Vector256 expected1 = Vector256.Create(10, 0, 10, 0, 10, 0, 10, 0, 10, 0, 10, 0, 10, 0, 10, 0); Assert.Equal(expected1, actual1); long y2 = 5; - Vector256 actual2 = Test2(Vector256.Create((int)1), ref y2); + Vector256 actual2 = Test2(Vector256.One, ref y2); Vector256 expected2 = Vector256.Create(10, 0, 10, 0, 10, 0, 10, 0); Assert.Equal(expected2, actual2); diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_92590/Runtime_92590.cs b/src/tests/JIT/Regression/JitBlue/Runtime_92590/Runtime_92590.cs index 99a5ef2ee5d18d..dd01b9ab9bda06 100644 --- a/src/tests/JIT/Regression/JitBlue/Runtime_92590/Runtime_92590.cs +++ b/src/tests/JIT/Regression/JitBlue/Runtime_92590/Runtime_92590.cs @@ -13,22 +13,22 @@ public static void TestEntryPoint() { Span bytes = stackalloc byte[4]; bytes.Fill(0xff); - TestByteByte(ref bytes[0], 0, Vector256.Create((byte)1)); + TestByteByte(ref bytes[0], 0, Vector256.One; Assert.True(bytes.SequenceEqual(stackalloc byte[] { 0x2, 0xff, 0xff, 0xff })); bytes.Fill(0xff); - TestByteInt(ref bytes[0], 0, Vector256.Create(1)); + TestByteInt(ref bytes[0], 0, Vector256.One); Assert.True(bytes.SequenceEqual(stackalloc byte[] { 0x2, 0xff, 0xff, 0xff })); int i = int.MaxValue; - TestIntByte(ref i, 0, Vector256.Create((byte)1)); + TestIntByte(ref i, 0, Vector256.One; Assert.Equal(2, i); i = int.MaxValue; - TestIntInt(ref i, 0, Vector256.Create(1)); + TestIntInt(ref i, 0, Vector256.One); Assert.Equal(2, i); } diff --git a/src/tests/JIT/opt/Loops/LoopSideEffectsForHwiStores.cs b/src/tests/JIT/opt/Loops/LoopSideEffectsForHwiStores.cs index 3a99365bcce6b9..a711ac9b5e8fea 100644 --- a/src/tests/JIT/opt/Loops/LoopSideEffectsForHwiStores.cs +++ b/src/tests/JIT/opt/Loops/LoopSideEffectsForHwiStores.cs @@ -39,7 +39,7 @@ static unsafe Vector128 ProblemWithSse2(ClassWithVtor a, byte* p) { Vector128 vtor = Vector128.Zero; - a.VtorField = Vector128.Create(1); + a.VtorField = Vector128.One; a.VtorField = Sse2.Add(a.VtorField, a.VtorField); for (int i = 0; i < 10; i++) @@ -56,7 +56,7 @@ static unsafe Vector128 ProblemWithAdvSimd(ClassWithVtor a, byte* p) { Vector128 vtor = Vector128.Zero; - a.VtorField = Vector128.Create(1); + a.VtorField = Vector128.One; a.VtorField = AdvSimd.Add(a.VtorField, a.VtorField); for (int i = 0; i < 10; i++) From 25a962fdf4e952810aec5cfb6c765bf12e9cb3f7 Mon Sep 17 00:00:00 2001 From: Tanner Gooding Date: Wed, 23 Jul 2025 08:35:17 -0700 Subject: [PATCH 02/10] Use static_cast instead of I64 --- src/coreclr/jit/hwintrinsicarm64.cpp | 18 +++++++++--------- src/coreclr/jit/hwintrinsicxarch.cpp | 18 +++++++++--------- 2 files changed, 18 insertions(+), 18 deletions(-) diff --git a/src/coreclr/jit/hwintrinsicarm64.cpp b/src/coreclr/jit/hwintrinsicarm64.cpp index 22f4e1b787538f..02a0afbfad294e 100644 --- a/src/coreclr/jit/hwintrinsicarm64.cpp +++ b/src/coreclr/jit/hwintrinsicarm64.cpp @@ -1420,13 +1420,13 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, if (simdBaseType == TYP_FLOAT) { GenTreeVecCon* vecCns = gtNewVconNode(retType); - vecCns->EvaluateBroadcastInPlace(TYP_INT, I64(0x00000001)); + vecCns->EvaluateBroadcastInPlace(TYP_INT, static_cast(0x00000001)); retNode = vecCns; } else if (simdBaseType == TYP_DOUBLE) { GenTreeVecCon* vecCns = gtNewVconNode(retType); - vecCns->EvaluateBroadcastInPlace(TYP_LONG, I64(0x0000000000000001)); + vecCns->EvaluateBroadcastInPlace(TYP_LONG, static_cast(0x0000000000000001)); retNode = vecCns; } break; @@ -1448,13 +1448,13 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, if (simdBaseType == TYP_FLOAT) { GenTreeVecCon* vecCns = gtNewVconNode(retType); - vecCns->EvaluateBroadcastInPlace(TYP_INT, I64(0x7FC00000)); + vecCns->EvaluateBroadcastInPlace(TYP_INT, static_cast(0x7FC00000)); retNode = vecCns; } else if (simdBaseType == TYP_DOUBLE) { GenTreeVecCon* vecCns = gtNewVconNode(retType); - vecCns->EvaluateBroadcastInPlace(TYP_LONG, I64(0x7FF8000000000000)); + vecCns->EvaluateBroadcastInPlace(TYP_LONG, static_cast(0x7FF8000000000000)); retNode = vecCns; } break; @@ -1468,13 +1468,13 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, if (simdBaseType == TYP_FLOAT) { GenTreeVecCon* vecCns = gtNewVconNode(retType); - vecCns->EvaluateBroadcastInPlace(TYP_INT, I64(0xFF800000)); + vecCns->EvaluateBroadcastInPlace(TYP_INT, static_cast(0xFF800000)); retNode = vecCns; } else if (simdBaseType == TYP_DOUBLE) { GenTreeVecCon* vecCns = gtNewVconNode(retType); - vecCns->EvaluateBroadcastInPlace(TYP_LONG, I64(0xFFF0000000000000)); + vecCns->EvaluateBroadcastInPlace(TYP_LONG, static_cast(0xFFF0000000000000)); retNode = vecCns; } break; @@ -1494,7 +1494,7 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, else if (varTypeIsSigned(simdBaseType)) { GenTreeVecCon* vecCns = gtNewVconNode(retType); - vecCns->EvaluateBroadcastInPlace(simdBaseType, I64(-1)); + vecCns->EvaluateBroadcastInPlace(simdBaseType, static_cast(-1)); retNode = vecCns; } break; @@ -1544,13 +1544,13 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, if (simdBaseType == TYP_FLOAT) { GenTreeVecCon* vecCns = gtNewVconNode(retType); - vecCns->EvaluateBroadcastInPlace(TYP_INT, I64(0x7F800000)); + vecCns->EvaluateBroadcastInPlace(TYP_INT, static_cast(0x7F800000)); retNode = vecCns; } else if (simdBaseType == TYP_DOUBLE) { GenTreeVecCon* vecCns = gtNewVconNode(retType); - vecCns->EvaluateBroadcastInPlace(TYP_LONG, I64(0x7FF0000000000000)); + vecCns->EvaluateBroadcastInPlace(TYP_LONG, static_cast(0x7FF0000000000000)); retNode = vecCns; } break; diff --git a/src/coreclr/jit/hwintrinsicxarch.cpp b/src/coreclr/jit/hwintrinsicxarch.cpp index 1ae9124435ce1e..04feba178f7d91 100644 --- a/src/coreclr/jit/hwintrinsicxarch.cpp +++ b/src/coreclr/jit/hwintrinsicxarch.cpp @@ -2552,13 +2552,13 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, if (simdBaseType == TYP_FLOAT) { GenTreeVecCon* vecCns = gtNewVconNode(retType); - vecCns->EvaluateBroadcastInPlace(TYP_INT, I64(0x00000001)); + vecCns->EvaluateBroadcastInPlace(TYP_INT, static_cast(0x00000001)); retNode = vecCns; } else if (simdBaseType == TYP_DOUBLE) { GenTreeVecCon* vecCns = gtNewVconNode(retType); - vecCns->EvaluateBroadcastInPlace(TYP_LONG, I64(0x0000000000000001)); + vecCns->EvaluateBroadcastInPlace(TYP_LONG, static_cast(0x0000000000000001)); retNode = vecCns; } break; @@ -2582,13 +2582,13 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, if (simdBaseType == TYP_FLOAT) { GenTreeVecCon* vecCns = gtNewVconNode(retType); - vecCns->EvaluateBroadcastInPlace(TYP_INT, I64(0xFFC00000)); + vecCns->EvaluateBroadcastInPlace(TYP_INT, static_cast(0xFFC00000)); retNode = vecCns; } else if (simdBaseType == TYP_DOUBLE) { GenTreeVecCon* vecCns = gtNewVconNode(retType); - vecCns->EvaluateBroadcastInPlace(TYP_LONG, I64(0xFFF8000000000000)); + vecCns->EvaluateBroadcastInPlace(TYP_LONG, static_cast(0xFFF8000000000000)); retNode = vecCns; } break; @@ -2603,13 +2603,13 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, if (simdBaseType == TYP_FLOAT) { GenTreeVecCon* vecCns = gtNewVconNode(retType); - vecCns->EvaluateBroadcastInPlace(TYP_INT, I64(0xFF800000)); + vecCns->EvaluateBroadcastInPlace(TYP_INT, static_cast(0xFF800000)); retNode = vecCns; } else if (simdBaseType == TYP_DOUBLE) { GenTreeVecCon* vecCns = gtNewVconNode(retType); - vecCns->EvaluateBroadcastInPlace(TYP_LONG, I64(0xFFF0000000000000)); + vecCns->EvaluateBroadcastInPlace(TYP_LONG, static_cast(0xFFF0000000000000)); retNode = vecCns; } break; @@ -2630,7 +2630,7 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, else if (varTypeIsSigned(simdBaseType)) { GenTreeVecCon* vecCns = gtNewVconNode(retType); - vecCns->EvaluateBroadcastInPlace(simdBaseType, I64(-1)); + vecCns->EvaluateBroadcastInPlace(simdBaseType, static_cast(-1)); retNode = vecCns; } break; @@ -2684,13 +2684,13 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, if (simdBaseType == TYP_FLOAT) { GenTreeVecCon* vecCns = gtNewVconNode(retType); - vecCns->EvaluateBroadcastInPlace(TYP_INT, I64(0x7F800000)); + vecCns->EvaluateBroadcastInPlace(TYP_INT, static_cast(0x7F800000)); retNode = vecCns; } else if (simdBaseType == TYP_DOUBLE) { GenTreeVecCon* vecCns = gtNewVconNode(retType); - vecCns->EvaluateBroadcastInPlace(TYP_LONG, I64(0x7FF0000000000000)); + vecCns->EvaluateBroadcastInPlace(TYP_LONG, static_cast(0x7FF0000000000000)); retNode = vecCns; } break; From 1f17a81ac387783e29a56577f869542ab50caa2e Mon Sep 17 00:00:00 2001 From: Tanner Gooding Date: Wed, 23 Jul 2025 09:27:44 -0700 Subject: [PATCH 03/10] Ensure mono corelib also suppresses the API compat warnings for extension members --- .../CompatibilitySuppressions.xml | 3 +- .../System.Private.CoreLib.csproj | 2 + .../tests/Vectors/Vector128Tests.cs | 4 +- .../tests/Vectors/Vector256Tests.cs | 4 +- .../tests/Vectors/Vector512Tests.cs | 4 +- .../tests/Vectors/Vector64Tests.cs | 4 +- .../CompatibilitySuppressions.xml | 95 +++++++++++++++++++ .../System.Private.CoreLib.csproj | 6 ++ 8 files changed, 113 insertions(+), 9 deletions(-) create mode 100644 src/mono/System.Private.CoreLib/CompatibilitySuppressions.xml diff --git a/src/coreclr/System.Private.CoreLib/CompatibilitySuppressions.xml b/src/coreclr/System.Private.CoreLib/CompatibilitySuppressions.xml index eeca822db2da0c..df844ac3062e87 100644 --- a/src/coreclr/System.Private.CoreLib/CompatibilitySuppressions.xml +++ b/src/coreclr/System.Private.CoreLib/CompatibilitySuppressions.xml @@ -1,5 +1,6 @@  - + + CP0001 diff --git a/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj b/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj index ffb4e3179f85fd..e144c31e6a255e 100644 --- a/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj +++ b/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj @@ -25,6 +25,8 @@ + + diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs index 9e8eea5b6d4092..e5a9b031a9cc9b 100644 --- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs +++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs @@ -4962,14 +4962,14 @@ public void Vector128Int64IndexerTest(params long[] values) [Fact] public void Vector128DoubleEqualsNaNTest() { - Vector128 nan = Vector128.NaN; + Vector128 nan = Vector128.NaN; Assert.True(nan.Equals(nan)); } [Fact] public void Vector128SingleEqualsNaNTest() { - Vector128 nan = Vector128.NaN; + Vector128 nan = Vector128.NaN; Assert.True(nan.Equals(nan)); } diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs index 14c1c7e56040b4..a96f9975d3f524 100644 --- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs +++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs @@ -6145,14 +6145,14 @@ public void Vector256Int64IndexerTest(params long[] values) [Fact] public void Vector256DoubleEqualsNaNTest() { - Vector256 nan = Vector256.NaN; + Vector256 nan = Vector256.NaN; Assert.True(nan.Equals(nan)); } [Fact] public void Vector256SingleEqualsNaNTest() { - Vector256 nan = Vector256.NaN; + Vector256 nan = Vector256.NaN; Assert.True(nan.Equals(nan)); } diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs index 06e09be9daaa31..c7cadd9ebe03ae 100644 --- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs +++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs @@ -5973,14 +5973,14 @@ public void Vector512Int64IndexerTest(params long[] values) [Fact] public void Vector512DoubleEqualsNaNTest() { - Vector512 nan = Vector512.NaN; + Vector512 nan = Vector512.NaN; Assert.True(nan.Equals(nan)); } [Fact] public void Vector512SingleEqualsNaNTest() { - Vector512 nan = Vector512.NaN; + Vector512 nan = Vector512.NaN; Assert.True(nan.Equals(nan)); } diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs index 88869d71914b76..ea82662451e4cc 100644 --- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs +++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs @@ -4243,14 +4243,14 @@ public void Vector64Int64IndexerTest(params long[] values) [Fact] public void Vector64DoubleEqualsNaNTest() { - Vector64 nan = Vector64.NaN; + Vector64 nan = Vector64.NaN; Assert.True(nan.Equals(nan)); } [Fact] public void Vector64SingleEqualsNaNTest() { - Vector64 nan = Vector64.NaN; + Vector64 nan = Vector64.NaN; Assert.True(nan.Equals(nan)); } diff --git a/src/mono/System.Private.CoreLib/CompatibilitySuppressions.xml b/src/mono/System.Private.CoreLib/CompatibilitySuppressions.xml new file mode 100644 index 00000000000000..df844ac3062e87 --- /dev/null +++ b/src/mono/System.Private.CoreLib/CompatibilitySuppressions.xml @@ -0,0 +1,95 @@ + + + + + + CP0001 + T:System.Numerics.Vector.<>E__0`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Numerics.Vector.<>E__1`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Numerics.Vector.<>E__2`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector128.<>E__0`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector128.<>E__1`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector128.<>E__2`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector256.<>E__0`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector256.<>E__1`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector256.<>E__2`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector512.<>E__0`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector512.<>E__1`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector512.<>E__2`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector64.<>E__0`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector64.<>E__1`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + + CP0001 + T:System.Runtime.Intrinsics.Vector64.<>E__2`1 + ref/net10.0/System.Private.CoreLib.dll + lib/net10.0/System.Private.CoreLib.dll + + diff --git a/src/mono/System.Private.CoreLib/System.Private.CoreLib.csproj b/src/mono/System.Private.CoreLib/System.Private.CoreLib.csproj index 1ef2c0a4aa22da..26ff31c43a0b9d 100644 --- a/src/mono/System.Private.CoreLib/System.Private.CoreLib.csproj +++ b/src/mono/System.Private.CoreLib/System.Private.CoreLib.csproj @@ -15,6 +15,12 @@ true + + + + + + From df6a9fa0cfc976807526abeefa67e178b0a0500d Mon Sep 17 00:00:00 2001 From: Tanner Gooding Date: Wed, 23 Jul 2025 10:54:20 -0700 Subject: [PATCH 04/10] Update src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs --- .../src/System/Runtime/Intrinsics/Vector64.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 e2a5bd6914a623..7727fe68adcaf9 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 @@ -1981,7 +1981,7 @@ public static Vector64 IsNegativeInfinity(Vector64 vector) } else if (typeof(T) == typeof(double)) { - return Equals(vector, Vector64.PositiveInfinity.As()); + return Equals(vector, Vector64.NegativeInfinity.As()); } return Vector64.Zero; } From 1fc18b857f15aca72abf8f33cad370274c8e28ad Mon Sep 17 00:00:00 2001 From: Tanner Gooding Date: Wed, 23 Jul 2025 12:52:15 -0700 Subject: [PATCH 05/10] Fixing a couple additional tests --- .../Regression/GitHub_17073/GitHub_17073.cs | 480 +++++++++--------- .../GitHub_17073/GitHub_17073_gen.csx | 6 +- .../ImageSharp_2117/ImageSharp_2117.cs | 4 +- .../JitBlue/Runtime_92590/Runtime_92590.cs | 4 +- 4 files changed, 249 insertions(+), 245 deletions(-) diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073.cs b/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073.cs index 454a1f499c50b2..ce42ec5eeb9f36 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073.cs +++ b/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073.cs @@ -26,603 +26,603 @@ public static void Test() r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f))); r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f))); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); - r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.NaN)); + r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0))); r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0))); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); - r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.NaN)); + r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.NaN, Vector128.NaN)); r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Normal(Vector128.Zero, Vector128.Zero)); r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Normal(Vector128.One, Vector128.Create(2))); r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_Normal(Vector128.Create(2), Vector128.Create(3))); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073_gen.csx b/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073_gen.csx index 2bbfeace2e35b0..f0591c85c0a97f 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073_gen.csx +++ b/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073_gen.csx @@ -169,11 +169,13 @@ static string CreateVector(int vectorSize, string vectorElementType, double valu { if (vectorElementType == "Single") return double.IsNaN(value) ? $"Vector{vectorSize}.NaN" : + (value == 0.0f) && float.IsPositive(value) ? $"Vector{vectorSize}.Zero" : (value == 1.0f) ? $"Vector{vectorSize}.One" : (value == -1.0f) ? $"Vector{vectorSize}.NegativeOne" : $"Vector{vectorSize}.Create({value:F1}f)"; if (vectorElementType == "Double") return double.IsNaN(value) ? $"Vector{vectorSize}.NaN" + (value == 0.0) && double.IsPositive(value) ? $"Vector{vectorSize}.Zero" : (value == 1.0) ? $"Vector{vectorSize}.One" : (value == -1.0) ? $"Vector{vectorSize}.NegativeOne" : $"Vector{vectorSize}.Create({value:F1})"; @@ -182,7 +184,9 @@ static string CreateVector(int vectorSize, string vectorElementType, double valu static string CreateVector(int vectorSize, int value) { - return $"Vector{vectorSize}.Create({value})"; + return (value == 0) ? $"Vector{vectorSize}.Zero" : + (value == 1) ? $"Vector{vectorSize}.One" : + $"Vector{vectorSize}.Create({value})"; } static string CreateVector(int vectorSize, string vectorElementType, T value) diff --git a/src/tests/JIT/Regression/JitBlue/ImageSharp_2117/ImageSharp_2117.cs b/src/tests/JIT/Regression/JitBlue/ImageSharp_2117/ImageSharp_2117.cs index c7d888033dc0c5..ac92f6a355c7b5 100644 --- a/src/tests/JIT/Regression/JitBlue/ImageSharp_2117/ImageSharp_2117.cs +++ b/src/tests/JIT/Regression/JitBlue/ImageSharp_2117/ImageSharp_2117.cs @@ -12,7 +12,7 @@ public static int TestEntryPoint() { if (Sse.IsSupported) { - Vector128 fnan = Vector128.NaN; + Vector128 fnan = Vector128.NaN; Vector128 res1 = Sse.Max(Sse.LoadVector128((float*)(&fnan)), Vector128.Zero); Vector128 res2 = Sse.Min(Sse.LoadVector128((float*)(&fnan)), Vector128.Zero); @@ -24,7 +24,7 @@ public static int TestEntryPoint() if (Sse2.IsSupported) { - Vector128 dnan = Vector128.NaN; + Vector128 dnan = Vector128.NaN; Vector128 res3 = Sse2.Max(Sse2.LoadVector128((double*)(&dnan)), Vector128.Zero); Vector128 res4 = Sse2.Min(Sse2.LoadVector128((double*)(&dnan)), Vector128.Zero); diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_92590/Runtime_92590.cs b/src/tests/JIT/Regression/JitBlue/Runtime_92590/Runtime_92590.cs index dd01b9ab9bda06..b010525c692131 100644 --- a/src/tests/JIT/Regression/JitBlue/Runtime_92590/Runtime_92590.cs +++ b/src/tests/JIT/Regression/JitBlue/Runtime_92590/Runtime_92590.cs @@ -13,7 +13,7 @@ public static void TestEntryPoint() { Span bytes = stackalloc byte[4]; bytes.Fill(0xff); - TestByteByte(ref bytes[0], 0, Vector256.One; + TestByteByte(ref bytes[0], 0, Vector256.One); Assert.True(bytes.SequenceEqual(stackalloc byte[] { 0x2, 0xff, 0xff, 0xff })); @@ -23,7 +23,7 @@ public static void TestEntryPoint() Assert.True(bytes.SequenceEqual(stackalloc byte[] { 0x2, 0xff, 0xff, 0xff })); int i = int.MaxValue; - TestIntByte(ref i, 0, Vector256.One; + TestIntByte(ref i, 0, Vector256.One); Assert.Equal(2, i); From a842d7dfc12134b820b7b66f1da300591fb7747d Mon Sep 17 00:00:00 2001 From: Tanner Gooding Date: Wed, 23 Jul 2025 12:52:27 -0700 Subject: [PATCH 06/10] Have the linker preserve the `extension marker method` if the type is preserved --- .../CompatibilitySuppressions.xml | 95 ------------------- .../System.Private.CoreLib.csproj | 6 -- .../CompatibilitySuppressions.xml | 95 ------------------- .../System.Private.CoreLib.csproj | 6 -- .../src/linker/Linker.Steps/MarkStep.cs | 6 ++ .../Linker/MethodDefinitionExtensions.cs | 18 ++++ 6 files changed, 24 insertions(+), 202 deletions(-) delete mode 100644 src/coreclr/System.Private.CoreLib/CompatibilitySuppressions.xml delete mode 100644 src/mono/System.Private.CoreLib/CompatibilitySuppressions.xml diff --git a/src/coreclr/System.Private.CoreLib/CompatibilitySuppressions.xml b/src/coreclr/System.Private.CoreLib/CompatibilitySuppressions.xml deleted file mode 100644 index df844ac3062e87..00000000000000 --- a/src/coreclr/System.Private.CoreLib/CompatibilitySuppressions.xml +++ /dev/null @@ -1,95 +0,0 @@ - - - - - - CP0001 - T:System.Numerics.Vector.<>E__0`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Numerics.Vector.<>E__1`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Numerics.Vector.<>E__2`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector128.<>E__0`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector128.<>E__1`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector128.<>E__2`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector256.<>E__0`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector256.<>E__1`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector256.<>E__2`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector512.<>E__0`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector512.<>E__1`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector512.<>E__2`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector64.<>E__0`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector64.<>E__1`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector64.<>E__2`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - diff --git a/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj b/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj index e144c31e6a255e..2fb4c3e7ffa6bb 100644 --- a/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj +++ b/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj @@ -24,12 +24,6 @@ true - - - - - - diff --git a/src/mono/System.Private.CoreLib/CompatibilitySuppressions.xml b/src/mono/System.Private.CoreLib/CompatibilitySuppressions.xml deleted file mode 100644 index df844ac3062e87..00000000000000 --- a/src/mono/System.Private.CoreLib/CompatibilitySuppressions.xml +++ /dev/null @@ -1,95 +0,0 @@ - - - - - - CP0001 - T:System.Numerics.Vector.<>E__0`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Numerics.Vector.<>E__1`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Numerics.Vector.<>E__2`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector128.<>E__0`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector128.<>E__1`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector128.<>E__2`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector256.<>E__0`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector256.<>E__1`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector256.<>E__2`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector512.<>E__0`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector512.<>E__1`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector512.<>E__2`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector64.<>E__0`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector64.<>E__1`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - - CP0001 - T:System.Runtime.Intrinsics.Vector64.<>E__2`1 - ref/net10.0/System.Private.CoreLib.dll - lib/net10.0/System.Private.CoreLib.dll - - diff --git a/src/mono/System.Private.CoreLib/System.Private.CoreLib.csproj b/src/mono/System.Private.CoreLib/System.Private.CoreLib.csproj index 26ff31c43a0b9d..1ef2c0a4aa22da 100644 --- a/src/mono/System.Private.CoreLib/System.Private.CoreLib.csproj +++ b/src/mono/System.Private.CoreLib/System.Private.CoreLib.csproj @@ -15,12 +15,6 @@ true - - - - - - diff --git a/src/tools/illink/src/linker/Linker.Steps/MarkStep.cs b/src/tools/illink/src/linker/Linker.Steps/MarkStep.cs index ffdd348619827e..7346114bfe21bf 100644 --- a/src/tools/illink/src/linker/Linker.Steps/MarkStep.cs +++ b/src/tools/illink/src/linker/Linker.Steps/MarkStep.cs @@ -2232,6 +2232,12 @@ internal void MarkStaticConstructorVisibleToReflection(TypeDefinition type, in D // For methods that must be preserved, blame the declaring type. MarkMethod(method, new DependencyInfo(DependencyKind.VirtualNeededDueToPreservedScope, type), typeOrigin); } + else if (method.IsExtensionMarkerMethod()) + { + // Extension marker methods are private, but are key metadata used by tooling, + // they should be preserved if the corresponding type is preserved. + MarkMethod(method, new DependencyInfo(DependencyKind.TypePreserve, type), typeOrigin); + } } if (ShouldMarkTypeStaticConstructor(type) && reason.Kind != DependencyKind.TriggersCctorForCalledMethod) { diff --git a/src/tools/illink/src/linker/Linker/MethodDefinitionExtensions.cs b/src/tools/illink/src/linker/Linker/MethodDefinitionExtensions.cs index 8d0884f3115542..3664476f421128 100644 --- a/src/tools/illink/src/linker/Linker/MethodDefinitionExtensions.cs +++ b/src/tools/illink/src/linker/Linker/MethodDefinitionExtensions.cs @@ -93,6 +93,24 @@ public static bool IsStaticConstructor(this MethodDefinition method) return method.IsConstructor && method.IsStatic; } + public static bool IsExtensionMarkerMethod(this MethodDefinition method) + { + TypeDefinition declaringType = method.DeclaringType; + + if (!declaringType.IsSpecialName || + !declaringType.IsSealed || + !declaringType.IsNestedPublic || + declaringType.HasInterfaces) + { + return false; + } + + return method.IsSpecialName && + method.IsStatic && + method.IsPrivate && + method.Name.Equals("$"); + } + public static void ClearDebugInformation(this MethodDefinition method) { // TODO: This always allocates, update when Cecil catches up From b47945b5cf89ec390037e7de34b34fc5099a6f9b Mon Sep 17 00:00:00 2001 From: Tanner Gooding Date: Wed, 23 Jul 2025 15:34:52 -0700 Subject: [PATCH 07/10] Have TestConstant check for IsNaN rather than a specific bit pattern --- .../tests/GenericVectorTests.cs | 18 ++++++++++++++++-- .../tests/Vectors/Vector128Tests.cs | 18 ++++++++++++++++-- .../tests/Vectors/Vector256Tests.cs | 18 ++++++++++++++++-- .../tests/Vectors/Vector512Tests.cs | 18 ++++++++++++++++-- .../tests/Vectors/Vector64Tests.cs | 18 ++++++++++++++++-- 5 files changed, 80 insertions(+), 10 deletions(-) diff --git a/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs b/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs index 052a4ce76c4918..f18f9ff9278419 100644 --- a/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs +++ b/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs @@ -6151,7 +6151,14 @@ private void TestConstant(Vector actual, double expected) { for (int i = 0; i < Vector.Count; i++) { - Assert.Equal(BitConverter.DoubleToInt64Bits(expected), BitConverter.DoubleToInt64Bits(actual[i])); + if (double.IsNaN(expected)) + { + Assert.True(double.IsNaN(actual[i])); + } + else + { + Assert.Equal(BitConverter.DoubleToInt64Bits(expected), BitConverter.DoubleToInt64Bits(actual[i])); + } } } @@ -6160,7 +6167,14 @@ private void TestConstant(Vector actual, float expected) { for (int i = 0; i < Vector.Count; i++) { - Assert.Equal(BitConverter.SingleToInt32Bits(expected), BitConverter.SingleToInt32Bits(actual[i])); + if (float.IsNaN(expected)) + { + Assert.True(float.IsNaN(actual[i])); + } + else + { + Assert.Equal(BitConverter.SingleToInt32Bits(expected), BitConverter.SingleToInt32Bits(actual[i])); + } } } diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs index e5a9b031a9cc9b..9414c26d4ede46 100644 --- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs +++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs @@ -7007,7 +7007,14 @@ private void TestConstant(Vector128 actual, double expected) { for (int i = 0; i < Vector128.Count; i++) { - Assert.Equal(BitConverter.DoubleToInt64Bits(expected), BitConverter.DoubleToInt64Bits(actual[i])); + if (double.IsNaN(expected)) + { + Assert.True(double.IsNaN(actual[i])); + } + else + { + Assert.Equal(BitConverter.DoubleToInt64Bits(expected), BitConverter.DoubleToInt64Bits(actual[i])); + } } } @@ -7016,7 +7023,14 @@ private void TestConstant(Vector128 actual, float expected) { for (int i = 0; i < Vector128.Count; i++) { - Assert.Equal(BitConverter.SingleToInt32Bits(expected), BitConverter.SingleToInt32Bits(actual[i])); + if (float.IsNaN(expected)) + { + Assert.True(float.IsNaN(actual[i])); + } + else + { + Assert.Equal(BitConverter.SingleToInt32Bits(expected), BitConverter.SingleToInt32Bits(actual[i])); + } } } diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs index a96f9975d3f524..db022b7bb4e752 100644 --- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs +++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs @@ -8183,7 +8183,14 @@ private void TestConstant(Vector256 actual, double expected) { for (int i = 0; i < Vector256.Count; i++) { - Assert.Equal(BitConverter.DoubleToInt64Bits(expected), BitConverter.DoubleToInt64Bits(actual[i])); + if (double.IsNaN(expected)) + { + Assert.True(double.IsNaN(actual[i])); + } + else + { + Assert.Equal(BitConverter.DoubleToInt64Bits(expected), BitConverter.DoubleToInt64Bits(actual[i])); + } } } @@ -8192,7 +8199,14 @@ private void TestConstant(Vector256 actual, float expected) { for (int i = 0; i < Vector256.Count; i++) { - Assert.Equal(BitConverter.SingleToInt32Bits(expected), BitConverter.SingleToInt32Bits(actual[i])); + if (float.IsNaN(expected)) + { + Assert.True(float.IsNaN(actual[i])); + } + else + { + Assert.Equal(BitConverter.SingleToInt32Bits(expected), BitConverter.SingleToInt32Bits(actual[i])); + } } } diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs index c7cadd9ebe03ae..098e3e5cffb308 100644 --- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs +++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs @@ -7966,7 +7966,14 @@ private void TestConstant(Vector512 actual, double expected) { for (int i = 0; i < Vector512.Count; i++) { - Assert.Equal(BitConverter.DoubleToInt64Bits(expected), BitConverter.DoubleToInt64Bits(actual[i])); + if (double.IsNaN(expected)) + { + Assert.True(double.IsNaN(actual[i])); + } + else + { + Assert.Equal(BitConverter.DoubleToInt64Bits(expected), BitConverter.DoubleToInt64Bits(actual[i])); + } } } @@ -7975,7 +7982,14 @@ private void TestConstant(Vector512 actual, float expected) { for (int i = 0; i < Vector512.Count; i++) { - Assert.Equal(BitConverter.SingleToInt32Bits(expected), BitConverter.SingleToInt32Bits(actual[i])); + if (float.IsNaN(expected)) + { + Assert.True(float.IsNaN(actual[i])); + } + else + { + Assert.Equal(BitConverter.SingleToInt32Bits(expected), BitConverter.SingleToInt32Bits(actual[i])); + } } } diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs index ea82662451e4cc..1184256bc4ac04 100644 --- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs +++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs @@ -6271,7 +6271,14 @@ private void TestConstant(Vector64 actual, double expected) { for (int i = 0; i < Vector64.Count; i++) { - Assert.Equal(BitConverter.DoubleToInt64Bits(expected), BitConverter.DoubleToInt64Bits(actual[i])); + if (double.IsNaN(expected)) + { + Assert.True(double.IsNaN(actual[i])); + } + else + { + Assert.Equal(BitConverter.DoubleToInt64Bits(expected), BitConverter.DoubleToInt64Bits(actual[i])); + } } } @@ -6280,7 +6287,14 @@ private void TestConstant(Vector64 actual, float expected) { for (int i = 0; i < Vector64.Count; i++) { - Assert.Equal(BitConverter.SingleToInt32Bits(expected), BitConverter.SingleToInt32Bits(actual[i])); + if (float.IsNaN(expected)) + { + Assert.True(float.IsNaN(actual[i])); + } + else + { + Assert.Equal(BitConverter.SingleToInt32Bits(expected), BitConverter.SingleToInt32Bits(actual[i])); + } } } From 2bce8ce04c527678ca1bc4646d47f5c1d6ec7e52 Mon Sep 17 00:00:00 2001 From: Tanner Gooding Date: Sun, 3 Aug 2025 06:30:30 -0700 Subject: [PATCH 08/10] Remove linker workaround for extension members --- .../src/CompatibilitySuppressions.xml | 2 +- .../illink/src/linker/Linker.Steps/MarkStep.cs | 6 ------ .../Linker/MethodDefinitionExtensions.cs | 18 ------------------ 3 files changed, 1 insertion(+), 25 deletions(-) diff --git a/src/libraries/System.Private.CoreLib/src/CompatibilitySuppressions.xml b/src/libraries/System.Private.CoreLib/src/CompatibilitySuppressions.xml index 01683374a671f8..21e9323f9e7168 100644 --- a/src/libraries/System.Private.CoreLib/src/CompatibilitySuppressions.xml +++ b/src/libraries/System.Private.CoreLib/src/CompatibilitySuppressions.xml @@ -1,5 +1,5 @@  - + CP0001 diff --git a/src/tools/illink/src/linker/Linker.Steps/MarkStep.cs b/src/tools/illink/src/linker/Linker.Steps/MarkStep.cs index b2cfaf1a8858d8..6eda4e165992f0 100644 --- a/src/tools/illink/src/linker/Linker.Steps/MarkStep.cs +++ b/src/tools/illink/src/linker/Linker.Steps/MarkStep.cs @@ -2221,12 +2221,6 @@ internal void MarkStaticConstructorVisibleToReflection(TypeDefinition type, in D // For methods that must be preserved, blame the declaring type. MarkMethod(method, new DependencyInfo(DependencyKind.VirtualNeededDueToPreservedScope, type), typeOrigin); } - else if (method.IsExtensionMarkerMethod()) - { - // Extension marker methods are private, but are key metadata used by tooling, - // they should be preserved if the corresponding type is preserved. - MarkMethod(method, new DependencyInfo(DependencyKind.TypePreserve, type), typeOrigin); - } } if (ShouldMarkTypeStaticConstructor(type) && reason.Kind != DependencyKind.TriggersCctorForCalledMethod) { diff --git a/src/tools/illink/src/linker/Linker/MethodDefinitionExtensions.cs b/src/tools/illink/src/linker/Linker/MethodDefinitionExtensions.cs index 3664476f421128..8d0884f3115542 100644 --- a/src/tools/illink/src/linker/Linker/MethodDefinitionExtensions.cs +++ b/src/tools/illink/src/linker/Linker/MethodDefinitionExtensions.cs @@ -93,24 +93,6 @@ public static bool IsStaticConstructor(this MethodDefinition method) return method.IsConstructor && method.IsStatic; } - public static bool IsExtensionMarkerMethod(this MethodDefinition method) - { - TypeDefinition declaringType = method.DeclaringType; - - if (!declaringType.IsSpecialName || - !declaringType.IsSealed || - !declaringType.IsNestedPublic || - declaringType.HasInterfaces) - { - return false; - } - - return method.IsSpecialName && - method.IsStatic && - method.IsPrivate && - method.Name.Equals("$"); - } - public static void ClearDebugInformation(this MethodDefinition method) { // TODO: This always allocates, update when Cecil catches up From ea7063d6e344860edc8fe66a7139ca1230f40c93 Mon Sep 17 00:00:00 2001 From: Tanner Gooding Date: Sun, 3 Aug 2025 06:34:55 -0700 Subject: [PATCH 09/10] Update src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073_gen.csx Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- .../X86/Regression/GitHub_17073/GitHub_17073_gen.csx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073_gen.csx b/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073_gen.csx index f0591c85c0a97f..3b606cef64b446 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073_gen.csx +++ b/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073_gen.csx @@ -174,7 +174,7 @@ static string CreateVector(int vectorSize, string vectorElementType, double valu (value == -1.0f) ? $"Vector{vectorSize}.NegativeOne" : $"Vector{vectorSize}.Create({value:F1}f)"; if (vectorElementType == "Double") - return double.IsNaN(value) ? $"Vector{vectorSize}.NaN" + return double.IsNaN(value) ? $"Vector{vectorSize}.NaN" : (value == 0.0) && double.IsPositive(value) ? $"Vector{vectorSize}.Zero" : (value == 1.0) ? $"Vector{vectorSize}.One" : (value == -1.0) ? $"Vector{vectorSize}.NegativeOne" : From 2400bab65b2dc508fb54fdfd15a95aba89f3c690 Mon Sep 17 00:00:00 2001 From: Tanner Gooding Date: Tue, 19 Aug 2025 13:05:41 -0700 Subject: [PATCH 10/10] Don't override the toolset compiler for runtime tests --- src/tests/Directory.Build.props | 6 ------ src/tests/async/Directory.Build.props | 1 + 2 files changed, 1 insertion(+), 6 deletions(-) diff --git a/src/tests/Directory.Build.props b/src/tests/Directory.Build.props index 604e7fc6f20b0a..136b5db5ae4eb0 100644 --- a/src/tests/Directory.Build.props +++ b/src/tests/Directory.Build.props @@ -8,12 +8,6 @@ - - - 5.0.0-1.25259.6 - Custom - - true diff --git a/src/tests/async/Directory.Build.props b/src/tests/async/Directory.Build.props index faf9886e152c5d..a1f7d48cf60a7d 100644 --- a/src/tests/async/Directory.Build.props +++ b/src/tests/async/Directory.Build.props @@ -9,6 +9,7 @@ false $(Features);runtime-async=on +